diff --git a/.gitignore b/.gitignore
index f1798bbc..78c7c665 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,19 +16,4 @@ mcp.json
tasks/
-# --- C# / Visual Studio (UWP) ---
-[Bb]in/
-[Oo]bj/
-.vs/
-*.user
-*.suo
-*.dbmdl
-*.jfm
-AppPackages/
-BundleArtifacts/
-*.appxupload
-*.msixupload
-*.appxbundle
-*.msixbundle
*.pfx
-Package.StoreAssociation.xml
diff --git a/AGENTS.md b/AGENTS.md
index 0fa95104..489f9f8b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -108,7 +108,7 @@ src-tauri/src/
### OBS 모드 (WebSocket 브릿지)
- **이벤트 포워딩**: 새 Tauri 이벤트(`app.emit(...)`)를 추가할 때, OBS 오버레이에도 전달되어야 하면 `src-tauri/src/services/obs_bridge.rs`의 `register_event_forwarding()` 이벤트 목록에 등록
-- **deny 리스트**: OBS 클라이언트에서 실행 불가능한 커맨드는 `obs_bridge.rs`의 `DENIED_WS_COMMANDS`에 등록 (백엔드가 유일한 source of truth)
+- **allowlist**: OBS 클라이언트에서 실행 가능한 커맨드만 `obs_bridge.rs`의 `ALLOWED_WS_COMMANDS`에 등록 (정확 일치, fail-closed — 목록에 없으면 차단, 백엔드가 유일한 source of truth). 신규 커맨드를 OBS에 노출하려면 검토 후 명시적으로 추가
- **IPC shim**: `src/renderer/api/ipcShim.ts`는 generic 설계 — 커맨드/이벤트별 분기 없음. 이벤트나 커맨드 추가 시 수정 불필요
### 주석
diff --git a/CLAUDE.md b/CLAUDE.md
index 4156b55a..3e6499b5 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -108,7 +108,7 @@ src-tauri/src/
### OBS 모드 (WebSocket 브릿지)
- **이벤트 포워딩**: 새 Tauri 이벤트(`app.emit(...)`)를 추가할 때, OBS 오버레이에도 전달되어야 하면 `src-tauri/src/services/obs_bridge.rs`의 `register_event_forwarding()` 이벤트 목록에 등록
-- **deny 리스트**: OBS 클라이언트에서 실행 불가능한 커맨드는 `obs_bridge.rs`의 `DENIED_WS_COMMANDS`에 등록 (백엔드가 유일한 source of truth)
+- **allowlist**: OBS 클라이언트에서 실행 가능한 커맨드만 `obs_bridge.rs`의 `ALLOWED_WS_COMMANDS`에 등록 (정확 일치, fail-closed — 목록에 없으면 차단, 백엔드가 유일한 source of truth). 신규 커맨드를 OBS에 노출하려면 검토 후 명시적으로 추가
- **IPC shim**: `src/renderer/api/ipcShim.ts`는 generic 설계 — 커맨드/이벤트별 분기 없음. 이벤트나 커맨드 추가 시 수정 불필요
### 주석
diff --git a/GameBarOverlay/App.xaml b/GameBarOverlay/App.xaml
deleted file mode 100644
index a0e62b51..00000000
--- a/GameBarOverlay/App.xaml
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-
-
-
diff --git a/GameBarOverlay/App.xaml.cs b/GameBarOverlay/App.xaml.cs
deleted file mode 100644
index ff5520a2..00000000
--- a/GameBarOverlay/App.xaml.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-using System;
-using Windows.ApplicationModel;
-using Windows.ApplicationModel.Activation;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Navigation;
-using Microsoft.Gaming.XboxGameBar;
-
-namespace GameBarOverlay
-{
- public sealed partial class App : Application
- {
- private XboxGameBarWidget widget;
-
- public App()
- {
- Environment.SetEnvironmentVariable("WEBVIEW2_DEFAULT_BACKGROUND_COLOR", "00FFFFFF");
- InitializeComponent();
- Suspending += OnSuspending;
- }
-
- protected override void OnLaunched(LaunchActivatedEventArgs e)
- {
- if (e.PrelaunchActivated)
- {
- return;
- }
-
- var rootFrame = EnsureRootFrame();
- if (rootFrame.Content == null)
- {
- rootFrame.Navigate(typeof(MainPage));
- }
-
- Window.Current.Activate();
- }
-
- protected override void OnActivated(IActivatedEventArgs e)
- {
- XboxGameBarWidgetActivatedEventArgs widgetArgs = null;
- if (e.Kind == ActivationKind.Protocol)
- {
- var protocolArgs = e as IProtocolActivatedEventArgs;
- if (
- protocolArgs != null
- && protocolArgs.Uri != null
- && string.Equals(
- protocolArgs.Uri.Scheme,
- "ms-gamebarwidget",
- StringComparison.OrdinalIgnoreCase
- )
- )
- {
- widgetArgs = e as XboxGameBarWidgetActivatedEventArgs;
- }
- }
-
- if (widgetArgs == null)
- {
- base.OnActivated(e);
- return;
- }
-
- NavigateToWidgetShell(widgetArgs);
- }
-
- private void NavigateToWidgetShell(XboxGameBarWidgetActivatedEventArgs widgetArgs)
- {
- var rootFrame = EnsureRootFrame();
- if (widgetArgs.IsLaunchActivation || widget == null)
- {
- widget = new XboxGameBarWidget(widgetArgs, Window.Current.CoreWindow, rootFrame);
- Window.Current.Closed -= OnWidgetWindowClosed;
- Window.Current.Closed += OnWidgetWindowClosed;
- }
-
- var page = rootFrame.Content as MainPage;
- if (page == null)
- {
- rootFrame.Navigate(typeof(MainPage), widget);
- }
- else
- {
- page.AttachWidget(widget);
- }
-
- page = rootFrame.Content as MainPage;
- if (page != null)
- {
- page.HandleActivation();
- }
-
- Window.Current.Activate();
- }
-
- private Frame EnsureRootFrame()
- {
- if (Window.Current.Content is Frame rootFrame)
- {
- return rootFrame;
- }
-
- rootFrame = new Frame();
- rootFrame.NavigationFailed += OnNavigationFailed;
- Window.Current.Content = rootFrame;
- return rootFrame;
- }
-
- private void OnWidgetWindowClosed(object sender, Windows.UI.Core.CoreWindowEventArgs e)
- {
- widget = null;
- Window.Current.Closed -= OnWidgetWindowClosed;
- }
-
- private void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
- {
- throw new Exception($"Failed to load page '{e.SourcePageType.FullName}'.");
- }
-
- private void OnSuspending(object sender, SuspendingEventArgs e)
- {
- var deferral = e.SuspendingOperation.GetDeferral();
- widget = null;
- deferral.Complete();
- }
- }
-}
diff --git a/GameBarOverlay/Assets/LockScreenLogo.scale-200.png b/GameBarOverlay/Assets/LockScreenLogo.scale-200.png
deleted file mode 100644
index 735f57ad..00000000
Binary files a/GameBarOverlay/Assets/LockScreenLogo.scale-200.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/SplashScreen.scale-200.png b/GameBarOverlay/Assets/SplashScreen.scale-200.png
deleted file mode 100644
index 88bf4a7e..00000000
Binary files a/GameBarOverlay/Assets/SplashScreen.scale-200.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/Square150x150Logo.scale-200.png b/GameBarOverlay/Assets/Square150x150Logo.scale-200.png
deleted file mode 100644
index 72555b3b..00000000
Binary files a/GameBarOverlay/Assets/Square150x150Logo.scale-200.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/Square44x44Logo.scale-200.png b/GameBarOverlay/Assets/Square44x44Logo.scale-200.png
deleted file mode 100644
index 13c10472..00000000
Binary files a/GameBarOverlay/Assets/Square44x44Logo.scale-200.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/Square44x44Logo.targetsize-24_altform-unplated.png b/GameBarOverlay/Assets/Square44x44Logo.targetsize-24_altform-unplated.png
deleted file mode 100644
index debc4b89..00000000
Binary files a/GameBarOverlay/Assets/Square44x44Logo.targetsize-24_altform-unplated.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/StoreLogo.png b/GameBarOverlay/Assets/StoreLogo.png
deleted file mode 100644
index 5772d970..00000000
Binary files a/GameBarOverlay/Assets/StoreLogo.png and /dev/null differ
diff --git a/GameBarOverlay/Assets/Wide310x150Logo.scale-200.png b/GameBarOverlay/Assets/Wide310x150Logo.scale-200.png
deleted file mode 100644
index 73d756e5..00000000
Binary files a/GameBarOverlay/Assets/Wide310x150Logo.scale-200.png and /dev/null differ
diff --git a/GameBarOverlay/GameBar/README.txt b/GameBarOverlay/GameBar/README.txt
deleted file mode 100644
index 074630d2..00000000
--- a/GameBarOverlay/GameBar/README.txt
+++ /dev/null
@@ -1 +0,0 @@
-Game Bar public folder placeholder.
diff --git a/GameBarOverlay/GameBarOverlay.csproj b/GameBarOverlay/GameBarOverlay.csproj
deleted file mode 100644
index d807306e..00000000
--- a/GameBarOverlay/GameBarOverlay.csproj
+++ /dev/null
@@ -1,195 +0,0 @@
-
-
-
-
-
- Debug
- x86
- {591B01BF-71B2-4E7A-9AD2-97BF8EC4C490}
- AppContainerExe
- Properties
- GameBarOverlay
- GameBarOverlay
- ko-KR
- UAP
- 10.0.26100.0
- 10.0.18362.0
- 14
- 512
- {A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
- true
- PackageReference
- False
- false
- false
- false
- true
- Always
- x86|x64|arm64
- 0
-
-
-
- true
- bin\x86\Debug\
- DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP
- ;2008
- full
- x86
- false
- prompt
- true
-
-
-
- bin\x86\Release\
- TRACE;NETFX_CORE;WINDOWS_UWP
- true
- ;2008
- pdbonly
- x86
- false
- prompt
- true
- true
-
-
-
- true
- bin\x64\Debug\
- DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP
- ;2008
- full
- x64
- false
- prompt
-
-
-
- bin\x64\Release\
- TRACE;NETFX_CORE;WINDOWS_UWP
- true
- ;2008
- pdbonly
- x64
- false
- prompt
- true
-
-
-
- true
- bin\ARM64\Debug\
- DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP
- ;2008
- full
- ARM64
- false
- prompt
- true
-
-
-
- bin\ARM64\Release\
- TRACE;NETFX_CORE;WINDOWS_UWP
- true
- ;2008
- pdbonly
- ARM64
- false
- prompt
- true
- true
-
-
-
-
- App.xaml
-
-
- MainPage.xaml
- Code
-
-
-
-
-
-
- MSBuild:Compile
- Designer
-
-
- MSBuild:Compile
- Designer
-
-
-
-
-
- Designer
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- $(NuGetPackageRoot)microsoft.gaming.xboxgamebar\7.3.2511061\lib\uap10.0\Microsoft.Gaming.XboxGameBar.winmd
- true
-
-
- $(NuGetPackageRoot)microsoft.ui.xaml\2.8.7\lib\uap10.0\Microsoft.UI.Xaml.winmd
- true
-
-
- $(NuGetPackageRoot)microsoft.web.webview2\1.0.2849.39\lib\Microsoft.Web.WebView2.Core.winmd
- true
-
-
-
-
- win32
- $(Platform)
-
-
-
- 18.0
- C:\Program Files (x86)\Microsoft SDKs\UWPNuGetPackages\microsoft.netcore.universalwindowsplatform\6.2.14\ref\uap10.0.15138
- $([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)\$(BaseIntermediateOutputPath)UwpReferenceAssemblies\'))
- $(UwpReferenceAssemblyCacheRoot)
- true
- <_TargetFrameworkDirectories Condition="Exists('$(UwpReferenceAssemblySource)')">$(UwpReferenceAssemblyCacheRoot).NETCore\v5.0\
- <_FullFrameworkReferenceAssemblyPaths Condition="Exists('$(UwpReferenceAssemblySource)')">$(UwpReferenceAssemblyCacheRoot).NETCore\v5.0\
- $(UwpReferenceAssemblyCacheRoot).NETCore\v5.0\
- $(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets
- C:\Program Files\Microsoft Visual Studio\18\Enterprise\MSBuild\Microsoft\WindowsXaml\v18.0\Microsoft.Windows.UI.Xaml.CSharp.Targets
-
-
-
-
-
-
-
- <_UwpReferenceAssembly Include="$(UwpReferenceAssemblySource)\*.dll" />
-
-
-
-
-
-
-
-
diff --git a/GameBarOverlay/GameBarOverlay.slnx b/GameBarOverlay/GameBarOverlay.slnx
deleted file mode 100644
index f42e857f..00000000
--- a/GameBarOverlay/GameBarOverlay.slnx
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/GameBarOverlay/MainPage.xaml b/GameBarOverlay/MainPage.xaml
deleted file mode 100644
index 6ecfb0e1..00000000
--- a/GameBarOverlay/MainPage.xaml
+++ /dev/null
@@ -1,35 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
diff --git a/GameBarOverlay/MainPage.xaml.cs b/GameBarOverlay/MainPage.xaml.cs
deleted file mode 100644
index a5523cc8..00000000
--- a/GameBarOverlay/MainPage.xaml.cs
+++ /dev/null
@@ -1,249 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Gaming.XboxGameBar;
-using Microsoft.UI.Xaml.Controls;
-using Microsoft.Web.WebView2.Core;
-using Windows.Foundation;
-using Windows.Data.Json;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Navigation;
-using Windows.Web.Http;
-
-namespace GameBarOverlay
-{
- public sealed partial class MainPage : Page
- {
- private const ushort DefaultBridgePort = 34891;
- private const int BridgePortScanCount = 10;
-
- private readonly DispatcherTimer reconnectTimer = new DispatcherTimer();
- private readonly HttpClient httpClient = new HttpClient();
-
- private bool connected;
- private bool isConnecting;
- private bool disposed;
- private XboxGameBarWidget widget;
-
- public MainPage()
- {
- InitializeComponent();
-
- Loaded += OnLoaded;
- Unloaded += OnUnloaded;
- OverlayWebView.NavigationCompleted += OnNavigationCompleted;
-
- reconnectTimer.Interval = TimeSpan.FromSeconds(5);
- reconnectTimer.Tick += OnReconnectTick;
- }
-
- protected override void OnNavigatedTo(NavigationEventArgs e)
- {
- base.OnNavigatedTo(e);
- AttachWidget(e.Parameter as XboxGameBarWidget);
- }
-
- public void AttachWidget(XboxGameBarWidget gameBarWidget)
- {
- if (object.ReferenceEquals(widget, gameBarWidget))
- {
- return;
- }
-
- DetachWidget();
- widget = gameBarWidget;
- if (widget == null)
- {
- ApplyWidgetState();
- return;
- }
-
- widget.MinWindowSize = new Size(360, 220);
- widget.MaxWindowSize = new Size(1920, 1080);
- widget.PinningSupported = true;
- widget.SettingsSupported = false;
- widget.VerticalResizeSupported = true;
- widget.RequestedThemeChanged += OnWidgetAppearanceChanged;
- widget.RequestedOpacityChanged += OnWidgetAppearanceChanged;
- widget.WindowStateChanged += OnWidgetWindowStateChanged;
- ApplyWidgetState();
- }
-
- public void HandleActivation()
- {
- _ = EnsureBridgeConnectedAsync();
- }
-
- private async void OnLoaded(object sender, RoutedEventArgs e)
- {
- reconnectTimer.Start();
- await EnsureBridgeConnectedAsync();
- }
-
- private void OnUnloaded(object sender, RoutedEventArgs e)
- {
- if (disposed)
- {
- return;
- }
-
- disposed = true;
- reconnectTimer.Stop();
- OverlayWebView.NavigationCompleted -= OnNavigationCompleted;
- OverlayWebView.Close();
- httpClient.Dispose();
- DetachWidget();
- }
-
- private async void OnReconnectTick(object sender, object e)
- {
- if (!connected)
- {
- await EnsureBridgeConnectedAsync();
- }
- }
-
- private async Task EnsureBridgeConnectedAsync()
- {
- if (disposed || connected || isConnecting)
- {
- return;
- }
-
- isConnecting = true;
- connected = false;
- StatusPanel.Visibility = Visibility.Visible;
- StatusText.Text = "로컬 브리지를 탐색하는 중";
-
- try
- {
- var bootstrap = await FindBootstrapAsync();
- if (bootstrap == null)
- {
- connected = false;
- StatusText.Text =
- "DmNote OBS 브리지를 찾지 못했습니다. Tauri 앱에서 OBS 모드를 먼저 시작하세요.";
- return;
- }
-
- await OverlayWebView.EnsureCoreWebView2Async();
- OverlayWebView.Source = new Uri(bootstrap.Url);
- StatusText.Text = "브리지에 연결했습니다. 오버레이를 로드하는 중";
- }
- catch (Exception ex)
- {
- connected = false;
- StatusText.Text = $"브리지 연결 실패: {ex.Message}";
- }
- finally
- {
- isConnecting = false;
- }
- }
-
- private void ApplyWidgetState()
- {
- if (widget == null)
- {
- RequestedTheme = ElementTheme.Default;
- RootGrid.Opacity = 1.0;
- return;
- }
-
- RequestedTheme = widget.RequestedTheme;
- RootGrid.Opacity = Math.Max(0.2, widget.RequestedOpacity);
- }
-
- private void DetachWidget()
- {
- if (widget == null)
- {
- return;
- }
-
- widget.RequestedThemeChanged -= OnWidgetAppearanceChanged;
- widget.RequestedOpacityChanged -= OnWidgetAppearanceChanged;
- widget.WindowStateChanged -= OnWidgetWindowStateChanged;
- widget = null;
- }
-
- private void OnWidgetAppearanceChanged(XboxGameBarWidget sender, object args)
- {
- ApplyWidgetState();
- }
-
- private void OnWidgetWindowStateChanged(XboxGameBarWidget sender, object args)
- {
- ApplyWidgetState();
- }
-
- private void OnNavigationCompleted(object sender, CoreWebView2NavigationCompletedEventArgs e)
- {
- connected = e.IsSuccess;
- if (connected)
- {
- StatusPanel.Visibility = Visibility.Collapsed;
- return;
- }
-
- StatusPanel.Visibility = Visibility.Visible;
- StatusText.Text = $"오버레이 로드 실패: {e.WebErrorStatus}";
- }
-
- private async Task FindBootstrapAsync()
- {
- for (var port = DefaultBridgePort; port < DefaultBridgePort + BridgePortScanCount; port++)
- {
- var bootstrap = await TryGetBootstrapAsync(port);
- if (bootstrap != null)
- {
- return bootstrap;
- }
- }
-
- return null;
- }
-
- private async Task TryGetBootstrapAsync(int port)
- {
- using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1)))
- {
- try
- {
- var response = await httpClient
- .GetAsync(new Uri($"http://127.0.0.1:{port}/gamebar/bootstrap.json"))
- .AsTask(cts.Token);
- if (!response.IsSuccessStatusCode)
- {
- return null;
- }
-
- var json = await response.Content.ReadAsStringAsync().AsTask(cts.Token);
- var obj = JsonObject.Parse(json);
- IJsonValue urlValue;
- if (!obj.TryGetValue("url", out urlValue))
- {
- return null;
- }
-
- return new GameBarBootstrap(urlValue.GetString());
- }
- catch
- {
- return null;
- }
- }
- }
-
- private sealed class GameBarBootstrap
- {
- public GameBarBootstrap(string url)
- {
- Url = url;
- }
-
- public string Url { get; }
- }
- }
-}
diff --git a/GameBarOverlay/Package.appxmanifest b/GameBarOverlay/Package.appxmanifest
deleted file mode 100644
index 4e2a539f..00000000
--- a/GameBarOverlay/Package.appxmanifest
+++ /dev/null
@@ -1,124 +0,0 @@
-
-
-
-
-
-
-
-
-
- GameBarOverlay
- esihunc
- Assets\StoreLogo.png
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- true
- true
- false
- false
-
- true
-
- 360
- 480
- 220
- 360
- 1080
- 1920
-
-
- true
- true
-
-
-
-
-
-
-
-
-
-
-
-
-
- Microsoft.Gaming.XboxGameBar.winmd
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/GameBarOverlay/Properties/AssemblyInfo.cs b/GameBarOverlay/Properties/AssemblyInfo.cs
deleted file mode 100644
index 9f66d963..00000000
--- a/GameBarOverlay/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("GameBarOverlay")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("GameBarOverlay")]
-[assembly: AssemblyCopyright("Copyright © 2026")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-[assembly: ComVisible(false)]
diff --git a/GameBarOverlay/Properties/Default.rd.xml b/GameBarOverlay/Properties/Default.rd.xml
deleted file mode 100644
index fa467633..00000000
--- a/GameBarOverlay/Properties/Default.rd.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-
-
-
diff --git a/GameBarOverlay/Properties/PublishProfiles/win-arm64.pubxml b/GameBarOverlay/Properties/PublishProfiles/win-arm64.pubxml
deleted file mode 100644
index 3481de2a..00000000
--- a/GameBarOverlay/Properties/PublishProfiles/win-arm64.pubxml
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
- FileSystem
- ARM64
- win-arm64
- bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\
- true
-
-
\ No newline at end of file
diff --git a/GameBarOverlay/Properties/PublishProfiles/win-x64.pubxml b/GameBarOverlay/Properties/PublishProfiles/win-x64.pubxml
deleted file mode 100644
index 4463ecc0..00000000
--- a/GameBarOverlay/Properties/PublishProfiles/win-x64.pubxml
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
- FileSystem
- x64
- win-x64
- bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\
- true
-
-
\ No newline at end of file
diff --git a/GameBarOverlay/Properties/PublishProfiles/win-x86.pubxml b/GameBarOverlay/Properties/PublishProfiles/win-x86.pubxml
deleted file mode 100644
index 31c51d68..00000000
--- a/GameBarOverlay/Properties/PublishProfiles/win-x86.pubxml
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
- FileSystem
- x86
- win-x86
- bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\
- true
-
-
\ No newline at end of file
diff --git a/GameBarOverlay/Properties/launchSettings.json b/GameBarOverlay/Properties/launchSettings.json
deleted file mode 100644
index aef8d0d3..00000000
--- a/GameBarOverlay/Properties/launchSettings.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
- "profiles": {
- "GameBarOverlay": {
- "commandName": "MsixPackage"
- }
- }
-}
\ No newline at end of file
diff --git a/THIRD_PARTY_NOTICES.txt b/THIRD_PARTY_NOTICES.txt
index 0980234e..c4ed537d 100644
--- a/THIRD_PARTY_NOTICES.txt
+++ b/THIRD_PARTY_NOTICES.txt
@@ -50,3 +50,127 @@ redistribution in binary form:
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Pretendard
+----------
+
+DM Note bundles the Pretendard variable font
+(src/renderer/assets/fonts/PretendardVariable.woff2), redistributed
+unmodified under the SIL Open Font License, Version 1.1.
+
+Copyright (c) 2021, Kil Hyung-jin (https://github.com/orioncactus/pretendard),
+with Reserved Font Name 'Pretendard'.
+
+Copyright 2014-2021 Adobe (http://www.adobe.com/),
+with Reserved Font Name 'Source'.
+Source is a trademark of Adobe in the United States and/or other countries.
+
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter),
+with Reserved Font Name 'Inter'.
+
+Copyright 2021 The M+ FONTS Project Authors (https://github.com/coz-m/MPLUS_FONTS),
+with Reserved Font Name 'M PLUS 1'.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply to any
+document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may include
+source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to
+a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer
+or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or in
+the appropriate machine-readable metadata fields within text or binary
+files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the
+corresponding Copyright Holder. This restriction only applies to the
+primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any Modified
+Version, except to acknowledge the contribution(s) of the Copyright
+Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+be distributed entirely under this license, and must not be distributed
+under any other license. The requirement for fonts to remain under this
+license does not apply to any document created using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+
+apple_cursor
+------------
+
+DM Note incorporates modified vector path data from the apple_cursor
+project by ful1e5 for its macOS resize cursors.
+
+Source: https://github.com/ful1e5/apple_cursor
+
+apple_cursor is licensed under the GNU General Public License, Version 3.
+DM Note redistributes the modified cursor data under GPL-3.0-only,
+consistent with DM Note's own license. The complete GNU GPL Version 3
+license text is included in the root LICENSE file.
diff --git a/docs/obs-mode-design.md b/docs/obs-mode-design.md
index ddd82f51..db4cff7b 100644
--- a/docs/obs-mode-design.md
+++ b/docs/obs-mode-design.md
@@ -29,7 +29,7 @@
→ [AppState (단일 상태 허브)]
├─ [기존 overlay window] ← OBS 모드 OFF
├─ [ObsBridgeService] ← OBS 모드 ON
- │ └─ WebSocket 서버 (localhost:PORT)
+ │ └─ WebSocket 서버 (0.0.0.0:PORT — 같은 네트워크 다른 PC 접속 지원, 토큰 인증)
│ ├─ HTTP: OBS 페이지 정적 파일 서빙 ✅
│ └─ WS: 키 이벤트 / 설정 / 레이아웃 브로드캐스트
└─ [Main window]
@@ -74,7 +74,7 @@
| 방향 | 타입 | 용도 | 빈도 | 상태 |
|------|------|------|------|------|
| C→S | `hello` | 최초 접속 핸드셰이크 | 1회 | ✅ |
-| S→C | `hello_ack` | 프로토콜 승인 + deny list | 1회 | ✅ |
+| S→C | `hello_ack` | 프로토콜 승인 + allow list | 1회 | ✅ |
| S→C | `snapshot` | 전체 상태 동기화 | 접속 시 + resync | ✅ |
| S→C | `tauri_event` | 범용 Tauri 이벤트 포워딩 | 빈번 | ✅ (v4: 기존 key_event/settings_diff/counter_update 통합) |
| C→S | `invoke_request` | 커맨드 실행 요청 (WS RPC) | 초기 + 간헐 | ✅ |
@@ -87,7 +87,7 @@
```
1. OBS 페이지 접속 (WS 직접 연결) ← v1: HTTP upgrade 없이 직접 WS
2. 클라이언트 → hello { client, protocol, appVersion, token }
-3. 서버 → hello_ack { serverVersion, obsMode, denyList }
+3. 서버 → hello_ack { serverVersion, obsMode, allowedList }
4. 서버 → snapshot { 전체 상태 }
5. 이후 tauri_event (keys:state, settings:changed 등) + invoke_request/invoke_response
6. seq gap 감지 시 → resync_request → snapshot 재전송
@@ -104,11 +104,15 @@
"client": "obs-browser",
"protocol": 1,
"appVersion": "1.5.2",
- "resumeFromSeq": 0
+ "resumeFromSeq": 0,
+ "token": "<세션 토큰>"
}
}
```
+서버는 `v`와 `payload.protocol`이 서버의 `OBS_PROTOCOL_VERSION`과 일치하지 않으면
+`error { code: "PROTOCOL_MISMATCH" }`를 보내고 연결을 종료한다 (fail-closed, 토큰 검증보다 먼저 수행).
+
#### snapshot (S→C) ✅
```json
{
@@ -543,13 +547,13 @@ OBS 환경:
|------|------|:---:|
| 프론트 IPC shim | `__TAURI_INTERNALS__` → WS RPC 교체 | **범용** |
| 프론트 이벤트 시스템 | 콜백 레지스트리 + `tauri_event` 디스패치 | **범용** |
-| 프론트 deny 체크 | `hello_ack`에서 수신한 단일 배열로 동적 구성 | **백엔드에서 수신 (관리 불필요)** |
+| 프론트 allow 체크 | `hello_ack`에서 수신한 단일 배열로 동적 구성 | **백엔드에서 수신 (관리 불필요)** |
| 백엔드 WS RPC | `invoke_request` → `webview.on_message()` 자동 디스패치 | **범용** |
-| 백엔드 deny 리스트 | OBS에서 의미 없는 커맨드 차단 | **프로젝트별 설정 (유일한 관리 포인트)** |
+| 백엔드 allow 리스트 | OBS에서 허용할 커맨드만 명시 | **프로젝트별 설정 (유일한 관리 포인트)** |
| 백엔드 이벤트 포워딩 | Tauri emit → `tauri_event` WS 브로드캐스트 | **범용** |
-프로젝트별로 관리하는 것은 **deny 리스트 하나뿐** — **백엔드 Rust 코드에서 1곳만 관리**.
-프론트엔드는 WS handshake(`hello_ack`)에서 deny 리스트를 수신하여 No-op Set을 동적 구성.
+프로젝트별로 관리하는 것은 **allow 리스트 하나뿐** — **백엔드 Rust 코드에서 1곳만 관리**.
+프론트엔드는 WS handshake(`hello_ack`)에서 allow 리스트를 수신하여 허용 Set을 동적 구성.
나머지 인프라는 어떤 Tauri 앱이든 그대로 이식 가능.
### 12.4 IPC Shim 구현
@@ -559,14 +563,15 @@ OBS 환경:
shim은 **커맨드별 분기를 하지 않는다**. 모든 invoke 호출은 다음 3단계로만 처리:
1. **이벤트 플러그인** (`plugin:event|*`) → 로컬 콜백 레지스트리에서 처리
-2. **No-op** (OBS에서 의미 없는 창 관리 커맨드) → 즉시 반환
+2. **allow 체크** (allowlist에 없는 커맨드는 no-op/차단) → 즉시 반환
3. **WS RPC** → 백엔드에 전달, 실제 커맨드 핸들러가 처리
```typescript
// src/renderer/api/ipcShim.ts
-// deny 리스트는 하드코딩 아님 — WS handshake(hello_ack)에서 수신
-let denyList: string[] = [];
+// allow 리스트는 하드코딩 아님 — WS handshake(hello_ack)에서 수신
+let allowList: string[] = [];
+let allowListReceived = false;
async function shimInvoke(cmd: string, args?: Record): Promise {
// 1. 이벤트 플러그인 (프론트엔드 로컬)
@@ -574,74 +579,86 @@ async function shimInvoke(cmd: string, args?: Record): Promise<
if (cmd === 'plugin:event|unlisten') { handleEventUnlisten(args); return; }
if (cmd === 'plugin:event|emit') { handleEventEmit(args); return; }
- // 2. deny 체크 (백엔드에서 수신한 단일 리스트)
- if (isDenied(cmd)) return;
+ // 2. allow 체크 (백엔드에서 수신한 단일 리스트)
+ if (!isAllowed(cmd)) return;
- // 3. 나머지 전부 → WS RPC (백엔드가 실제 처리)
+ // 3. 허용된 커맨드만 → WS RPC (백엔드가 실제 처리)
return wsRpc(cmd, args);
}
-// "|"로 끝나면 prefix 매칭, 아니면 exact 매칭
-function isDenied(cmd: string): boolean {
- return denyList.some(entry =>
- entry.endsWith('|') ? cmd.startsWith(entry) : cmd === entry
- );
+// allowlist 정확 일치 — hello_ack 수신 전에는 백엔드 이중 검사에 위임
+function isAllowed(cmd: string): boolean {
+ if (!allowListReceived) return true;
+ return allowList.includes(cmd);
}
```
-**커맨드 추가 시 shim 수정 불필요** — 백엔드에 커맨드가 있으면 자동으로 동작.
+**신규 커맨드는 기본 차단** — OBS 오버레이에 실제로 필요한 커맨드만 백엔드 allowlist에 추가한다.
+deny 방식(신규 커맨드 기본 노출)과 정반대이며, 위험 커맨드가 실수로 원격에 열리는 것을 구조적으로 막는다.
-#### deny 리스트 일원화
+#### allow 리스트 일원화
-**백엔드가 유일한 source of truth**. 단일 배열 하나로 exact + prefix 매칭 통합.
-`|`로 끝나는 항목은 prefix 매칭, 아니면 exact 매칭.
+**백엔드가 유일한 source of truth**. 단일 배열, **정확 일치(exact match)** 매칭.
+prefix 매칭은 없다 — 명시된 커맨드 이름만 허용된다.
프론트엔드는 WS handshake에서 수신:
```json
-// hello_ack 응답에 deny 리스트 포함
+// hello_ack 응답에 allow 리스트 포함
{
"type": "hello_ack",
"payload": {
- "serverVersion": "1.5.2",
+ "serverVersion": "1.6.1",
"obsMode": true,
- "denyList": [
- "overlay_resize", "overlay_set_visible", "overlay_set_lock",
- "overlay_set_anchor", "overlay_get",
- "window_minimize", "window_close", "window_show_main",
- "window_open_devtools_all",
- "app_quit", "app_restart", "app_open_external", "app_auto_update",
- "plugin:window|", "plugin:menu|", "plugin:resources|"
+ "allowedList": [
+ "app_bootstrap", "settings_get", "layer_groups_get",
+ "note_tab_get_all", "note_tab_get",
+ "css_get", "css_get_use", "css_tab_get_all", "css_tab_get",
+ "js_get", "js_get_use", "get_cursor_settings",
+ "keys_get", "keys_get_counters", "positions_get",
+ "stat_positions_get", "graph_positions_get", "knob_positions_get",
+ "custom_tabs_list", "counter_animation_list",
+ "plugin_bridge_send", "plugin_bridge_send_to",
+ "raw_input_subscribe", "raw_input_unsubscribe",
+ "plugin_storage_get", "plugin_storage_set", "plugin_storage_remove",
+ "plugin_storage_keys", "plugin_storage_has_data", "plugin_storage_clear_by_prefix"
]
}
}
```
-프론트 shim은 `hello_ack` 수신 시 `denyList`를 그대로 저장:
+프론트 shim은 `hello_ack` 수신 시 `allowedList`를 그대로 저장:
```typescript
function onHelloAck(payload: HelloAckPayload) {
- denyList = payload.denyList ?? [];
+ if (payload.allowedList) {
+ allowList = payload.allowedList;
+ allowListReceived = true;
+ }
}
```
이 구조의 장점:
-- **관리 포인트 1곳** — Rust 코드의 `DENIED_WS_COMMANDS` 배열 하나만 수정
-- **단일 배열** — exact/prefix 구분 없이 하나의 리스트로 통합 (`|` suffix 컨벤션)
+- **관리 포인트 1곳** — Rust 코드의 `ALLOWED_WS_COMMANDS` 배열 하나만 수정
+- **fail-closed** — allowlist에 없으면 차단 — 신규 커맨드가 검토 없이 원격에 열리지 않음
- **빌드 의존성 없음** — codegen이나 공유 JSON 파일 불필요
- **런타임 동기화** — 백엔드 버전이 올라가도 프론트 shim 재빌드 필요 없음
+- **백엔드 이중 검사** — 프론트는 UX상 조기 차단일 뿐, 실제 경계는 `handle_invoke_request`가 `ALLOWED_WS_COMMANDS`로 재검사
-#### deny 커맨드 목록 (참고 — Rust에서만 관리)
+#### allow 커맨드 목록 (참고 — Rust에서만 관리)
-| 항목 | 매칭 | 이유 |
-|------|------|------|
-| `overlay_resize`, `overlay_set_visible` 등 | exact | Tauri 윈도우 조작 |
-| `window_minimize`, `window_close` 등 | exact | 네이티브 윈도우 제어 |
-| `app_quit`, `app_restart` 등 | exact | 앱 생명주기 |
-| `plugin:window\|` | prefix | Tauri window 플러그인 전체 |
-| `plugin:menu\|` | prefix | Tauri menu 플러그인 전체 |
-| `plugin:resources\|` | prefix | Tauri resources 플러그인 전체 |
+오버레이 렌더에 필요한 읽기 계열 + 플러그인 브릿지/구독/네임스페이스 storage만 허용. 전부 정확 일치.
-`raw_input_subscribe` 등 **백엔드 기능이 필요한 커맨드**는 deny가 아닌 WS RPC로 처리.
+| 분류 | 커맨드 | 이유 |
+|------|--------|------|
+| 부트스트랩·상태 | `app_bootstrap`, `settings_get`, `layer_groups_get`, `note_tab_get_all`, `note_tab_get` | 오버레이 초기 스냅샷·상태 읽기 |
+| CSS/JS 읽기 | `css_get`, `css_get_use`, `css_tab_get_all`, `css_tab_get`, `js_get`, `js_get_use` | 커스텀 CSS/JS 로드 |
+| 위치·카운터 읽기 | `keys_get`, `keys_get_counters`, `positions_get`, `stat_positions_get`, `graph_positions_get`, `knob_positions_get`, `custom_tabs_list`, `counter_animation_list` | 배치·통계 읽기 |
+| 커서 | `get_cursor_settings` | macOS 커서 처리 |
+| 플러그인 브릿지·구독 | `plugin_bridge_send`, `plugin_bridge_send_to`, `raw_input_subscribe`, `raw_input_unsubscribe` | 오버레이 플러그인 동기화·입력 구독 |
+| 플러그인 storage | `plugin_storage_get`, `plugin_storage_set`, `plugin_storage_remove`, `plugin_storage_keys`, `plugin_storage_has_data`, `plugin_storage_clear_by_prefix` | 플러그인 네임스페이스 저장소 |
+
+`settings_update`, `sound_delete`, `js_set_content`, `preset_save` 등 **변이·파일 커맨드는 allowlist에 없어 원격 차단**.
+`plugin:window|`, `plugin:menu|` 등 네이티브 창/메뉴 커맨드도 allowlist에 없으므로 자동 no-op 처리된다.
### 12.5 WS ↔ Tauri 이벤트 매핑
@@ -681,8 +698,8 @@ shim이 설치되면 자동으로 WS 경유 동작 — 별도 처리 불필요.
overlay/App.tsx가 `@tauri-apps/api/window`, `@tauri-apps/api/menu` 등을 직접 import.
이 모듈들은 내부적으로 `invoke('plugin:window|...', ...)` 형태로 호출.
-백엔드 deny 리스트의 `denyPrefixes`에 `plugin:window|`, `plugin:menu|` 등이 포함되어
-shim이 handshake 시 수신한 prefix 매칭으로 자동 no-op 처리 — 별도 모듈 모킹 불필요.
+`plugin:window|`, `plugin:menu|` 등은 allowlist에 없으므로 shim의 allow 체크에서
+자동 no-op 처리 — 별도 모듈 모킹 불필요.
`convertFileSrc()`는 `__TAURI_INTERNALS__.convertFileSrc`에 설치되므로 shim에서 직접 제공.
OBS HTTP 서버의 `/media/?token=...` 경로로 변환:
@@ -767,9 +784,9 @@ async function bootstrap() {
| 리스크 | 심각도 | 대응 |
|--------|--------|------|
| `window.__TAURI_INTERNALS__` 내부 API 변경 | 중 | Tauri 버전 고정 + 업그레이드 시 shim 검증 |
-| WS RPC 보안 (임의 커맨드 실행) | 중 | deny 리스트 + Tauri ACL 재사용 + 세션 토큰 검증 |
+| WS RPC 보안 (임의 커맨드 실행) | 중 | allow 리스트(정확 일치) + Tauri ACL 재사용 + 세션 토큰 검증 + Host/Origin 검증 |
| `InvokeRequest` API 안정성 | 중 | Tauri 2.x 내 변경 가능성 낮음, 업그레이드 시 한 곳만 수정 |
-| overlay 전용 API 누락으로 런타임 에러 | 낮 | No-op prefix 매칭 (`plugin:window|*`) + try/catch 가드 |
+| overlay 전용 API 누락으로 런타임 에러 | 낮 | allowlist 미포함 커맨드 자동 no-op + try/catch 가드 |
| WS RPC 지연 (localhost) | 낮 | <1ms, 체감 불가 |
| pendingRpc dispose 시 미해결 Promise | 낮 | dispose 시 모든 pending을 reject 처리 |
@@ -792,8 +809,8 @@ async fn handle_invoke_request(
args: Value,
ws_tx: &WsSender,
) {
- // 1. deny 리스트 체크 (= 프론트 No-op 리스트와 동일)
- if DENIED_WS_COMMANDS.contains(&command) {
+ // 1. allow 리스트 체크 (= 프론트 허용 리스트와 동일, 정확 일치)
+ if !ALLOWED_WS_COMMANDS.contains(&command) {
ws_tx.send(invoke_response_error(request_id, "Command not allowed"));
return;
}
@@ -817,54 +834,54 @@ async fn handle_invoke_request(
}
```
-#### deny 리스트 (유일한 source of truth)
+#### allow 리스트 (유일한 source of truth)
**이 배열 하나가 프론트/백엔드 양쪽의 유일한 관리 포인트**.
-`|`로 끝나는 항목은 prefix 매칭, 아니면 exact 매칭 — 프론트/백엔드 동일 규칙.
+정확 일치(exact match)만 허용 — prefix 매칭 없음.
WS handshake 시 `hello_ack`에 포함하여 프론트엔드에 전달 (§12.4 참조).
```rust
-// obs_bridge.rs — 유일한 deny 리스트 정의 (단일 배열)
-const DENIED_WS_COMMANDS: &[&str] = &[
- // exact 매칭
- "overlay_resize", "overlay_set_visible", "overlay_set_lock",
- "overlay_set_anchor", "overlay_get",
- "window_minimize", "window_close", "window_show_main",
- "window_open_devtools_all",
- "app_quit", "app_restart", "app_open_external", "app_auto_update",
- // prefix 매칭 ("|"로 끝남)
- "plugin:window|", "plugin:menu|", "plugin:resources|",
+// obs_bridge.rs — 유일한 allow 리스트 정의 (단일 배열, 정확 일치)
+const ALLOWED_WS_COMMANDS: &[&str] = &[
+ "app_bootstrap", "settings_get", "layer_groups_get",
+ "note_tab_get_all", "note_tab_get",
+ "css_get", "css_get_use", "css_tab_get_all", "css_tab_get",
+ "js_get", "js_get_use", "get_cursor_settings",
+ "keys_get", "keys_get_counters", "positions_get",
+ "stat_positions_get", "graph_positions_get", "knob_positions_get",
+ "custom_tabs_list", "counter_animation_list",
+ "plugin_bridge_send", "plugin_bridge_send_to",
+ "raw_input_subscribe", "raw_input_unsubscribe",
+ "plugin_storage_get", "plugin_storage_set", "plugin_storage_remove",
+ "plugin_storage_keys", "plugin_storage_has_data", "plugin_storage_clear_by_prefix",
];
-fn is_denied(cmd: &str) -> bool {
- DENIED_WS_COMMANDS.iter().any(|entry| {
- if entry.ends_with('|') { cmd.starts_with(entry) }
- else { cmd == *entry }
- })
+fn is_allowed_command(cmd: &str) -> bool {
+ ALLOWED_WS_COMMANDS.contains(&cmd)
}
```
```rust
-// hello_ack 전송 시 deny 리스트 포함
+// hello_ack 전송 시 allow 리스트 포함
fn build_hello_ack(&self) -> Value {
json!({
"serverVersion": self.server_version,
"obsMode": true,
- "denyList": DENIED_WS_COMMANDS,
+ "allowedList": ALLOWED_WS_COMMANDS,
})
}
```
-deny에 없는 커맨드는 **자동으로 Tauri가 처리** — 새 커맨드 추가 시 양쪽 모두 수정 불필요.
-Tauri의 ACL 시스템이 보안 경계 역할을 하므로 별도 화이트리스트 불필요.
+allowlist에 없는 커맨드는 **차단** — 신규 `#[tauri::command]`는 검토 후 명시적으로 추가해야 원격 노출된다.
+Tauri ACL에 더해, 변이·파일·창 제어 커맨드를 원격 표면에서 구조적으로 배제하는 것이 이 리스트의 목적.
#### 장점
- **match문 완전 제거** — 커맨드별 분기 없음
- **인자 역직렬화 자동** — Tauri의 `#[tauri::command]` 매크로가 처리
- **ACL 재사용** — Tauri permissions 시스템이 보안 검증
-- **새 커맨드 자동 지원** — `#[tauri::command]` 추가하면 WS에서도 즉시 동작
-- **관리 포인트 1개** — Rust deny 리스트만 수정하면 `hello_ack`로 프론트에 자동 전파
+- **fail-closed** — allowlist에 명시한 커맨드만 원격 노출, 신규 커맨드는 기본 차단
+- **관리 포인트 1개** — Rust allow 리스트만 수정하면 `hello_ack`로 프론트에 자동 전파
#### 제약
@@ -973,8 +990,8 @@ function onWsMessage(envelope) {
- overlay/App.tsx **코드 변경 0**
- obs/index.tsx → IPC Shim 설치 → overlay/App.tsx **동일 코드** 실행
- 중복 로직 **완전 해소** (레거시 624줄 삭제)
-- **커맨드 추가 시 양쪽 모두 수정 불필요** — deny 리스트에 없으면 자동 동작
-- **deny 리스트 관리 포인트 1곳** — Rust `DENIED_WS_COMMANDS` 수정 시 WS handshake로 프론트에 자동 반영
+- **신규 커맨드 기본 차단** — allowlist에 명시해야 원격 노출, 위험 커맨드 실수 노출 방지
+- **allow 리스트 관리 포인트 1곳** — Rust `ALLOWED_WS_COMMANDS` 수정 시 WS handshake로 프론트에 자동 반영
- **auto_start_obs 경로**에도 IPC Shim 지원 추가 (set_app_handle + register_event_forwarding)
Codex(GPT 5.4) 리뷰에서 발견/수정한 이슈:
diff --git a/plugin/kps-builtin.js b/plugin/kps-builtin.js
index 64d774b2..aec8d4d7 100644
--- a/plugin/kps-builtin.js
+++ b/plugin/kps-builtin.js
@@ -82,7 +82,7 @@ dmn.plugin.defineElement({
default: true,
label: "settings.showGraph",
},
- graphDivider: { type: "divider" },
+ graphSection: { type: "section" },
graphType: {
type: "select",
options: [
diff --git a/plugin/kps.js b/plugin/kps.js
index f8e6f5d0..1dc6142c 100644
--- a/plugin/kps.js
+++ b/plugin/kps.js
@@ -76,7 +76,7 @@ dmn.plugin.defineElement({
default: true,
label: "settings.showGraph",
},
- graphDivider: { type: "divider" },
+ graphSection: { type: "section" },
graphType: {
type: "select",
options: [
diff --git a/scripts/verify-macos-bundle.sh b/scripts/verify-macos-bundle.sh
new file mode 100755
index 00000000..6424c407
--- /dev/null
+++ b/scripts/verify-macos-bundle.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+APP_BUNDLE="${1:-${REPO_ROOT}/src-tauri/target/release/bundle/macos/DM NOTE.app}"
+
+fail() {
+ echo "[FAIL] $*" >&2
+ exit 1
+}
+
+require_file() {
+ [[ -f "$1" ]] || fail "파일을 찾을 수 없음: $1"
+}
+
+read_executable_name() {
+ /usr/libexec/PlistBuddy -c "Print :CFBundleExecutable" "$1" 2>/dev/null \
+ || fail "CFBundleExecutable을 읽을 수 없음: $1"
+}
+
+read_minos() {
+ local binary="$1"
+ local arch="$2"
+ xcrun vtool -show-build -arch "$arch" "$binary" 2>/dev/null \
+ | awk '$1 == "minos" { print $2; exit }'
+}
+
+read_plist_min_version() {
+ /usr/libexec/PlistBuddy -c "Print :LSMinimumSystemVersion" "$1" 2>/dev/null || true
+}
+
+MIN_SYSTEM_VERSION="11.0"
+
+command -v lipo >/dev/null 2>&1 || fail "lipo를 찾을 수 없음"
+command -v xcrun >/dev/null 2>&1 || fail "xcrun을 찾을 수 없음"
+[[ -x /usr/libexec/PlistBuddy ]] || fail "PlistBuddy를 찾을 수 없음"
+[[ -d "$APP_BUNDLE" ]] || fail "앱 번들을 찾을 수 없음: $APP_BUNDLE"
+
+MAIN_INFO="${APP_BUNDLE}/Contents/Info.plist"
+HELPER_BUNDLE="${APP_BUNDLE}/Contents/Resources/DM NOTE.app"
+HELPER_INFO="${HELPER_BUNDLE}/Contents/Info.plist"
+NOTICES="${APP_BUNDLE}/Contents/Resources/THIRD_PARTY_NOTICES.txt"
+
+require_file "$MAIN_INFO"
+[[ -d "$HELPER_BUNDLE" ]] || fail "helper 번들을 찾을 수 없음: $HELPER_BUNDLE"
+require_file "$HELPER_INFO"
+require_file "$NOTICES"
+
+MAIN_EXECUTABLE="${APP_BUNDLE}/Contents/MacOS/$(read_executable_name "$MAIN_INFO")"
+HELPER_EXECUTABLE="${HELPER_BUNDLE}/Contents/MacOS/$(read_executable_name "$HELPER_INFO")"
+require_file "$MAIN_EXECUTABLE"
+require_file "$HELPER_EXECUTABLE"
+[[ -x "$MAIN_EXECUTABLE" ]] || fail "main 바이너리에 실행 권한이 없음: $MAIN_EXECUTABLE"
+[[ -x "$HELPER_EXECUTABLE" ]] || fail "helper 바이너리에 실행 권한이 없음: $HELPER_EXECUTABLE"
+
+# plist 최소 버전이 바이너리 minos와 일치하는지 비교 (표기-실행 불일치 방지)
+MAIN_PLIST_MIN="$(read_plist_min_version "$MAIN_INFO")"
+[[ "$MAIN_PLIST_MIN" == "$MIN_SYSTEM_VERSION" ]] \
+ || fail "main LSMinimumSystemVersion이 ${MIN_SYSTEM_VERSION}이 아님: ${MAIN_PLIST_MIN:-없음}"
+echo "[OK] main plist LSMinimumSystemVersion=$MAIN_PLIST_MIN"
+
+HELPER_PLIST_MIN="$(read_plist_min_version "$HELPER_INFO")"
+[[ "$HELPER_PLIST_MIN" == "$MIN_SYSTEM_VERSION" ]] \
+ || fail "helper LSMinimumSystemVersion이 ${MIN_SYSTEM_VERSION}이 아님: ${HELPER_PLIST_MIN:-없음}"
+echo "[OK] helper plist LSMinimumSystemVersion=$HELPER_PLIST_MIN"
+
+HELPER_ARCHS="$(lipo -archs "$HELPER_EXECUTABLE")"
+for arch in arm64 x86_64; do
+ case " $HELPER_ARCHS " in
+ *" $arch "*) ;;
+ *) fail "helper에 $arch 아키텍처가 없음: $HELPER_ARCHS" ;;
+ esac
+
+ minos="$(read_minos "$HELPER_EXECUTABLE" "$arch")"
+ [[ "$minos" == "$MIN_SYSTEM_VERSION" ]] \
+ || fail "helper $arch minos가 ${MIN_SYSTEM_VERSION}이 아님: ${minos:-없음}"
+ echo "[OK] helper $arch minos=$minos"
+done
+
+MAIN_ARCHS="$(lipo -archs "$MAIN_EXECUTABLE")"
+[[ -n "$MAIN_ARCHS" ]] || fail "main 바이너리 아키텍처를 읽을 수 없음"
+for arch in $MAIN_ARCHS; do
+ minos="$(read_minos "$MAIN_EXECUTABLE" "$arch")"
+ [[ "$minos" == "$MIN_SYSTEM_VERSION" ]] \
+ || fail "main $arch minos가 ${MIN_SYSTEM_VERSION}이 아님: ${minos:-없음}"
+ echo "[OK] main $arch minos=$minos"
+done
+
+echo "[OK] helper 경로: $HELPER_BUNDLE"
+echo "[OK] notices 경로: $NOTICES"
+echo "[OK] macOS 번들 검증 완료"
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index c17e2b43..921b40a5 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -1165,6 +1165,7 @@ dependencies = [
"gif-dispose",
"local-ip-address",
"log",
+ "minisign-verify",
"notify",
"notify-debouncer-mini",
"objc",
@@ -1191,6 +1192,7 @@ dependencies = [
"thread-priority",
"tokio",
"tokio-tungstenite",
+ "url",
"uuid",
"walkdir",
"webp-animation",
@@ -2682,6 +2684,12 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+[[package]]
+name = "minisign-verify"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f9645cb765ea72b8111f36c522475d2daa0d22c957a9826437e97534bc4e9e"
+
[[package]]
name = "miniz_oxide"
version = "0.8.9"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 74e81a9e..168565e6 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -2,6 +2,7 @@
name = "dm-note"
version = "1.6.1"
edition = "2021"
+rust-version = "1.87"
default-run = "dm-note"
[features]
@@ -17,6 +18,7 @@ anyhow = "1.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
base64 = "0.22"
+minisign-verify = "0.2.5"
thiserror = "1.0"
parking_lot = "0.12"
log = "0.4"
@@ -31,6 +33,7 @@ open = "5.1"
rfd = "0.14"
dirs-next = "2.0"
uuid = { version = "1", features = ["v4"] }
+url = "2"
zip = "0.6"
gif = "0.13.3"
gif-dispose = "5.0.1"
diff --git a/src-tauri/build.rs b/src-tauri/build.rs
index 09b6045f..0837cdb3 100644
--- a/src-tauri/build.rs
+++ b/src-tauri/build.rs
@@ -157,6 +157,8 @@ fn maybe_build_macos_dock_helper() {
let helper_macos = helper_contents.join("MacOS");
let helper_resources = helper_contents.join("Resources");
let helper_exec = helper_macos.join("DMNoteDockHelper");
+ let helper_arm64_exec = helper_macos.join("DMNoteDockHelper.arm64");
+ let helper_x86_64_exec = helper_macos.join("DMNoteDockHelper.x86_64");
let helper_bundle_info = helper_contents.join("Info.plist");
let helper_icon = helper_resources.join("icon.icns");
let source_icon = PathBuf::from("icons/icon.icns");
@@ -168,6 +170,9 @@ fn maybe_build_macos_dock_helper() {
if legacy_helper_bundle.exists() {
let _ = fs::remove_dir_all(&legacy_helper_bundle);
}
+ if helper_bundle.exists() {
+ let _ = fs::remove_dir_all(&helper_bundle);
+ }
if let Err(err) = fs::create_dir_all(&helper_macos) {
println!("cargo:warning=failed to create helper MacOS dir: {err}");
@@ -178,21 +183,66 @@ fn maybe_build_macos_dock_helper() {
return;
}
- let status = Command::new("xcrun")
- .args(["--sdk", "macosx", "swiftc"])
- .arg(&helper_src)
- .args(["-O", "-framework", "AppKit", "-o"])
+ let helper_slices = [
+ (
+ "arm64",
+ "arm64-apple-macos11.0",
+ helper_arm64_exec.as_path(),
+ ),
+ (
+ "x86_64",
+ "x86_64-apple-macos11.0",
+ helper_x86_64_exec.as_path(),
+ ),
+ ];
+
+ for (arch, target, output) in helper_slices {
+ let status = Command::new("xcrun")
+ .args(["--sdk", "macosx", "swiftc"])
+ .arg(&helper_src)
+ .args(["-target", target, "-O", "-framework", "AppKit", "-o"])
+ .arg(output)
+ .status();
+
+ match status {
+ Ok(s) if s.success() => {}
+ Ok(s) => {
+ println!("cargo:warning=swiftc helper {arch} build failed with status {s}");
+ let _ = fs::remove_file(&helper_arm64_exec);
+ let _ = fs::remove_file(&helper_x86_64_exec);
+ return;
+ }
+ Err(err) => {
+ println!("cargo:warning=failed to invoke swiftc for helper {arch} build: {err}");
+ let _ = fs::remove_file(&helper_arm64_exec);
+ let _ = fs::remove_file(&helper_x86_64_exec);
+ return;
+ }
+ }
+ }
+
+ let lipo_status = Command::new("xcrun")
+ .arg("lipo")
+ .arg("-create")
+ .arg(&helper_arm64_exec)
+ .arg(&helper_x86_64_exec)
+ .arg("-output")
.arg(&helper_exec)
.status();
- match status {
+ let _ = fs::remove_file(&helper_arm64_exec);
+ let _ = fs::remove_file(&helper_x86_64_exec);
+
+ match lipo_status {
Ok(s) if s.success() => {}
Ok(s) => {
- println!("cargo:warning=swiftc helper build failed with status {s}");
+ println!("cargo:warning=lipo helper build failed with status {s}");
+ let _ = fs::remove_file(&helper_exec);
return;
}
Err(err) => {
- println!("cargo:warning=failed to invoke swiftc for helper build: {err}");
+ println!("cargo:warning=failed to invoke lipo for helper build: {err}");
+ let _ = fs::remove_file(&helper_exec);
return;
}
}
diff --git a/src-tauri/helper/DockHelper/main.swift b/src-tauri/helper/DockHelper/main.swift
index 116db1d1..387a9096 100644
--- a/src-tauri/helper/DockHelper/main.swift
+++ b/src-tauri/helper/DockHelper/main.swift
@@ -16,10 +16,11 @@ private func argValue(_ key: ArgKey) -> String? {
}
final class DockHelperAppDelegate: NSObject, NSApplicationDelegate {
- private let mainPid: pid_t?
+ private var mainPid: pid_t?
private let mainBundleId: String
private let mainBundlePath: String?
private var monitorTimer: Timer?
+ private var isQuitting = false
private lazy var dockMenu: NSMenu = {
let menu = NSMenu()
let openItem = NSMenuItem(
@@ -49,6 +50,16 @@ final class DockHelperAppDelegate: NSObject, NSApplicationDelegate {
}
func applicationDidFinishLaunching(_ notification: Notification) {
+ let currentPid = ProcessInfo.processInfo.processIdentifier
+ // 기존 helper 인스턴스가 있으면 종료시키고 이 인스턴스(최신 main-pid)가 대체한다.
+ // 반대로 새 인스턴스를 자결시키면 앱 재시작 시 구 helper도 곧 죽어 Dock 아이콘이 사라진다
+ let staleHelpers = NSRunningApplication
+ .runningApplications(withBundleIdentifier: Bundle.main.bundleIdentifier ?? "")
+ .filter { $0.processIdentifier != currentPid && !$0.isTerminated }
+ for helper in staleHelpers {
+ helper.terminate()
+ }
+
NSApp.setActivationPolicy(.regular)
startMainProcessMonitor()
}
@@ -67,14 +78,11 @@ final class DockHelperAppDelegate: NSObject, NSApplicationDelegate {
}
@objc private func quitMainAndHelper() {
+ guard !isQuitting else { return }
+ isQuitting = true
+ monitorTimer?.invalidate()
terminateMainApplications()
- DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) { [mainBundleId] in
- let running = NSRunningApplication.runningApplications(withBundleIdentifier: mainBundleId)
- for app in running where !app.isTerminated {
- app.forceTerminate()
- }
- NSApp.terminate(nil)
- }
+ waitForMainTermination(attempt: 0)
}
private func startMainProcessMonitor() {
@@ -89,12 +97,32 @@ final class DockHelperAppDelegate: NSObject, NSApplicationDelegate {
}
private func mainIsAlive() -> Bool {
- if let pid = mainPid {
- return kill(pid, 0) == 0
+ // kill(pid,0)은 번들 여부와 무관하게 모든 프로세스에 동작 — dev 바이너리 포함.
+ // NSRunningApplication은 LaunchServices에 등록된 앱만 조회돼 생존 확인엔 부적합
+ // pid 재사용 위험은 원 설계와 동일하게 수용
+ if let pid = mainPid, kill(pid, 0) == 0 {
+ return true
}
+ // pid가 죽었으면 같은 번들 ID로 재시작된 메인에 재결합 (패키지 앱 재시작)
+ return currentMainApplication() != nil
+ }
- let apps = NSRunningApplication.runningApplications(withBundleIdentifier: mainBundleId)
- return apps.contains { !$0.isTerminated }
+ private func currentMainApplication() -> NSRunningApplication? {
+ // 부모가 넘겨준 pid는 신뢰한다. 번들 ID 동일성은 pid 재사용 방어용이며
+ // non-nil일 때만 검사 — dev 실행 메인은 번들이 아니라 bundleIdentifier가
+ // nil이므로, 동일성을 요구하면 helper가 메인 사망으로 오판해 자결한다
+ if let pid = mainPid,
+ let app = NSRunningApplication(processIdentifier: pid),
+ !app.isTerminated,
+ app.bundleIdentifier == nil || app.bundleIdentifier == mainBundleId {
+ return app
+ }
+
+ let replacement = NSRunningApplication
+ .runningApplications(withBundleIdentifier: mainBundleId)
+ .first { !$0.isTerminated }
+ mainPid = replacement?.processIdentifier
+ return replacement
}
private func terminateMainApplications() {
@@ -108,23 +136,60 @@ final class DockHelperAppDelegate: NSObject, NSApplicationDelegate {
}
}
- private func activateOrLaunchMain() {
- if let pid = mainPid, let app = NSRunningApplication(processIdentifier: pid), !app.isTerminated {
- app.activate(options: [.activateIgnoringOtherApps])
+ private func waitForMainTermination(attempt: Int) {
+ let running = NSRunningApplication
+ .runningApplications(withBundleIdentifier: mainBundleId)
+ .filter { !$0.isTerminated }
+ if running.isEmpty {
+ NSApp.terminate(nil)
return
}
- if let running = NSRunningApplication
- .runningApplications(withBundleIdentifier: mainBundleId)
- .first(where: { !$0.isTerminated }) {
- running.activate(options: [.activateIgnoringOtherApps])
+ if attempt >= 50 {
+ for app in running {
+ app.forceTerminate()
+ }
+ NSApp.terminate(nil)
return
}
+ DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+ self?.waitForMainTermination(attempt: attempt + 1)
+ }
+ }
+
+ private func sendReopenEvent(to pid: pid_t) {
+ // openApplication이 번들 앱에 보내는 reopen(aevt/rapp)과 동일한 이벤트를 pid로 직접 전송
+ // — 메인의 RunEvent::Reopen 핸들러가 트레이에 숨긴 창을 복원한다. reopen은 TCC 동의 면제
+ let target = NSAppleEventDescriptor(processIdentifier: pid)
+ let event = NSAppleEventDescriptor(
+ eventClass: AEEventClass(kCoreEventClass),
+ eventID: AEEventID(kAEReopenApplication),
+ targetDescriptor: target,
+ returnID: AEReturnID(kAutoGenerateReturnID),
+ transactionID: AETransactionID(kAnyTransactionID)
+ )
+ AESendMessage(event.aeDesc, nil, AESendMode(kAENoReply), kAEDefaultTimeout)
+ }
+
+ private func activateOrLaunchMain() {
let workspace = NSWorkspace.shared
let configuration = NSWorkspace.OpenConfiguration()
configuration.activates = true
+ if let running = currentMainApplication() {
+ // 번들 없는 프로세스(dev 바이너리)의 bundleURL은 실행 파일 경로를 그대로 반환하는데,
+ // 그걸 openApplication에 넘기면 LaunchServices가 Terminal로 열어 새 인스턴스가 뜬다.
+ // 실제 .app 번들일 때만 openApplication 사용, dev는 reopen 이벤트를 직접 전송
+ if let bundleURL = running.bundleURL, bundleURL.pathExtension == "app" {
+ workspace.openApplication(at: bundleURL, configuration: configuration) { _, _ in }
+ } else {
+ sendReopenEvent(to: running.processIdentifier)
+ running.activate(options: [.activateIgnoringOtherApps])
+ }
+ return
+ }
+
if let bundlePath = mainBundlePath {
let bundleURL = URL(fileURLWithPath: bundlePath)
workspace.openApplication(at: bundleURL, configuration: configuration) { _, _ in }
diff --git a/src-tauri/src/commands/app/obs.rs b/src-tauri/src/commands/app/obs.rs
index 57c6baaf..a90c7a1f 100644
--- a/src-tauri/src/commands/app/obs.rs
+++ b/src-tauri/src/commands/app/obs.rs
@@ -5,27 +5,11 @@ use uuid::Uuid;
use crate::{errors::CmdResult, models::obs::ObsStatus, state::AppState};
-/// 저장된 토큰 재사용 또는 신규 생성 후 store에 저장
-fn resolve_and_save_token(state: &AppState) -> String {
- let existing = state.store.with_state(|s| s.obs_token.clone());
- if let Some(token) = existing {
- if !token.is_empty() {
- return token;
- }
- }
- // 신규 생성 후 저장
- let token = Uuid::new_v4().simple().to_string();
- let t = token.clone();
- let _ = state.store.update(|s| {
- s.obs_token = Some(t.clone());
- });
- token
-}
-
#[tauri::command]
pub async fn obs_start(app: AppHandle, state: State<'_, AppState>) -> CmdResult {
let port = state.store.with_state(|s| s.obs_port);
- let token = resolve_and_save_token(&state);
+ // 저장 불가면 시작 중단 — 서버가 쓰는 토큰은 반드시 디스크에 존재해야 함
+ let token = state.resolve_and_save_obs_token()?;
// OBS 정적 파일 서빙 설정
if cfg!(debug_assertions) {
@@ -58,10 +42,13 @@ pub async fn obs_start(app: AppHandle, state: State<'_, AppState>) -> CmdResult<
.await
.map_err(crate::errors::CommandError::msg)?;
// 성공한 포트를 store에 저장 (fallback 시 다음 시작에 재사용)
+ // 실패해도 서버는 이미 동작 중 — 다음 시작에 fallback을 다시 거치므로 경고만 남김
if actual_port != port {
- let _ = state.store.update(|s| {
+ if let Err(error) = state.store.update(|s| {
s.obs_port = actual_port;
- });
+ }) {
+ log::warn!("[ObsBridge] fallback 포트 저장 실패: {error}");
+ }
}
// 초기 스냅샷 캐싱 (신규 클라이언트에 전송됨)
state.refresh_obs_snapshot();
@@ -90,11 +77,11 @@ pub fn obs_status(state: State<'_, AppState>) -> CmdResult {
#[tauri::command]
pub fn obs_regenerate_token(app: AppHandle, state: State<'_, AppState>) -> CmdResult {
let token = Uuid::new_v4().simple().to_string();
- // store에 저장
+ // 디스크 저장이 성공한 뒤에만 메모리 토큰 교체 — 실패 시 구 토큰이 그대로 유효한 일관 상태 유지
let t = token.clone();
- let _ = state.store.update(|s| {
+ state.store.update(|s| {
s.obs_token = Some(t.clone());
- });
+ })?;
// 실행 중이면 bridge 메모리 토큰도 교체
if state.obs_bridge.is_running() {
state.obs_bridge.set_token(token);
diff --git a/src-tauri/src/commands/app/system.rs b/src-tauri/src/commands/app/system.rs
index 48f31d3f..17bd0d16 100644
--- a/src-tauri/src/commands/app/system.rs
+++ b/src-tauri/src/commands/app/system.rs
@@ -4,8 +4,6 @@ use crate::cursor::{get_macos_cursor_settings, rgb_to_hex};
use crate::errors::CmdResult;
use crate::state::AppState;
-const TRAY_ICON_ID: &str = "background-tray";
-
#[tauri::command]
pub fn window_minimize(app: AppHandle) -> CmdResult<()> {
if let Some(window) = app.get_webview_window("main") {
@@ -31,25 +29,15 @@ pub fn app_open_external(_app: AppHandle, url: String) -> CmdResult<()> {
}
#[tauri::command]
-pub fn app_restart(app: AppHandle) -> CmdResult<()> {
+pub fn app_restart(app: AppHandle, state: State<'_, AppState>) -> CmdResult<()> {
+ state.shutdown();
app.request_restart();
Ok(())
}
#[tauri::command]
pub fn window_show_main(app: AppHandle, state: State<'_, AppState>) -> CmdResult<()> {
- if let Some(main) = app.get_webview_window("main") {
- let _ = main.unminimize();
- main.show()?;
- let _ = main.set_focus();
- }
-
- if app.tray_by_id(TRAY_ICON_ID).is_some() {
- let _ = app.remove_tray_by_id(TRAY_ICON_ID);
- }
-
- state.set_main_window_hidden(false)?;
-
+ state.show_main_window(&app)?;
Ok(())
}
diff --git a/src-tauri/src/commands/app/update.rs b/src-tauri/src/commands/app/update.rs
index cf584119..94459d4a 100644
--- a/src-tauri/src/commands/app/update.rs
+++ b/src-tauri/src/commands/app/update.rs
@@ -1,6 +1,15 @@
-use tauri::AppHandle;
+use tauri::{AppHandle, State};
use crate::errors::{CmdResult, CommandError};
+use crate::state::AppState;
+
+#[cfg(any(target_os = "windows", test))]
+use base64::{engine::general_purpose::STANDARD as BASE64_STANDARD, Engine as _};
+#[cfg(any(target_os = "windows", test))]
+use minisign_verify::{PublicKey, Signature};
+
+#[cfg(any(target_os = "windows", test))]
+const UPDATE_PUBLIC_KEY: &str = "";
#[derive(Debug, Clone, serde::Serialize)]
#[serde(rename_all = "camelCase")]
@@ -11,15 +20,20 @@ pub struct AutoUpdateResult {
}
#[tauri::command]
-pub fn app_auto_update(app: AppHandle, tag: String) -> CmdResult {
+pub fn app_auto_update(
+ app: AppHandle,
+ state: State<'_, AppState>,
+ tag: String,
+) -> CmdResult {
#[cfg(target_os = "windows")]
{
- app_auto_update_windows(app, &tag)
+ app_auto_update_windows(app, &state, &tag)
}
#[cfg(not(target_os = "windows"))]
{
let _ = app;
+ let _ = state;
let _ = tag;
Err(CommandError::msg(
"auto update is only supported on Windows",
@@ -28,12 +42,17 @@ pub fn app_auto_update(app: AppHandle, tag: String) -> CmdResult CmdResult {
+fn app_auto_update_windows(
+ app: AppHandle,
+ state: &AppState,
+ tag: &str,
+) -> CmdResult {
use std::time::Duration;
const REPO_OWNER: &str = "lee-sihun";
const REPO_NAME: &str = "DmNote";
const ASSET_NAME: &str = "DM.NOTE.exe";
+ const SIGNATURE_ASSET_NAME: &str = "DM.NOTE.exe.sig";
let trimmed_tag = tag.trim();
if trimmed_tag.is_empty() {
@@ -64,20 +83,27 @@ fn app_auto_update_windows(app: AppHandle, tag: &str) -> CmdResult CmdResult CmdResult CmdResult> {
+ let response = client
+ .get(url)
+ .send()
+ .map_err(|error| CommandError::msg(format!("failed to download {asset_label}: {error}")))?;
+ let response = response
+ .error_for_status()
+ .map_err(|error| CommandError::msg(format!("failed to download {asset_label}: {error}")))?;
+ let bytes = response.bytes().map_err(|error| {
+ CommandError::msg(format!("failed to read downloaded {asset_label}: {error}"))
+ })?;
+ Ok(bytes.to_vec())
+}
+
+#[cfg(any(target_os = "windows", test))]
+fn verify_update_signature(
+ update_bytes: &[u8],
+ wrapped_public_key: &str,
+ wrapped_signature: &str,
+) -> CmdResult<()> {
+ let public_key_text = decode_tauri_minisign_text(wrapped_public_key, "public key")?;
+ let signature_text = decode_tauri_minisign_text(wrapped_signature, "signature")?;
+ let public_key = PublicKey::decode(&public_key_text)
+ .map_err(|error| CommandError::msg(format!("invalid update public key: {error}")))?;
+ let signature = Signature::decode(&signature_text)
+ .map_err(|error| CommandError::msg(format!("invalid update signature: {error}")))?;
+ public_key
+ .verify(update_bytes, &signature, false)
+ .map_err(|error| {
+ CommandError::msg(format!("update signature verification failed: {error}"))
+ })
+}
+
+#[cfg(any(target_os = "windows", test))]
+fn decode_tauri_minisign_text(wrapped: &str, label: &str) -> CmdResult {
+ let decoded = BASE64_STANDARD
+ .decode(wrapped.trim())
+ .map_err(|error| CommandError::msg(format!("invalid base64-wrapped {label}: {error}")))?;
+ String::from_utf8(decoded)
+ .map_err(|error| CommandError::msg(format!("decoded {label} is not UTF-8: {error}")))
+}
+
#[cfg(target_os = "windows")]
fn parse_semver_version(raw: &str) -> CmdResult {
let normalized = raw.trim().trim_start_matches(['v', 'V']);
@@ -107,3 +181,40 @@ fn is_safe_tag(tag: &str) -> bool {
tag.chars()
.all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '.' | '_' | '-' | '+'))
}
+
+#[cfg(test)]
+mod tests {
+ use super::{verify_update_signature, UPDATE_PUBLIC_KEY};
+
+ // 테스트 전용 일회성 키로 생성한 픽스처 — 프로덕션 키와 무관
+ const TEST_PAYLOAD: &[u8] = b"DM NOTE isolated update signature test fixture\n";
+ const TEST_PUBLIC_KEY: &str = "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDQ0QkI0QkQ0MUVERDNDMzMKUldRelBOMGUxRXU3UlBVUWx2Z21zWmlHWnkwRUsvcy9rOTJHNXhqemRuTjAxS0I3cWduZUNITzIK";
+ const TEST_MISMATCH_PUBLIC_KEY: &str = "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDI2MjU5MzY2NjdDOTJDMzMKUldRekxNbG5acE1sSnZBMmJPZlFFd3VydTg3TGsrUjNBdjVyRFNUSnFFeFlNQjYySzRnd1pqYjQK";
+ const TEST_SIGNATURE: &str = "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkKUlVRelBOMGUxRXU3UkhkdGprNFZPVTgyQlMvTkF6ZFBmd1h1SzdKbFVIMkhOUlFKUG5tR1dlVndXaWJGR3ZvN2s2QS85NU9UZmNhb0haREwrYWNkc2k0U0tKQ0RvQTBzSUFrPQp0cnVzdGVkIGNvbW1lbnQ6IHRpbWVzdGFtcDoxNzgzOTI0NDE2CWZpbGU6dXBkYXRlX3NpZ25hdHVyZV90ZXN0X3BheWxvYWQuYmluCldRa0E4UkRDRU1oZHl1TEZPQnpwUTkxeHR0WnRyUVUrUFU4cWk0dzVjVGZJRVE2WWJkKzE0VzdFamVvQWFDRVJrNm5PQjgzRlVUVG1wVlQvSzdySUNRPT0K";
+
+ #[test]
+ fn production_public_key_gate_stays_disabled() {
+ assert!(UPDATE_PUBLIC_KEY.is_empty());
+ }
+
+ #[test]
+ fn update_signature_fixture_verifies() {
+ verify_update_signature(TEST_PAYLOAD, TEST_PUBLIC_KEY, TEST_SIGNATURE).unwrap();
+ }
+
+ #[test]
+ fn update_signature_rejects_tampered_payload() {
+ let mut tampered = TEST_PAYLOAD.to_vec();
+ tampered[0] ^= 1;
+
+ assert!(verify_update_signature(&tampered, TEST_PUBLIC_KEY, TEST_SIGNATURE).is_err());
+ }
+
+ #[test]
+ fn update_signature_rejects_mismatched_key() {
+ assert!(
+ verify_update_signature(TEST_PAYLOAD, TEST_MISMATCH_PUBLIC_KEY, TEST_SIGNATURE)
+ .is_err()
+ );
+ }
+}
diff --git a/src-tauri/src/commands/keys/key_sound.rs b/src-tauri/src/commands/keys/key_sound.rs
index 11b04c07..4a83b205 100644
--- a/src-tauri/src/commands/keys/key_sound.rs
+++ b/src-tauri/src/commands/keys/key_sound.rs
@@ -64,7 +64,7 @@ pub fn key_sound_set_output_backend(
state: State<'_, AppState>,
backend: KeySoundOutputBackend,
) -> CmdResult {
- Ok(state.key_sound_set_output_backend(backend))
+ Ok(state.key_sound_set_output_backend(backend)?)
}
#[tauri::command]
diff --git a/src-tauri/src/commands/keys/keys.rs b/src-tauri/src/commands/keys/keys.rs
index 67cc9779..7eccc77c 100644
--- a/src-tauri/src/commands/keys/keys.rs
+++ b/src-tauri/src/commands/keys/keys.rs
@@ -7,14 +7,163 @@ use crate::{
defaults::{default_keys, default_positions},
errors::CmdResult,
models::{
- CustomCssPatch, CustomTab, KeyCounters, KeyMappings, KeyPositions, LayerGroups,
- NoteSettings, NoteSettingsPatch, SettingsPatchInput,
+ AppStoreData, CustomCssPatch, CustomTab, KeyCounters, KeyMappings, KeyPositions,
+ LayerGroups, NoteSettings, NoteSettingsPatch, SettingsPatchInput,
},
state::AppState,
};
const MAX_CUSTOM_TABS: usize = 30;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ModeResetKind {
+ Default,
+ Custom,
+}
+
+struct CustomTabDeletePlan {
+ custom_tabs: Vec,
+ next_selected: String,
+}
+
+fn zeroed_counters(keys: &KeyMappings) -> KeyCounters {
+ keys.iter()
+ .map(|(mode, mode_keys)| {
+ (
+ mode.clone(),
+ mode_keys.iter().map(|key| (key.clone(), 0)).collect(),
+ )
+ })
+ .collect()
+}
+
+fn reset_all_editor_data(store: &mut AppStoreData, keys: &KeyMappings, positions: &KeyPositions) {
+ store.keys = keys.clone();
+ store.key_positions = positions.clone();
+ store.stat_positions.clear();
+ store.graph_positions.clear();
+ store.knob_positions.clear();
+ store.layer_groups.clear();
+ store.key_counters = zeroed_counters(keys);
+ store.custom_tabs.clear();
+ store.selected_key_type = "4key".to_string();
+ store.tab_note_overrides.clear();
+ store.tab_css_overrides.clear();
+}
+
+fn reset_mode_kind(store: &AppStoreData, mode: &str) -> Option {
+ if default_keys().contains_key(mode) {
+ Some(ModeResetKind::Default)
+ } else if store.custom_tabs.iter().any(|tab| tab.id == mode) {
+ Some(ModeResetKind::Custom)
+ } else {
+ None
+ }
+}
+
+fn is_selectable_mode(store: &AppStoreData, mode: &str) -> bool {
+ default_keys().contains_key(mode)
+ || (store.keys.contains_key(mode) && store.custom_tabs.iter().any(|tab| tab.id == mode))
+}
+
+fn set_mode_with(
+ store: &AppStoreData,
+ requested: String,
+ commit: Commit,
+ apply_runtime: ApplyRuntime,
+) -> CmdResult
+where
+ Commit: FnOnce(String) -> CmdResult,
+ ApplyRuntime: FnOnce(&str) -> CmdResult<()>,
+{
+ if !is_selectable_mode(store, &requested) {
+ return Ok(ModeResponse {
+ success: false,
+ mode: store.selected_key_type.clone(),
+ });
+ }
+
+ let effective = commit(requested.clone())?;
+ apply_runtime(&effective)?;
+ Ok(ModeResponse {
+ success: effective == requested,
+ mode: effective,
+ })
+}
+
+fn reset_mode_data(store: &mut AppStoreData, mode: &str, kind: ModeResetKind) {
+ match kind {
+ ModeResetKind::Default => {
+ if let Some(keys) = default_keys().get(mode) {
+ store.keys.insert(mode.to_string(), keys.clone());
+ }
+ if let Some(positions) = default_positions().get(mode) {
+ store
+ .key_positions
+ .insert(mode.to_string(), positions.clone());
+ }
+ }
+ ModeResetKind::Custom => {
+ store.keys.insert(mode.to_string(), Vec::new());
+ store.key_positions.insert(mode.to_string(), Vec::new());
+ }
+ }
+
+ store.stat_positions.insert(mode.to_string(), Vec::new());
+ store.graph_positions.insert(mode.to_string(), Vec::new());
+ store.knob_positions.insert(mode.to_string(), Vec::new());
+ store.layer_groups.remove(mode);
+ store.tab_css_overrides.remove(mode);
+ store.tab_note_overrides.remove(mode);
+
+ let mode_keys = store.keys.get(mode).cloned().unwrap_or_default();
+ store.key_counters.insert(
+ mode.to_string(),
+ mode_keys.into_iter().map(|key| (key, 0)).collect(),
+ );
+}
+
+fn plan_custom_tab_delete(store: &AppStoreData, id: &str) -> Option {
+ let index = store.custom_tabs.iter().position(|tab| tab.id == id)?;
+ let custom_tabs: Vec = store
+ .custom_tabs
+ .iter()
+ .filter(|tab| tab.id != id)
+ .cloned()
+ .collect();
+ let selected_tab_deleted = store.selected_key_type == id;
+ let next_selected = if selected_tab_deleted {
+ if custom_tabs.is_empty() {
+ "8key".to_string()
+ } else {
+ custom_tabs[if index > 0 { index - 1 } else { 0 }]
+ .id
+ .clone()
+ }
+ } else {
+ store.selected_key_type.clone()
+ };
+
+ Some(CustomTabDeletePlan {
+ custom_tabs,
+ next_selected,
+ })
+}
+
+fn delete_custom_tab_data(store: &mut AppStoreData, id: &str, plan: &CustomTabDeletePlan) {
+ store.custom_tabs = plan.custom_tabs.clone();
+ store.keys.remove(id);
+ store.key_positions.remove(id);
+ store.stat_positions.remove(id);
+ store.graph_positions.remove(id);
+ store.knob_positions.remove(id);
+ store.layer_groups.remove(id);
+ store.tab_css_overrides.remove(id);
+ store.tab_note_overrides.remove(id);
+ store.key_counters.remove(id);
+ store.selected_key_type = plan.next_selected.clone();
+}
+
#[derive(Serialize)]
pub struct ModeResponse {
pub success: bool,
@@ -80,9 +229,18 @@ pub fn keys_update(
app: AppHandle,
mappings: KeyMappings,
) -> CmdResult {
- let updated = state.store.update_keys(mappings)?;
- state.keyboard.update_mappings(updated.clone());
+ let previous_mode = state.keyboard.current_mode();
+ let (updated, selected_key_type) = state.store.update_keys(mappings)?;
+ state
+ .keyboard
+ .update_mappings_and_set_mode(updated.clone(), selected_key_type.clone());
app.emit("keys:changed", &updated)?;
+ if previous_mode != selected_key_type {
+ app.emit(
+ "keys:mode-changed",
+ &serde_json::json!({ "mode": &selected_key_type }),
+ )?;
+ }
state.sync_counters_with_keys(&updated);
app.emit("keys:counters", &state.snapshot_key_counters())?;
state.obs_broadcast_counters();
@@ -108,25 +266,26 @@ pub fn keys_set_mode(
app: AppHandle,
mode: String,
) -> CmdResult {
- let success = state.keyboard.set_mode(mode.clone());
- let effective = if success {
- mode
- } else {
- state.keyboard.current_mode()
- };
-
- state.transfer_active_keys(&effective);
- state.store.set_selected_key_type(effective.clone())?;
-
- app.emit(
- "keys:mode-changed",
- &serde_json::json!({ "mode": &effective }),
- )?;
- state.refresh_obs_snapshot();
- Ok(ModeResponse {
- success,
- mode: effective,
- })
+ let snapshot = state.store.snapshot();
+ set_mode_with(
+ &snapshot,
+ mode,
+ |candidate| {
+ state
+ .store
+ .set_selected_key_type(candidate)
+ .map_err(Into::into)
+ },
+ |effective| {
+ state.keyboard.set_mode(effective.to_string());
+ app.emit(
+ "keys:mode-changed",
+ &serde_json::json!({ "mode": effective }),
+ )?;
+ state.refresh_obs_snapshot();
+ Ok(())
+ },
+ )
}
#[tauri::command]
@@ -135,8 +294,10 @@ pub fn keys_reset_all(state: State<'_, AppState>, app: AppHandle) -> CmdResult = Vec::new();
let cleared_tab_css_ids: Vec = state
@@ -148,26 +309,17 @@ pub fn keys_reset_all(state: State<'_, AppState>, app: AppHandle) -> CmdResult, app: AppHandle) -> CmdResult, app: AppHandle) -> CmdResult CmdResult {
- let defaults = default_keys();
- if !defaults.contains_key(&mode) {
+ let snapshot = state.store.snapshot();
+ let Some(kind) = reset_mode_kind(&snapshot, &mode) else {
return Ok(ResetModeResponse {
success: false,
mode,
});
- }
-
- let default_pos = default_positions();
-
- let snapshot = state.store.snapshot();
- let mut keys = snapshot.keys;
- if let Some(value) = defaults.get(&mode) {
- keys.insert(mode.clone(), value.clone());
- }
- let mut positions = snapshot.key_positions;
- if let Some(value) = default_pos.get(&mode) {
- positions.insert(mode.clone(), value.clone());
- }
- let mut stat_positions = snapshot.stat_positions;
- stat_positions.insert(mode.clone(), Vec::new());
- let mut graph_positions = snapshot.graph_positions;
- graph_positions.insert(mode.clone(), Vec::new());
- let mut layer_groups = snapshot.layer_groups;
- layer_groups.remove(&mode);
- let mut tab_note_overrides = snapshot.tab_note_overrides;
- tab_note_overrides.remove(&mode);
- let mut tab_css_overrides = snapshot.tab_css_overrides;
- let cleared_tab_css = tab_css_overrides.remove(&mode).is_some();
+ };
+ let cleared_tab_css = snapshot.tab_css_overrides.contains_key(&mode);
+ let runtime_counters = state.snapshot_key_counters();
- state.store.update(|store| {
- store.keys = keys.clone();
- store.key_positions = positions.clone();
- store.stat_positions = stat_positions.clone();
- store.graph_positions = graph_positions.clone();
- store.layer_groups = layer_groups.clone();
- store.tab_note_overrides = tab_note_overrides.clone();
- store.tab_css_overrides = tab_css_overrides.clone();
+ let updated = state.store.update(|store| {
+ store.key_counters = runtime_counters.clone();
+ reset_mode_data(store, &mode, kind);
})?;
if cleared_tab_css {
state.unwatch_tab_css(&mode);
}
- state.keyboard.update_mappings(keys.clone());
- state.sync_counters_with_keys(&keys);
- state.reset_mode_counters(&mode);
- state.persist_key_counters()?;
+ state.keyboard.update_mappings(updated.keys.clone());
+ state.commit_key_counters_mirror(updated.key_counters.clone());
- app.emit("keys:changed", &keys)?;
- app.emit("positions:changed", &positions)?;
- app.emit("statPositions:changed", &stat_positions)?;
- app.emit("graphPositions:changed", &graph_positions)?;
- app.emit("layerGroups:changed", &layer_groups)?;
- app.emit("tabNote:changed_all", &tab_note_overrides)?;
+ app.emit("keys:changed", &updated.keys)?;
+ app.emit("positions:changed", &updated.key_positions)?;
+ app.emit("statPositions:changed", &updated.stat_positions)?;
+ app.emit("graphPositions:changed", &updated.graph_positions)?;
+ app.emit("knobPositions:changed", &updated.knob_positions)?;
+ app.emit("layerGroups:changed", &updated.layer_groups)?;
+ app.emit("tabNote:changed_all", &updated.tab_note_overrides)?;
if cleared_tab_css {
app.emit(
"tabCss:changed",
@@ -311,7 +438,7 @@ pub fn keys_reset_mode(
},
)?;
}
- app.emit("keys:counters", &state.snapshot_key_counters())?;
+ app.emit("keys:counters", &updated.key_counters)?;
state.obs_broadcast_counters();
state.refresh_obs_snapshot();
@@ -375,11 +502,11 @@ pub fn custom_tabs_create(
store.selected_key_type = id.clone();
})?;
- state.keyboard.update_mappings(keys.clone());
- state.keyboard.set_mode(id.clone());
+ state
+ .keyboard
+ .update_mappings_and_set_mode(keys.clone(), id.clone());
state.sync_counters_with_keys(&keys);
- state.reset_mode_counters(&id);
- state.persist_key_counters()?;
+ let counters_snapshot = state.reset_mode_counters(&id)?;
app.emit(
"customTabs:changed",
@@ -391,7 +518,7 @@ pub fn custom_tabs_create(
app.emit("keys:changed", &keys)?;
app.emit("positions:changed", &positions)?;
app.emit("keys:mode-changed", &serde_json::json!({ "mode": &id }))?;
- app.emit("keys:counters", &state.snapshot_key_counters())?;
+ app.emit("keys:counters", &counters_snapshot)?;
state.obs_broadcast_counters();
state.refresh_obs_snapshot();
@@ -408,77 +535,58 @@ pub fn custom_tabs_delete(
id: String,
) -> CmdResult {
let snapshot = state.store.snapshot();
- if !snapshot.custom_tabs.iter().any(|tab| tab.id == id) {
+ let Some(plan) = plan_custom_tab_delete(&snapshot, &id) else {
return Ok(CustomTabDeleteResult {
success: false,
selected: snapshot.selected_key_type,
error: Some("not-found".to_string()),
});
- }
-
- let custom_tabs: Vec = snapshot
- .custom_tabs
- .iter()
- .filter(|&tab| tab.id != id)
- .cloned()
- .collect();
- let mut keys = snapshot.keys.clone();
- let mut positions = snapshot.key_positions.clone();
- keys.remove(&id);
- positions.remove(&id);
-
- let next_selected = if snapshot.selected_key_type == id {
- if let Some((index, _)) = snapshot
- .custom_tabs
- .iter()
- .enumerate()
- .find(|(_, tab)| tab.id == id)
- {
- if !custom_tabs.is_empty() {
- let pick = if index > 0 { index - 1 } else { 0 };
- custom_tabs[pick].id.clone()
- } else {
- "8key".to_string()
- }
- } else {
- "8key".to_string()
- }
- } else {
- snapshot.selected_key_type.clone()
};
+ let runtime_counters = state.snapshot_key_counters();
- state.store.update(|store| {
- store.custom_tabs = custom_tabs.clone();
- store.keys = keys.clone();
- store.key_positions = positions.clone();
- store.selected_key_type = next_selected.clone();
+ let updated = state.store.update(|store| {
+ store.key_counters = runtime_counters.clone();
+ delete_custom_tab_data(store, &id, &plan);
})?;
- state.keyboard.update_mappings(keys.clone());
- state.keyboard.set_mode(next_selected.clone());
- state.sync_counters_with_keys(&keys);
- state.persist_key_counters()?;
+ state.unwatch_tab_css(&id);
+ state
+ .keyboard
+ .update_mappings_and_set_mode(updated.keys.clone(), updated.selected_key_type.clone());
+ state.commit_key_counters_mirror(updated.key_counters.clone());
app.emit(
"customTabs:changed",
&CustomTabChangePayload {
- custom_tabs: custom_tabs.clone(),
- selected_key_type: next_selected.clone(),
+ custom_tabs: updated.custom_tabs.clone(),
+ selected_key_type: updated.selected_key_type.clone(),
+ },
+ )?;
+ app.emit("keys:changed", &updated.keys)?;
+ app.emit("positions:changed", &updated.key_positions)?;
+ app.emit("statPositions:changed", &updated.stat_positions)?;
+ app.emit("graphPositions:changed", &updated.graph_positions)?;
+ app.emit("knobPositions:changed", &updated.knob_positions)?;
+ app.emit("layerGroups:changed", &updated.layer_groups)?;
+ app.emit("tabNote:changed_all", &updated.tab_note_overrides)?;
+ app.emit(
+ "tabCss:changed",
+ &crate::commands::editor::css::TabCssResponse {
+ tab_id: id,
+ css: None,
},
)?;
- app.emit("keys:changed", &keys)?;
- app.emit("positions:changed", &positions)?;
app.emit(
"keys:mode-changed",
- &serde_json::json!({ "mode": &next_selected }),
+ &serde_json::json!({ "mode": &updated.selected_key_type }),
)?;
- app.emit("keys:counters", &state.snapshot_key_counters())?;
+ app.emit("keys:counters", &updated.key_counters)?;
state.obs_broadcast_counters();
state.refresh_obs_snapshot();
Ok(CustomTabDeleteResult {
success: true,
- selected: next_selected,
+ selected: updated.selected_key_type,
error: None,
})
}
@@ -498,9 +606,7 @@ pub fn custom_tabs_select(
id: String,
) -> CmdResult {
let snapshot = state.store.snapshot();
- let defaults = default_keys();
- let exists = defaults.contains_key(&id) || snapshot.custom_tabs.iter().any(|tab| tab.id == id);
- if !exists {
+ if !is_selectable_mode(&snapshot, &id) {
return Ok(CustomTabSelectResult {
success: false,
selected: snapshot.selected_key_type,
@@ -508,16 +614,18 @@ pub fn custom_tabs_select(
});
}
- state.store.set_selected_key_type(id.clone())?;
- state.keyboard.set_mode(id.clone());
- state.transfer_active_keys(&id);
+ let selected = state.store.set_selected_key_type(id)?;
+ state.keyboard.set_mode(selected.clone());
- app.emit("keys:mode-changed", &serde_json::json!({ "mode": &id }))?;
+ app.emit(
+ "keys:mode-changed",
+ &serde_json::json!({ "mode": &selected }),
+ )?;
state.refresh_obs_snapshot();
Ok(CustomTabSelectResult {
success: true,
- selected: id,
+ selected,
error: None,
})
}
@@ -530,24 +638,23 @@ pub fn custom_tabs_restore(
custom_tabs: Vec,
selected_key_type: String,
) -> CmdResult<()> {
- state.store.update(|store| {
+ let updated = state.store.update(|store| {
store.custom_tabs = custom_tabs.clone();
store.selected_key_type = selected_key_type.clone();
})?;
- state.keyboard.set_mode(selected_key_type.clone());
- state.transfer_active_keys(&selected_key_type);
+ state.keyboard.set_mode(updated.selected_key_type.clone());
app.emit(
"customTabs:changed",
&CustomTabChangePayload {
- custom_tabs,
- selected_key_type: selected_key_type.clone(),
+ custom_tabs: updated.custom_tabs,
+ selected_key_type: updated.selected_key_type.clone(),
},
)?;
app.emit(
"keys:mode-changed",
- &serde_json::json!({ "mode": &selected_key_type }),
+ &serde_json::json!({ "mode": &updated.selected_key_type }),
)?;
state.refresh_obs_snapshot();
Ok(())
@@ -555,8 +662,7 @@ pub fn custom_tabs_restore(
#[tauri::command]
pub fn keys_reset_counters(state: State<'_, AppState>, app: AppHandle) -> CmdResult {
- let snapshot = state.reset_key_counters();
- state.persist_key_counters()?;
+ let snapshot = state.reset_key_counters()?;
app.emit("keys:counters", &snapshot)?;
state.obs_broadcast_counters();
Ok(snapshot)
@@ -568,9 +674,7 @@ pub fn keys_reset_counters_mode(
app: AppHandle,
mode: String,
) -> CmdResult {
- state.reset_mode_counters(&mode);
- state.persist_key_counters()?;
- let snapshot = state.snapshot_key_counters();
+ let snapshot = state.reset_mode_counters(&mode)?;
app.emit("keys:counters", &snapshot)?;
state.obs_broadcast_counters();
Ok(snapshot)
@@ -583,9 +687,7 @@ pub fn keys_reset_single_counter(
mode: String,
key: String,
) -> CmdResult {
- state.reset_single_key_counter(&mode, &key);
- state.persist_key_counters()?;
- let snapshot = state.snapshot_key_counters();
+ let snapshot = state.reset_single_key_counter(&mode, &key)?;
app.emit("keys:counters", &snapshot)?;
state.obs_broadcast_counters();
Ok(snapshot)
@@ -649,3 +751,235 @@ pub fn raw_input_unsubscribe(state: State<'_, AppState>) -> CmdResult AppStoreData {
+ let position = default_positions()
+ .values()
+ .next()
+ .and_then(|positions| positions.first())
+ .cloned()
+ .expect("default position fixture");
+ let mut store = AppStoreData {
+ custom_tabs: vec![
+ CustomTab {
+ id: "custom-before".to_string(),
+ name: "Before".to_string(),
+ },
+ CustomTab {
+ id: TARGET_TAB.to_string(),
+ name: "Target".to_string(),
+ },
+ ],
+ selected_key_type: TARGET_TAB.to_string(),
+ ..AppStoreData::default()
+ };
+ store
+ .keys
+ .insert(TARGET_TAB.to_string(), vec!["KeyD".to_string()]);
+ store
+ .key_positions
+ .insert(TARGET_TAB.to_string(), vec![position.clone()]);
+ store.stat_positions.insert(
+ TARGET_TAB.to_string(),
+ vec![StatPosition {
+ stat_type: StatType::Kps,
+ position: position.clone(),
+ }],
+ );
+ store.graph_positions.insert(
+ TARGET_TAB.to_string(),
+ vec![GraphPosition {
+ stat_type: GraphStatType::Kps,
+ graph_type: GraphType::Line,
+ graph_speed: 1,
+ graph_color: "#ffffff".to_string(),
+ show_avg_line: true,
+ position: position.clone(),
+ }],
+ );
+ store.knob_positions.insert(
+ TARGET_TAB.to_string(),
+ vec![KnobPosition {
+ axis_id: "axis".to_string(),
+ sensitivity: 1.0,
+ reverse: false,
+ position,
+ }],
+ );
+ store.layer_groups.insert(
+ TARGET_TAB.to_string(),
+ vec![LayerGroupDef {
+ id: "group".to_string(),
+ name: "Group".to_string(),
+ }],
+ );
+ store
+ .tab_css_overrides
+ .insert(TARGET_TAB.to_string(), TabCss::default());
+ store
+ .tab_note_overrides
+ .insert(TARGET_TAB.to_string(), TabNoteSettings::default());
+ store.key_counters.insert(
+ TARGET_TAB.to_string(),
+ [("KeyD".to_string(), 7)].into_iter().collect(),
+ );
+ store
+ }
+
+ #[test]
+ fn deleting_selected_custom_tab_clears_all_tab_scoped_data() {
+ let mut store = populated_custom_tab_store();
+ let plan = plan_custom_tab_delete(&store, TARGET_TAB).expect("delete plan");
+
+ assert_eq!(plan.next_selected, "custom-before");
+ delete_custom_tab_data(&mut store, TARGET_TAB, &plan);
+
+ assert!(!store.custom_tabs.iter().any(|tab| tab.id == TARGET_TAB));
+ assert!(!store.keys.contains_key(TARGET_TAB));
+ assert!(!store.key_positions.contains_key(TARGET_TAB));
+ assert!(!store.stat_positions.contains_key(TARGET_TAB));
+ assert!(!store.graph_positions.contains_key(TARGET_TAB));
+ assert!(!store.knob_positions.contains_key(TARGET_TAB));
+ assert!(!store.layer_groups.contains_key(TARGET_TAB));
+ assert!(!store.tab_css_overrides.contains_key(TARGET_TAB));
+ assert!(!store.tab_note_overrides.contains_key(TARGET_TAB));
+ assert!(!store.key_counters.contains_key(TARGET_TAB));
+ assert_eq!(store.selected_key_type, "custom-before");
+ }
+
+ #[test]
+ fn reset_all_clears_knob_positions_and_zeroes_default_counters() {
+ let mut store = populated_custom_tab_store();
+ reset_all_editor_data(&mut store, default_keys(), default_positions());
+
+ assert!(store.knob_positions.is_empty());
+ assert!(store.custom_tabs.is_empty());
+ assert_eq!(store.selected_key_type, "4key");
+ assert!(store
+ .key_counters
+ .values()
+ .flat_map(|mode| mode.values())
+ .all(|count| *count == 0));
+ }
+
+ #[test]
+ fn custom_mode_reset_is_supported_and_preserves_tab_identity() {
+ let mut store = populated_custom_tab_store();
+ let tabs_before = store.custom_tabs.clone();
+ let kind = reset_mode_kind(&store, TARGET_TAB);
+
+ assert_eq!(kind, Some(ModeResetKind::Custom));
+ reset_mode_data(&mut store, TARGET_TAB, kind.unwrap());
+
+ assert_eq!(store.custom_tabs, tabs_before);
+ assert!(store.keys[TARGET_TAB].is_empty());
+ assert!(store.key_positions[TARGET_TAB].is_empty());
+ assert!(store.stat_positions[TARGET_TAB].is_empty());
+ assert!(store.graph_positions[TARGET_TAB].is_empty());
+ assert!(store.knob_positions[TARGET_TAB].is_empty());
+ assert!(!store.layer_groups.contains_key(TARGET_TAB));
+ assert!(!store.tab_css_overrides.contains_key(TARGET_TAB));
+ assert!(!store.tab_note_overrides.contains_key(TARGET_TAB));
+ assert!(store.key_counters[TARGET_TAB].is_empty());
+ }
+
+ #[test]
+ fn default_mode_reset_clears_knob_positions() {
+ let mut store = AppStoreData::default();
+ store.knob_positions.insert(
+ "4key".to_string(),
+ populated_custom_tab_store().knob_positions[TARGET_TAB].clone(),
+ );
+
+ reset_mode_data(&mut store, "4key", ModeResetKind::Default);
+
+ assert!(store.knob_positions["4key"].is_empty());
+ }
+
+ #[test]
+ fn ghost_mode_request_leaves_store_keyboard_and_events_unchanged() {
+ let mut store = AppStoreData {
+ selected_key_type: "8key".to_string(),
+ ..AppStoreData::default()
+ };
+ store
+ .keys
+ .insert("ghost-mode".to_string(), vec!["KeyA".to_string()]);
+ let keyboard = KeyboardManager::new(store.keys.clone(), "8key");
+ let commit_calls = Cell::new(0);
+ let emit_calls = Cell::new(0);
+
+ let response = set_mode_with(
+ &store,
+ "ghost-mode".to_string(),
+ |candidate| {
+ commit_calls.set(commit_calls.get() + 1);
+ Ok(candidate)
+ },
+ |effective| {
+ keyboard.set_mode(effective.to_string());
+ emit_calls.set(emit_calls.get() + 1);
+ Ok(())
+ },
+ )
+ .unwrap();
+
+ assert!(!response.success);
+ assert_eq!(response.mode, "8key");
+ assert_eq!(store.selected_key_type, "8key");
+ assert_eq!(keyboard.current_mode(), "8key");
+ assert_eq!(commit_calls.get(), 0);
+ assert_eq!(emit_calls.get(), 0);
+ }
+
+ #[test]
+ fn absent_mode_request_remains_a_no_op() {
+ let store = AppStoreData {
+ selected_key_type: "8key".to_string(),
+ ..AppStoreData::default()
+ };
+ let keyboard = KeyboardManager::new(store.keys.clone(), "8key");
+ let commit_calls = Cell::new(0);
+ let emit_calls = Cell::new(0);
+
+ let response = set_mode_with(
+ &store,
+ "missing-mode".to_string(),
+ |candidate| {
+ commit_calls.set(commit_calls.get() + 1);
+ Ok(candidate)
+ },
+ |effective| {
+ keyboard.set_mode(effective.to_string());
+ emit_calls.set(emit_calls.get() + 1);
+ Ok(())
+ },
+ )
+ .unwrap();
+
+ assert!(!response.success);
+ assert_eq!(response.mode, "8key");
+ assert_eq!(store.selected_key_type, "8key");
+ assert_eq!(keyboard.current_mode(), "8key");
+ assert_eq!(commit_calls.get(), 0);
+ assert_eq!(emit_calls.get(), 0);
+ }
+}
diff --git a/src-tauri/src/commands/keys/sound.rs b/src-tauri/src/commands/keys/sound.rs
index 50ad96bb..d15316a1 100644
--- a/src-tauri/src/commands/keys/sound.rs
+++ b/src-tauri/src/commands/keys/sound.rs
@@ -11,12 +11,38 @@ use tauri::{Emitter, Manager, State};
use uuid::Uuid;
use crate::errors::{CmdResult, CommandError};
-use crate::models::{SoundLibraryEntry, SoundSource};
-use crate::state::AppState;
+use crate::models::{AppStoreData, PendingProcessedWavReplacement, SoundLibraryEntry, SoundSource};
+use crate::state::{
+ atomic_file::{prepare_atomic_replace, PreparedAtomicReplace},
+ store::{
+ move_staged_sound_deletions_to_trash, restore_staged_sound_deletions,
+ stage_sound_files_for_deletion, PROCESSED_WAV_TRANSACTION_LOCK,
+ },
+ AppState,
+};
const SUPPORTED_SOUND_EXTENSIONS: [&str; 8] =
["wav", "mp3", "ogg", "flac", "m4a", "aac", "aif", "aiff"];
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum SoundReferenceChangeEvent {
+ Key,
+ Stat,
+ Graph,
+ Knob,
+}
+
+impl SoundReferenceChangeEvent {
+ fn name(self) -> &'static str {
+ match self {
+ Self::Key => "positions:changed",
+ Self::Stat => "statPositions:changed",
+ Self::Graph => "graphPositions:changed",
+ Self::Knob => "knobPositions:changed",
+ }
+ }
+}
+
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SoundLoadResponse {
@@ -152,27 +178,57 @@ pub fn sound_list(
state: State<'_, AppState>,
) -> CmdResult> {
let sounds_dir = ensure_sounds_dir(&app)?;
+ let _transaction_guard = PROCESSED_WAV_TRANSACTION_LOCK.lock();
+ let recovery_complete = state.store.prepare_sound_listing_while_locked()?;
let mut items = Vec::new();
let mut library = state.store.with_state(|s| s.sound_library.clone());
let mut seen_paths = HashSet::new();
let mut library_mutated = false;
+ let mut scan_complete = recovery_complete;
let entries = fs::read_dir(&sounds_dir)
.map_err(|e| CommandError::msg(format!("사운드 디렉토리 읽기 실패: {e}")))?;
for entry_result in entries {
- let Ok(entry) = entry_result else {
- continue;
+ let entry = match entry_result {
+ Ok(entry) => entry,
+ Err(error) => {
+ scan_complete = false;
+ log::warn!("[Sounds] 사운드 항목 열거 실패: {error}");
+ continue;
+ }
};
let path = entry.path();
- if !path.is_file() || !is_supported_sound_file(&path) {
+ let file_type = match entry.file_type() {
+ Ok(file_type) => file_type,
+ Err(error) => {
+ scan_complete = false;
+ log::warn!(
+ "[Sounds] 사운드 항목 형식 확인 실패 ('{}'): {error}",
+ path.display()
+ );
+ continue;
+ }
+ };
+ if file_type.is_dir() || !is_supported_sound_file(&path) {
continue;
}
- let Ok(metadata) = entry.metadata() else {
- continue;
+ let metadata = match entry.metadata() {
+ Ok(metadata) => metadata,
+ Err(error) => {
+ scan_complete = false;
+ log::warn!(
+ "[Sounds] 사운드 메타데이터 확인 실패 ('{}'): {error}",
+ path.display()
+ );
+ continue;
+ }
};
+ if !metadata.is_file() {
+ continue;
+ }
let file_name = path
.file_name()
@@ -216,11 +272,7 @@ pub fn sound_list(
});
}
- let stale_keys: Vec = library
- .keys()
- .filter(|key| !seen_paths.contains(*key))
- .cloned()
- .collect();
+ let stale_keys = stale_sound_library_keys(&library, &seen_paths, scan_complete);
if !stale_keys.is_empty() {
for key in stale_keys {
library.remove(&key);
@@ -251,6 +303,21 @@ pub fn sound_list(
Ok(items)
}
+fn stale_sound_library_keys(
+ library: &std::collections::HashMap,
+ seen_paths: &HashSet,
+ scan_complete: bool,
+) -> Vec {
+ if !scan_complete {
+ return Vec::new();
+ }
+ library
+ .keys()
+ .filter(|key| !seen_paths.contains(*key))
+ .cloned()
+ .collect()
+}
+
#[tauri::command]
pub fn sound_set_hidden(
app: tauri::AppHandle,
@@ -293,7 +360,7 @@ fn set_sound_hidden(
return Err(CommandError::msg("대상 사운드 파일이 존재하지 않습니다."));
}
- let path_key = normalize_path_string(&validated_path);
+ let path_key = resolve_stored_sound_path_key(state, &validated_path);
state.store.update(|store| {
store
.sound_library
@@ -316,7 +383,7 @@ pub fn sound_rename(
if !validated_path.exists() {
return Err(CommandError::msg("대상 사운드 파일이 존재하지 않습니다."));
}
- let path_key = normalize_path_string(&validated_path);
+ let path_key = resolve_stored_sound_path_key(state.inner(), &validated_path);
let trimmed = display_name.trim();
if trimmed.is_empty() {
@@ -358,8 +425,14 @@ pub fn sound_delete(
sound_path: String,
) -> CmdResult {
let sounds_dir = ensure_sounds_dir(&app)?;
+ let trash_dir = app
+ .path()
+ .app_data_dir()
+ .map_err(|error| CommandError::msg(format!("앱 데이터 경로 확인 실패: {error}")))?
+ .join("trash");
let validated_path = validate_sound_path(&sounds_dir, &sound_path)?;
- let path_key = normalize_path_string(&validated_path);
+ let path_key = resolve_stored_sound_path_key(state.inner(), &validated_path);
+ let stored_path = validate_sound_path(&sounds_dir, &path_key)?;
// 내장 사운드 삭제 차단 (OBS/플러그인 경유 호출 포함)
let is_builtin = state.store.with_state(|s| {
@@ -371,71 +444,151 @@ pub fn sound_delete(
return Err(CommandError::msg("내장 사운드는 삭제할 수 없습니다."));
}
- // 라이브러리에서 원본 경로를 먼저 조회
+ // 라이브러리에서 원본 경로 선조회
let original_rel_path = state.store.with_state(|s| {
s.sound_library
.get(&path_key)
.and_then(|entry| entry.original_path.clone())
});
+ let original_path = original_rel_path.as_ref().and_then(|orig_rel| {
+ let original_path = sounds_dir.join(orig_rel);
+ match validate_sound_path(&sounds_dir, &original_path.to_string_lossy()) {
+ Ok(original_path) => Some(original_path),
+ Err(error) => {
+ log::warn!("[Sound] 잘못된 원본 사운드 경로 무시: {error}");
+ None
+ }
+ }
+ });
+
+ let _transaction_guard = PROCESSED_WAV_TRANSACTION_LOCK.lock();
+ let source_paths: Vec = std::iter::once(stored_path)
+ .chain(original_path.clone())
+ .collect();
+ let staged = stage_sound_files_for_deletion(&source_paths)
+ .map_err(|error| CommandError::msg(format!("사운드 파일 삭제 준비 실패: {error:#}")))?;
+
+ let mut references_changed = false;
+ let updated = commit_staged_sound_deletion(&staged, || {
+ state
+ .store
+ .update(|store| {
+ references_changed = remove_sound_entry_and_references(store, &path_key);
+ })
+ .map_err(Into::into)
+ })?;
+
+ state.key_sound_invalidate_file_cache(&path_key);
+ if let Err(error) = move_staged_sound_deletions_to_trash(&staged, &trash_dir) {
+ // store 커밋은 끝났고 숨은 삭제 백업은 다음 시작 시 다시 trash로 이동
+ log::warn!("[Sound] 삭제 파일 trash 이동 지연: {error:#}");
+ }
- if validated_path.exists() {
- fs::remove_file(&validated_path)
- .map_err(|e| CommandError::msg(format!("사운드 파일 삭제 실패: {e}")))?;
+ if references_changed {
+ emit_sound_reference_changes_with(|event| match event {
+ SoundReferenceChangeEvent::Key => app.emit(event.name(), &updated.key_positions),
+ SoundReferenceChangeEvent::Stat => app.emit(event.name(), &updated.stat_positions),
+ SoundReferenceChangeEvent::Graph => app.emit(event.name(), &updated.graph_positions),
+ SoundReferenceChangeEvent::Knob => app.emit(event.name(), &updated.knob_positions),
+ });
}
- // 원본 파일도 삭제
- if let Some(ref orig_rel) = original_rel_path {
- let orig_abs = sounds_dir.join(orig_rel);
- if orig_abs.exists() && orig_abs.starts_with(&sounds_dir) {
- if let Err(e) = fs::remove_file(&orig_abs) {
- log::warn!("[Sound] 원본 사운드 파일 삭제 실패: {e}");
+ Ok(SoundDeleteResponse { success: true })
+}
+
+fn remove_sound_entry_and_references(store: &mut AppStoreData, path_key: &str) -> bool {
+ store.sound_library.remove(path_key);
+ let mut references_changed = false;
+
+ for positions in store.key_positions.values_mut() {
+ for position in positions.iter_mut() {
+ if position.sound_path.as_deref() == Some(path_key) {
+ position.sound_path = None;
+ position.sound_enabled = Some(false);
+ references_changed = true;
}
}
}
- // 라이브러리 엔트리 제거 + 키 참조 정리를 하나의 트랜잭션으로
- let mut references_changed = false;
- let updated = state.store.update(|store| {
- store.sound_library.remove(&path_key);
-
- for positions in store.key_positions.values_mut() {
- for position in positions.iter_mut() {
- if position.sound_path.as_deref() == Some(&path_key) {
- position.sound_path = None;
- position.sound_enabled = Some(false);
- references_changed = true;
- }
+ for positions in store.stat_positions.values_mut() {
+ for stat_position in positions.iter_mut() {
+ if stat_position.position.sound_path.as_deref() == Some(path_key) {
+ stat_position.position.sound_path = None;
+ stat_position.position.sound_enabled = Some(false);
+ references_changed = true;
}
}
+ }
- for positions in store.stat_positions.values_mut() {
- for stat_position in positions.iter_mut() {
- if stat_position.position.sound_path.as_deref() == Some(&path_key) {
- stat_position.position.sound_path = None;
- stat_position.position.sound_enabled = Some(false);
- references_changed = true;
- }
+ for positions in store.graph_positions.values_mut() {
+ for graph_position in positions.iter_mut() {
+ if graph_position.position.sound_path.as_deref() == Some(path_key) {
+ graph_position.position.sound_path = None;
+ graph_position.position.sound_enabled = Some(false);
+ references_changed = true;
}
}
+ }
- for positions in store.graph_positions.values_mut() {
- for graph_position in positions.iter_mut() {
- if graph_position.position.sound_path.as_deref() == Some(&path_key) {
- graph_position.position.sound_path = None;
- graph_position.position.sound_enabled = Some(false);
- references_changed = true;
- }
+ for positions in store.knob_positions.values_mut() {
+ for knob_position in positions.iter_mut() {
+ if knob_position.position.sound_path.as_deref() == Some(path_key) {
+ knob_position.position.sound_path = None;
+ knob_position.position.sound_enabled = Some(false);
+ references_changed = true;
}
}
- })?;
+ }
- if references_changed {
- app.emit("positions:changed", &updated.key_positions)?;
- app.emit("statPositions:changed", &updated.stat_positions)?;
- app.emit("graphPositions:changed", &updated.graph_positions)?;
+ references_changed
+}
+
+fn sound_delete_rollback_error(
+ primary: CommandError,
+ rollback: anyhow::Result<()>,
+) -> CommandError {
+ match rollback {
+ Ok(()) => primary,
+ Err(rollback) => {
+ CommandError::msg(format!("{primary}; 삭제 준비 파일 원복 실패: {rollback:#}"))
+ }
}
+}
- Ok(SoundDeleteResponse { success: true })
+fn commit_staged_sound_deletion(
+ staged: &[crate::state::store::StagedSoundDeletionFile],
+ commit: Commit,
+) -> CmdResult
+where
+ Commit: FnOnce() -> CmdResult,
+{
+ match commit() {
+ Ok(value) => Ok(value),
+ Err(error) => Err(sound_delete_rollback_error(
+ error,
+ restore_staged_sound_deletions(staged),
+ )),
+ }
+}
+
+fn emit_sound_reference_changes_with(mut emit: Emit)
+where
+ Emit: FnMut(SoundReferenceChangeEvent) -> Result<(), Error>,
+ Error: std::fmt::Display,
+{
+ for event in [
+ SoundReferenceChangeEvent::Key,
+ SoundReferenceChangeEvent::Stat,
+ SoundReferenceChangeEvent::Graph,
+ SoundReferenceChangeEvent::Knob,
+ ] {
+ if let Err(error) = emit(event) {
+ log::warn!(
+ "[Sound] 삭제 후 '{}' 이벤트 전송 실패: {error}",
+ event.name()
+ );
+ }
+ }
}
#[tauri::command]
@@ -571,7 +724,7 @@ pub fn sound_load_original(
) -> CmdResult {
let sounds_dir = ensure_sounds_dir(&app)?;
let validated_path = validate_sound_path(&sounds_dir, &sound_path)?;
- let path_key = normalize_path_string(&validated_path);
+ let path_key = resolve_stored_sound_path_key(state.inner(), &validated_path);
let original_rel = state
.store
@@ -582,10 +735,8 @@ pub fn sound_load_original(
})
.ok_or_else(|| CommandError::msg("원본 파일 정보가 없습니다."))?;
- let original_abs = sounds_dir.join(&original_rel);
- if !original_abs.starts_with(&sounds_dir) {
- return Err(CommandError::msg("잘못된 원본 경로입니다."));
- }
+ let original_path = sounds_dir.join(&original_rel);
+ let original_abs = validate_sound_path(&sounds_dir, &original_path.to_string_lossy())?;
if !original_abs.exists() {
return Err(CommandError::msg("원본 파일이 존재하지 않습니다."));
}
@@ -634,7 +785,7 @@ pub fn sound_update_processed_wav(
) -> CmdResult {
let sounds_dir = ensure_sounds_dir(&app)?;
let validated_path = validate_sound_path(&sounds_dir, &request.sound_path)?;
- let path_key = normalize_path_string(&validated_path);
+ let path_key = resolve_stored_sound_path_key(state.inner(), &validated_path);
// 내장 사운드 덮어쓰기 차단 (OBS/플러그인 경유 호출 포함)
let is_builtin = state.store.with_state(|s| {
@@ -660,19 +811,46 @@ pub fn sound_update_processed_wav(
});
}
- fs::write(&validated_path, wav_bytes)
- .map_err(|e| CommandError::msg(format!("편집된 사운드 저장 실패: {e}")))?;
-
- state.store.update(|s| {
- if let Some(entry) = s.sound_library.get_mut(&path_key) {
- entry.trim_start_ratio = request.trim_start_ratio;
- entry.trim_end_ratio = request.trim_end_ratio;
- if let Some(ref name) = request.display_name {
- entry.display_name = Some(name.clone());
- }
- }
+ let _transaction_guard = PROCESSED_WAV_TRANSACTION_LOCK.lock();
+ state
+ .store
+ .recover_interrupted_processed_wav_replacements_while_locked()?;
+ ensure_existing_sound_edit_target(&validated_path)?;
+ let pending = PendingProcessedWavReplacement {
+ sound_path: normalize_path_string(&validated_path),
+ had_original: validated_path.exists(),
+ };
+ state.store.update(|store| {
+ store.pending_processed_wav_replacement = Some(pending.clone());
})?;
+ let replacement_result = replace_processed_wav_with(
+ &validated_path,
+ &wav_bytes,
+ || {
+ state.store.update(|store| {
+ if let Some(entry) = store.sound_library.get_mut(&path_key) {
+ entry.trim_start_ratio = request.trim_start_ratio;
+ entry.trim_end_ratio = request.trim_end_ratio;
+ if let Some(ref name) = request.display_name {
+ entry.display_name = Some(name.clone());
+ }
+ }
+ store.pending_processed_wav_replacement = None;
+ })?;
+ Ok(())
+ },
+ |path, bytes| prepare_atomic_replace(path, bytes, "processed-wav"),
+ PreparedAtomicReplace::commit,
+ |path| fs::remove_file(path),
+ );
+ if let Err(error) = replacement_result {
+ // 파일 롤백 자체가 실패했을 수 있으므로 복구 표식은 다음 재시도까지 보존
+ return Err(CommandError::msg(format!(
+ "편집된 사운드 저장 실패: {error}"
+ )));
+ }
+
// 키음 엔진 캐시에서 이전 디코딩 결과 무효화
state.key_sound_invalidate_file_cache(&path_key);
@@ -682,19 +860,311 @@ pub fn sound_update_processed_wav(
})
}
+fn ensure_existing_sound_edit_target(path: &Path) -> CmdResult<()> {
+ match path.try_exists() {
+ Ok(true) if path.is_file() => Ok(()),
+ Ok(true) => Err(CommandError::msg("대상 사운드 경로가 파일이 아닙니다.")),
+ Ok(false) => Err(CommandError::msg("편집할 사운드 파일을 찾을 수 없습니다.")),
+ Err(error) => Err(CommandError::msg(format!(
+ "편집할 사운드 파일 확인 실패: {error}"
+ ))),
+ }
+}
+
+fn replace_processed_wav_with(
+ target_path: &Path,
+ wav_bytes: &[u8],
+ save_metadata: Save,
+ prepare: Prepare,
+ commit: Commit,
+ cleanup_backup: Cleanup,
+) -> CmdResult<()>
+where
+ Save: FnOnce() -> CmdResult<()>,
+ Prepare: FnOnce(&Path, &[u8]) -> anyhow::Result,
+ Commit: FnOnce(PreparedAtomicReplace) -> anyhow::Result<()>,
+ Cleanup: FnOnce(&Path) -> std::io::Result<()>,
+{
+ let backup_path = backup_path_for(target_path)?;
+ restore_interrupted_processed_wav_backup(target_path, &backup_path)?;
+
+ if target_path.exists() && !target_path.is_file() {
+ return Err(CommandError::msg("대상 사운드 경로가 파일이 아닙니다."));
+ }
+
+ if backup_path.exists() {
+ fs::remove_file(&backup_path)?;
+ }
+
+ let prepared = prepare(target_path, wav_bytes)?;
+ let had_original = target_path.exists();
+ if had_original {
+ fs::rename(target_path, &backup_path)?;
+ }
+
+ if let Err(error) = commit(prepared) {
+ let rollback_result =
+ restore_processed_wav(target_path, had_original.then_some(&backup_path));
+ return Err(with_rollback_error(error.into(), rollback_result, None));
+ }
+
+ if let Err(error) = save_metadata() {
+ let file_result = restore_processed_wav(target_path, had_original.then_some(&backup_path));
+ return Err(with_rollback_error(error, file_result, None));
+ }
+
+ if had_original {
+ if let Err(error) = cleanup_backup(&backup_path) {
+ // 새 파일과 메타데이터는 이미 함께 커밋됨. 백업은 종료 시 격리 청소 대상
+ log::warn!(
+ "편집된 WAV 백업 정리 지연 ({}): {}",
+ backup_path.display(),
+ error
+ );
+ }
+ }
+
+ Ok(())
+}
+
+fn restore_interrupted_processed_wav_backup(
+ target_path: &Path,
+ backup_path: &Path,
+) -> CmdResult<()> {
+ restore_interrupted_processed_wav_backup_with(target_path, backup_path, |from, to| {
+ fs::rename(from, to)
+ })
+}
+
+fn restore_interrupted_processed_wav_backup_with(
+ target_path: &Path,
+ backup_path: &Path,
+ rename: Rename,
+) -> CmdResult<()>
+where
+ Rename: FnOnce(&Path, &Path) -> std::io::Result<()>,
+{
+ if !target_path.exists() && backup_path.exists() {
+ rename(backup_path, target_path).map_err(|error| {
+ CommandError::msg(format!(
+ "중단된 WAV 백업 복구 실패 ('{}' → '{}'): {error}",
+ backup_path.display(),
+ target_path.display()
+ ))
+ })?;
+ }
+
+ Ok(())
+}
+
+fn backup_path_for(path: &Path) -> CmdResult {
+ let mut file_name = path
+ .file_name()
+ .ok_or_else(|| CommandError::msg("사운드 파일명이 없습니다."))?
+ .to_os_string();
+ file_name.push(".bak");
+ Ok(path.with_file_name(file_name))
+}
+
+fn restore_processed_wav(target_path: &Path, backup_path: Option<&Path>) -> std::io::Result<()> {
+ match backup_path {
+ Some(backup_path) => {
+ if !target_path.exists() {
+ return fs::rename(backup_path, target_path);
+ }
+
+ let rollback_path = rollback_path_for(target_path);
+ fs::rename(target_path, &rollback_path)?;
+ if let Err(error) = fs::rename(backup_path, target_path) {
+ return match fs::rename(&rollback_path, target_path) {
+ Ok(()) => Err(error),
+ Err(recovery_error) => Err(std::io::Error::other(format!(
+ "{error}; 새 WAV 재배치 실패: {recovery_error}"
+ ))),
+ };
+ }
+ fs::remove_file(rollback_path)
+ }
+ None if target_path.exists() => {
+ let rollback_path = rollback_path_for(target_path);
+ fs::rename(target_path, &rollback_path)?;
+ fs::remove_file(rollback_path)
+ }
+ None => Ok(()),
+ }
+}
+
+fn rollback_path_for(path: &Path) -> PathBuf {
+ let mut file_name = path.file_name().unwrap_or_default().to_os_string();
+ file_name.push(format!(".rollback-{}", Uuid::new_v4()));
+ path.with_file_name(file_name)
+}
+
+fn with_rollback_error(
+ primary: CommandError,
+ file_result: std::io::Result<()>,
+ metadata_result: Option>,
+) -> CommandError {
+ let mut failures = Vec::new();
+ if let Err(error) = file_result {
+ failures.push(format!("WAV 원복 실패: {error}"));
+ }
+ if let Some(Err(error)) = metadata_result {
+ failures.push(format!("메타데이터 원복 실패: {error}"));
+ }
+
+ if failures.is_empty() {
+ primary
+ } else {
+ CommandError::msg(format!("{primary}; {}", failures.join("; ")))
+ }
+}
+
+fn resolve_stored_sound_path_key(state: &AppState, validated_path: &Path) -> String {
+ let mut stored_keys = state
+ .store
+ .with_state(|store| store.sound_library.keys().cloned().collect::>());
+ stored_keys.sort_unstable();
+ resolve_sound_path_key_from_keys(validated_path, &stored_keys)
+}
+
+fn resolve_sound_path_key_from_keys(validated_path: &Path, stored_keys: &[String]) -> String {
+ let input_key = normalize_path_string(validated_path);
+ if stored_keys
+ .iter()
+ .any(|stored_key| stored_key == &input_key)
+ {
+ return input_key;
+ }
+
+ let Ok(canonical_input) = canonicalize_sound_path(validated_path) else {
+ return input_key;
+ };
+
+ stored_keys
+ .iter()
+ .find(|stored_key| {
+ canonicalize_sound_path(Path::new(stored_key)).is_ok_and(|canonical_stored| {
+ canonical_paths_equivalent(&canonical_input, &canonical_stored)
+ })
+ })
+ .cloned()
+ .unwrap_or(input_key)
+}
+
+fn canonical_paths_equivalent(left: &Path, right: &Path) -> bool {
+ #[cfg(windows)]
+ {
+ windows_canonical_path_key(left) == windows_canonical_path_key(right)
+ }
+ #[cfg(not(windows))]
+ {
+ left == right
+ }
+}
+
+#[cfg(windows)]
+fn windows_canonical_path_key(path: &Path) -> String {
+ let normalized = path
+ .to_string_lossy()
+ .replace('/', "\\")
+ .to_ascii_lowercase();
+ if let Some(rest) = normalized.strip_prefix("\\\\?\\unc\\") {
+ format!("\\\\{rest}")
+ } else {
+ normalized
+ .strip_prefix("\\\\?\\")
+ .unwrap_or(&normalized)
+ .to_string()
+ }
+}
+
+fn canonicalize_sound_path(path: &Path) -> CmdResult {
+ match fs::canonicalize(path) {
+ Ok(path) => Ok(path),
+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+ match fs::symlink_metadata(path) {
+ Ok(_) => {
+ return Err(CommandError::msg(format!("사운드 경로 확인 실패: {error}")));
+ }
+ Err(metadata_error) if metadata_error.kind() != std::io::ErrorKind::NotFound => {
+ return Err(CommandError::msg(format!(
+ "사운드 경로 확인 실패: {metadata_error}"
+ )));
+ }
+ Err(_) => {}
+ }
+
+ let parent = path
+ .parent()
+ .ok_or_else(|| CommandError::msg("사운드 파일의 부모 경로가 없습니다."))?;
+ let file_name = path
+ .file_name()
+ .ok_or_else(|| CommandError::msg("사운드 파일명이 없습니다."))?;
+ let canonical_parent = fs::canonicalize(parent).map_err(|parent_error| {
+ CommandError::msg(format!("사운드 파일의 부모 경로 확인 실패: {parent_error}"))
+ })?;
+ Ok(canonical_parent.join(file_name))
+ }
+ Err(error) => Err(CommandError::msg(format!("사운드 경로 확인 실패: {error}"))),
+ }
+}
+
fn validate_sound_path(sounds_dir: &Path, sound_path: &str) -> CmdResult {
let path = PathBuf::from(sound_path);
if !path.is_absolute() {
return Err(CommandError::msg("절대 경로만 허용됩니다."));
}
- if !path.starts_with(sounds_dir) {
+ if contains_relative_path_component(sound_path) || contains_duplicate_path_separator(sound_path)
+ {
+ return Err(CommandError::msg(
+ "'.', '..' 또는 중복 경로 구분자는 허용되지 않습니다.",
+ ));
+ }
+
+ let canonical_sounds_dir = fs::canonicalize(sounds_dir)
+ .map_err(|error| CommandError::msg(format!("사운드 디렉토리 확인 실패: {error}")))?;
+ let canonical_path = canonicalize_sound_path(&path)?;
+
+ if !canonical_path.starts_with(&canonical_sounds_dir) {
return Err(CommandError::msg(
"appData/sounds 외부 경로에는 접근할 수 없습니다.",
));
}
+ // canonical은 경계 검사 전용 — 반환은 store 키와 일치하는 원 경로
+ // (Windows에서 canonicalize가 \\?\ verbatim 경로를 반환해 조회 키를 오염시키는 것 방지)
Ok(path)
}
+fn contains_relative_path_component(path: &str) -> bool {
+ path.split(std::path::is_separator)
+ .any(|component| component == "." || component == "..")
+}
+
+fn contains_duplicate_path_separator(path: &str) -> bool {
+ #[cfg(windows)]
+ let prefix_body = path
+ .strip_prefix("\\\\?\\")
+ .or_else(|| path.strip_prefix("\\\\"))
+ .or_else(|| path.strip_prefix("//"));
+ #[cfg(windows)]
+ let path = match prefix_body {
+ Some(body) if body.chars().next().is_some_and(std::path::is_separator) => return true,
+ Some(body) => body,
+ None => path,
+ };
+
+ let mut previous_was_separator = false;
+ for character in path.chars() {
+ let is_separator = std::path::is_separator(character);
+ if is_separator && previous_was_separator {
+ return true;
+ }
+ previous_was_separator = is_separator;
+ }
+ false
+}
+
fn normalize_path_string(path: &Path) -> String {
path.to_string_lossy().to_string()
}
@@ -726,3 +1196,703 @@ fn is_supported_sound_file(path: &Path) -> bool {
.iter()
.any(|allowed| ext.eq_ignore_ascii_case(allowed))
}
+
+#[cfg(test)]
+mod tests {
+ use super::{
+ backup_path_for, commit_staged_sound_deletion, contains_duplicate_path_separator,
+ emit_sound_reference_changes_with, ensure_existing_sound_edit_target,
+ remove_sound_entry_and_references, replace_processed_wav_with,
+ resolve_sound_path_key_from_keys, restore_interrupted_processed_wav_backup_with,
+ stale_sound_library_keys, validate_sound_path, PreparedAtomicReplace,
+ SoundReferenceChangeEvent,
+ };
+ use crate::{
+ defaults::default_positions,
+ errors::{CmdResult, CommandError},
+ models::AppStoreData,
+ state::{
+ atomic_file::prepare_atomic_replace,
+ store::{
+ move_staged_sound_deletions_to_trash, stage_sound_files_for_deletion,
+ PROCESSED_WAV_TRANSACTION_LOCK,
+ },
+ },
+ };
+ use std::{
+ cell::{Cell, RefCell},
+ path::Path,
+ sync::mpsc,
+ thread,
+ };
+
+ fn wav_test_path(label: &str) -> (std::path::PathBuf, std::path::PathBuf) {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-processed-wav-{label}-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let path = root.join("sound.wav");
+ std::fs::write(&path, b"old-wav").unwrap();
+ (root, path)
+ }
+
+ fn assert_wav_rollback(path: &Path, metadata: &RefCell<&'static str>) {
+ assert_eq!(std::fs::read(path).unwrap(), b"old-wav");
+ assert_eq!(*metadata.borrow(), "old-metadata");
+ assert!(!backup_path_for(path).unwrap().exists());
+ assert!(!std::fs::read_dir(path.parent().unwrap())
+ .unwrap()
+ .any(|entry| {
+ entry
+ .ok()
+ .and_then(|entry| entry.file_name().into_string().ok())
+ .is_some_and(|name| name.ends_with(".tmp") || name.contains(".rollback-"))
+ }));
+ }
+
+ fn sound_delete_data(path_key: &str) -> AppStoreData {
+ let mut data = AppStoreData {
+ key_positions: default_positions().clone(),
+ ..Default::default()
+ };
+ data.sound_library
+ .insert(path_key.to_string(), Default::default());
+ let position = data
+ .key_positions
+ .get_mut("4key")
+ .unwrap()
+ .first_mut()
+ .unwrap();
+ position.sound_path = Some(path_key.to_string());
+ position.sound_enabled = Some(true);
+ data
+ }
+
+ #[test]
+ fn incomplete_sound_scan_never_prunes_library_metadata() {
+ let library = std::collections::HashMap::from([
+ ("/sounds/seen.wav".to_string(), Default::default()),
+ ("/sounds/unreadable.wav".to_string(), Default::default()),
+ ]);
+ let seen = std::collections::HashSet::from(["/sounds/seen.wav".to_string()]);
+
+ assert!(stale_sound_library_keys(&library, &seen, false).is_empty());
+ assert_eq!(
+ stale_sound_library_keys(&library, &seen, true),
+ vec!["/sounds/unreadable.wav".to_string()]
+ );
+ }
+
+ #[test]
+ fn sound_path_validation_resolves_existing_and_missing_paths() {
+ let root =
+ std::env::temp_dir().join(format!("dmnote-sound-path-test-{}", uuid::Uuid::new_v4()));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let existing = sounds_dir.join("existing.wav");
+ std::fs::write(&existing, b"sound").unwrap();
+
+ // macOS temp_dir는 /var → /private/var 심링크 — 경계 검사는 canonical로 통과하되
+ // 반환은 원 경로여야 함 (store 키 일관성)
+ assert_eq!(
+ validate_sound_path(&sounds_dir, &existing.to_string_lossy()).unwrap(),
+ existing
+ );
+
+ #[cfg(windows)]
+ {
+ let verbatim_existing = format!("\\\\?\\{}", existing.display());
+ assert_eq!(
+ validate_sound_path(&sounds_dir, &verbatim_existing).unwrap(),
+ std::path::PathBuf::from(verbatim_existing)
+ );
+ }
+
+ let missing = sounds_dir.join("missing.wav");
+ assert_eq!(
+ validate_sound_path(&sounds_dir, &missing.to_string_lossy()).unwrap(),
+ missing
+ );
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_path_validation_rejects_parent_directory_escape() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-escape-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let outside = root.join("outside.wav");
+ std::fs::write(&outside, b"outside").unwrap();
+
+ let escaped_existing = sounds_dir.join("..").join("outside.wav");
+ assert!(validate_sound_path(&sounds_dir, &escaped_existing.to_string_lossy()).is_err());
+
+ let escaped_missing = sounds_dir.join("..").join("missing.wav");
+ assert!(validate_sound_path(&sounds_dir, &escaped_missing.to_string_lossy()).is_err());
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_path_validation_rejects_relative_alias_components() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-alias-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(sounds_dir.join("nested")).unwrap();
+ let existing = sounds_dir.join("existing.wav");
+ std::fs::write(&existing, b"sound").unwrap();
+
+ let current_dir_alias = format!("{}/./existing.wav", sounds_dir.display());
+ let parent_dir_alias = format!("{}/nested/../existing.wav", sounds_dir.display());
+
+ for alias in [current_dir_alias, parent_dir_alias] {
+ let error = validate_sound_path(&sounds_dir, &alias)
+ .unwrap_err()
+ .to_string();
+ assert_eq!(
+ error,
+ "'.', '..' 또는 중복 경로 구분자는 허용되지 않습니다."
+ );
+ }
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_path_validation_rejects_duplicate_separators() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-duplicate-separator-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let existing = sounds_dir.join("existing.wav");
+ std::fs::write(&existing, b"sound").unwrap();
+
+ let separator = std::path::MAIN_SEPARATOR;
+ let duplicate_separator_alias =
+ format!("{}{separator}{separator}existing.wav", sounds_dir.display());
+ #[cfg(windows)]
+ let aliases = [duplicate_separator_alias];
+ #[cfg(not(windows))]
+ let aliases = [
+ duplicate_separator_alias,
+ format!("/{}", existing.display()),
+ ];
+
+ assert!(aliases
+ .iter()
+ .all(|alias| contains_duplicate_path_separator(alias)));
+
+ for alias in aliases {
+ let error = validate_sound_path(&sounds_dir, &alias)
+ .unwrap_err()
+ .to_string();
+ assert_eq!(
+ error,
+ "'.', '..' 또는 중복 경로 구분자는 허용되지 않습니다."
+ );
+ }
+
+ assert_eq!(
+ validate_sound_path(&sounds_dir, &existing.to_string_lossy()).unwrap(),
+ existing
+ );
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn sound_path_key_resolver_uses_canonical_match_for_reference_removal() {
+ use std::os::unix::fs::symlink;
+
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-canonical-match-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let stored_path = sounds_dir.join("stored.wav");
+ let alias_path = sounds_dir.join("alias.wav");
+ std::fs::write(&stored_path, b"sound").unwrap();
+ symlink(&stored_path, &alias_path).unwrap();
+
+ let stored_key = stored_path.to_string_lossy().to_string();
+ let validated_alias =
+ validate_sound_path(&sounds_dir, &alias_path.to_string_lossy()).unwrap();
+ let resolved_key =
+ resolve_sound_path_key_from_keys(&validated_alias, std::slice::from_ref(&stored_key));
+ let mut data = sound_delete_data(&stored_key);
+
+ assert_eq!(resolved_key, stored_key);
+ assert!(remove_sound_entry_and_references(&mut data, &resolved_key));
+ assert!(!data.sound_library.contains_key(&stored_key));
+ assert_eq!(data.key_positions["4key"][0].sound_path, None);
+ assert_eq!(data.key_positions["4key"][0].sound_enabled, Some(false));
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn sound_path_key_resolver_matches_missing_file_via_canonical_parent() {
+ use std::os::unix::fs::symlink;
+
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-missing-canonical-match-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ let stored_parent = sounds_dir.join("stored-parent");
+ let alias_parent = sounds_dir.join("alias-parent");
+ std::fs::create_dir_all(&stored_parent).unwrap();
+ symlink(&stored_parent, &alias_parent).unwrap();
+ let stored_path = stored_parent.join("missing.wav");
+ let alias_path = alias_parent.join("missing.wav");
+
+ let stored_key = stored_path.to_string_lossy().to_string();
+ let validated_alias =
+ validate_sound_path(&sounds_dir, &alias_path.to_string_lossy()).unwrap();
+ let resolved_key =
+ resolve_sound_path_key_from_keys(&validated_alias, std::slice::from_ref(&stored_key));
+
+ assert_eq!(resolved_key, stored_key);
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_path_key_resolver_preserves_unmatched_input_behavior() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-no-canonical-match-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let stored_path = sounds_dir.join("stored.wav");
+ let unmatched_path = sounds_dir.join("unmatched.wav");
+ std::fs::write(&stored_path, b"stored").unwrap();
+ std::fs::write(&unmatched_path, b"unmatched").unwrap();
+
+ let stored_key = stored_path.to_string_lossy().to_string();
+ let unmatched_key = unmatched_path.to_string_lossy().to_string();
+ let validated_unmatched =
+ validate_sound_path(&sounds_dir, &unmatched_path.to_string_lossy()).unwrap();
+ let resolved_key = resolve_sound_path_key_from_keys(
+ &validated_unmatched,
+ std::slice::from_ref(&stored_key),
+ );
+ let mut data = sound_delete_data(&stored_key);
+
+ assert_eq!(resolved_key, unmatched_key);
+ assert!(!remove_sound_entry_and_references(&mut data, &resolved_key));
+ assert!(data.sound_library.contains_key(&stored_key));
+ assert_eq!(
+ data.key_positions["4key"][0].sound_path.as_deref(),
+ Some(stored_key.as_str())
+ );
+ assert_eq!(data.key_positions["4key"][0].sound_enabled, Some(true));
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[cfg(windows)]
+ #[test]
+ fn sound_path_key_resolver_matches_case_and_separator_aliases() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-path-windows-alias-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = root.join("sounds");
+ std::fs::create_dir_all(&sounds_dir).unwrap();
+ let stored_path = sounds_dir.join("stored.wav");
+ std::fs::write(&stored_path, b"sound").unwrap();
+
+ let stored_key = stored_path.to_string_lossy().to_string();
+ let alias = stored_key.replace('\\', "/").to_ascii_uppercase();
+ let validated_alias = validate_sound_path(&sounds_dir, &alias).unwrap();
+ let resolved_key =
+ resolve_sound_path_key_from_keys(&validated_alias, std::slice::from_ref(&stored_key));
+
+ assert_eq!(resolved_key, stored_key);
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[cfg(windows)]
+ #[test]
+ fn duplicate_separator_check_preserves_windows_prefixes() {
+ assert!(!contains_duplicate_path_separator(r"\\server\share\x.wav"));
+ assert!(!contains_duplicate_path_separator(r"\\?\C:\sounds\x.wav"));
+ assert!(contains_duplicate_path_separator(r"C:\sounds\\x.wav"));
+ assert!(contains_duplicate_path_separator(r"C:\sounds/\x.wav"));
+ assert!(contains_duplicate_path_separator(r"\\server\share\\x.wav"));
+ assert!(contains_duplicate_path_separator(r"\\?\C:\sounds\\x.wav"));
+ assert!(contains_duplicate_path_separator(r"\\\server\share\x.wav"));
+ assert!(contains_duplicate_path_separator(r"///server/share/x.wav"));
+ }
+
+ #[test]
+ fn sound_delete_store_failure_keeps_files_and_references() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-delete-store-failure-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let processed_path = root.join("sound.wav");
+ let original_path = root.join("original.wav");
+ std::fs::write(&processed_path, b"processed").unwrap();
+ std::fs::write(&original_path, b"original").unwrap();
+ let path_key = processed_path.to_string_lossy().to_string();
+ let data = RefCell::new(sound_delete_data(&path_key));
+ let cache_invalidated = Cell::new(false);
+
+ let staged =
+ stage_sound_files_for_deletion(&[processed_path.clone(), original_path.clone()])
+ .unwrap();
+ let result: CmdResult<()> = commit_staged_sound_deletion(&staged, || {
+ let mut scratch = data.borrow().clone();
+ remove_sound_entry_and_references(&mut scratch, &path_key);
+ Err(CommandError::msg("injected store failure"))
+ });
+
+ assert!(result.is_err());
+ assert!(processed_path.exists());
+ assert!(original_path.exists());
+ assert!(!cache_invalidated.get());
+ assert!(data.borrow().sound_library.contains_key(&path_key));
+ let position = &data.borrow().key_positions["4key"][0];
+ assert_eq!(position.sound_path.as_deref(), Some(path_key.as_str()));
+ assert_eq!(position.sound_enabled, Some(true));
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_delete_stages_files_before_store_and_moves_them_to_trash_after_commit() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-sound-delete-success-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let processed_path = root.join("sound.wav");
+ let original_path = root.join("original.wav");
+ std::fs::write(&processed_path, b"processed").unwrap();
+ std::fs::write(&original_path, b"original").unwrap();
+ let path_key = processed_path.to_string_lossy().to_string();
+ let data = RefCell::new(sound_delete_data(&path_key));
+ let events = RefCell::new(Vec::new());
+ let trash_dir = root.join("trash");
+ let staged =
+ stage_sound_files_for_deletion(&[processed_path.clone(), original_path.clone()])
+ .unwrap();
+ assert!(!processed_path.exists());
+ assert!(!original_path.exists());
+
+ commit_staged_sound_deletion(&staged, || {
+ let mut scratch = data.borrow().clone();
+ remove_sound_entry_and_references(&mut scratch, &path_key);
+ *data.borrow_mut() = scratch;
+ events.borrow_mut().push("store");
+ Ok(())
+ })
+ .unwrap();
+ events.borrow_mut().push("cache");
+ move_staged_sound_deletions_to_trash(&staged, &trash_dir).unwrap();
+ events.borrow_mut().push("trash");
+
+ assert_eq!(*events.borrow(), ["store", "cache", "trash"]);
+ assert!(!processed_path.exists());
+ assert!(!original_path.exists());
+ let quarantined: Vec<_> = std::fs::read_dir(&trash_dir)
+ .unwrap()
+ .flat_map(|session| std::fs::read_dir(session.unwrap().path()).unwrap())
+ .flat_map(|category| std::fs::read_dir(category.unwrap().path()).unwrap())
+ .map(|entry| entry.unwrap().file_name())
+ .collect();
+ assert!(quarantined.contains(&"sound.wav".into()));
+ assert!(quarantined.contains(&"original.wav".into()));
+ let position = &data.borrow().key_positions["4key"][0];
+ assert_eq!(position.sound_path, None);
+ assert_eq!(position.sound_enabled, Some(false));
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn sound_delete_event_failure_does_not_stop_remaining_notifications() {
+ let attempted = RefCell::new(Vec::new());
+
+ emit_sound_reference_changes_with(|event| {
+ attempted.borrow_mut().push(event.name());
+ if event == SoundReferenceChangeEvent::Key {
+ Err("injected emit failure")
+ } else {
+ Ok(())
+ }
+ });
+
+ assert_eq!(
+ *attempted.borrow(),
+ [
+ "positions:changed",
+ "statPositions:changed",
+ "graphPositions:changed",
+ "knobPositions:changed",
+ ]
+ );
+ }
+
+ #[test]
+ fn processed_wav_temp_failure_keeps_file_and_metadata() {
+ let (root, path) = wav_test_path("temp-failure");
+ let metadata = RefCell::new("old-metadata");
+
+ let result = replace_processed_wav_with(
+ &path,
+ b"new-wav",
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |_, _| Err(anyhow::anyhow!("injected temp failure")),
+ PreparedAtomicReplace::commit,
+ |path| std::fs::remove_file(path),
+ );
+
+ assert!(result.is_err());
+ assert_wav_rollback(&path, &metadata);
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn deleted_sound_cannot_be_recreated_by_a_waiting_edit() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-processed-wav-deleted-before-edit-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let path = root.join("deleted.wav");
+ std::fs::write(&path, b"old-wav").unwrap();
+ let delete_guard = PROCESSED_WAV_TRANSACTION_LOCK.lock();
+ let edit_path = path.clone();
+ let (waiting_tx, waiting_rx) = mpsc::channel();
+ let edit = thread::spawn(move || {
+ waiting_tx.send(()).unwrap();
+ let _edit_guard = PROCESSED_WAV_TRANSACTION_LOCK.lock();
+ ensure_existing_sound_edit_target(&edit_path)
+ });
+ waiting_rx.recv().unwrap();
+
+ std::fs::remove_file(&path).unwrap();
+ drop(delete_guard);
+
+ let error = edit.join().unwrap().unwrap_err().to_string();
+
+ assert!(error.contains("찾을 수 없습니다"));
+ assert!(!path.exists());
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_rename_failure_keeps_file_and_metadata() {
+ let (root, path) = wav_test_path("rename-failure");
+ let metadata = RefCell::new("old-metadata");
+
+ let result = replace_processed_wav_with(
+ &path,
+ b"new-wav",
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |path, bytes| prepare_atomic_replace(path, bytes, "rename-failure"),
+ |_| Err(anyhow::anyhow!("injected rename failure")),
+ |path| std::fs::remove_file(path),
+ );
+
+ assert!(result.is_err());
+ assert_wav_rollback(&path, &metadata);
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_store_failure_restores_file_and_metadata() {
+ let (root, path) = wav_test_path("store-failure");
+ let metadata = RefCell::new("old-metadata");
+
+ let result = replace_processed_wav_with(
+ &path,
+ b"new-wav",
+ || -> CmdResult<()> { Err(CommandError::msg("injected store failure")) },
+ |path, bytes| prepare_atomic_replace(path, bytes, "store-failure"),
+ PreparedAtomicReplace::commit,
+ |path| std::fs::remove_file(path),
+ );
+
+ assert!(result.is_err());
+ assert_wav_rollback(&path, &metadata);
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_success_commits_and_removes_backup() {
+ let (root, path) = wav_test_path("success");
+ let metadata = RefCell::new("old-metadata");
+
+ replace_processed_wav_with(
+ &path,
+ b"new-wav",
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |path, bytes| prepare_atomic_replace(path, bytes, "success"),
+ PreparedAtomicReplace::commit,
+ |path| std::fs::remove_file(path),
+ )
+ .unwrap();
+
+ assert_eq!(std::fs::read(&path).unwrap(), b"new-wav");
+ assert_eq!(*metadata.borrow(), "new-metadata");
+ assert!(!backup_path_for(&path).unwrap().exists());
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_backup_cleanup_failure_keeps_committed_file_and_metadata() {
+ let (root, path) = wav_test_path("cleanup-failure");
+ let metadata = RefCell::new("old-metadata");
+
+ replace_processed_wav_with(
+ &path,
+ b"new-wav",
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |path, bytes| prepare_atomic_replace(path, bytes, "cleanup-failure"),
+ PreparedAtomicReplace::commit,
+ |_| {
+ Err(std::io::Error::new(
+ std::io::ErrorKind::PermissionDenied,
+ "injected cleanup failure",
+ ))
+ },
+ )
+ .unwrap();
+
+ assert_eq!(std::fs::read(&path).unwrap(), b"new-wav");
+ assert_eq!(*metadata.borrow(), "new-metadata");
+ assert_eq!(
+ std::fs::read(backup_path_for(&path).unwrap()).unwrap(),
+ b"old-wav"
+ );
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_replacement_recovers_backup_before_retrying() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-processed-wav-crash-retry-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let path = root.join("sound.wav");
+ let backup_path = backup_path_for(&path).unwrap();
+ let crashed_temp_path = root.join(format!(
+ ".sound.wav.processed-wav-{}.tmp",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::write(&backup_path, b"old-wav").unwrap();
+ std::fs::write(&crashed_temp_path, b"crashed-new-wav").unwrap();
+ let metadata = RefCell::new("old-metadata");
+
+ replace_processed_wav_with(
+ &path,
+ b"retried-new-wav",
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |target_path, bytes| {
+ assert_eq!(std::fs::read(target_path).unwrap(), b"old-wav");
+ prepare_atomic_replace(target_path, bytes, "crash-retry")
+ },
+ PreparedAtomicReplace::commit,
+ |path| std::fs::remove_file(path),
+ )
+ .unwrap();
+
+ assert_eq!(std::fs::read(&path).unwrap(), b"retried-new-wav");
+ assert_eq!(*metadata.borrow(), "new-metadata");
+ assert!(!backup_path.exists());
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ #[test]
+ fn processed_wav_backup_recovery_error_includes_operation_and_paths() {
+ let root = std::env::temp_dir().join(format!(
+ "dmnote-processed-wav-recovery-error-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&root).unwrap();
+ let target_path = root.join("sound.wav");
+ let backup_path = backup_path_for(&target_path).unwrap();
+ std::fs::write(&backup_path, b"old-wav").unwrap();
+
+ let error =
+ restore_interrupted_processed_wav_backup_with(&target_path, &backup_path, |_, _| {
+ Err(std::io::Error::other("injected recovery failure"))
+ })
+ .unwrap_err()
+ .to_string();
+
+ assert!(error.contains("중단된 WAV 백업 복구 실패"));
+ assert!(error.contains(&backup_path.display().to_string()));
+ assert!(error.contains(&target_path.display().to_string()));
+ assert!(error.contains("injected recovery failure"));
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+
+ // 단독 실행: cargo test --lib commands::keys::sound::tests::processed_wav_atomic_write_survives_file_size_limit -- --ignored --exact
+ #[cfg(unix)]
+ #[test]
+ #[ignore = "RLIMIT_FSIZE는 프로세스 전역이므로 단독 실행"]
+ fn processed_wav_atomic_write_survives_file_size_limit() {
+ use crate::state::atomic_file::test_support::FileSizeLimit;
+
+ let (root, path) = wav_test_path("rlimit");
+ let metadata = RefCell::new("old-metadata");
+
+ {
+ let _limit = FileSizeLimit::set(1_024);
+ let oversized = vec![b'w'; 4_096];
+ let result = replace_processed_wav_with(
+ &path,
+ &oversized,
+ || {
+ *metadata.borrow_mut() = "new-metadata";
+ Ok(())
+ },
+ |path, bytes| prepare_atomic_replace(path, bytes, "rlimit"),
+ PreparedAtomicReplace::commit,
+ |path| std::fs::remove_file(path),
+ );
+ assert!(result.is_err());
+ assert_wav_rollback(&path, &metadata);
+ }
+
+ let _ = std::fs::remove_dir_all(root);
+ }
+}
diff --git a/src-tauri/src/commands/preset/load.rs b/src-tauri/src/commands/preset/load.rs
index 47e58493..c781b37b 100644
--- a/src-tauri/src/commands/preset/load.rs
+++ b/src-tauri/src/commands/preset/load.rs
@@ -1,4 +1,8 @@
-use std::{collections::HashMap, fs, path::Path};
+use std::{
+ collections::{BTreeSet, HashMap, HashSet},
+ fs,
+ path::Path,
+};
use base64::{engine::general_purpose::STANDARD as BASE64_STANDARD, Engine as _};
use rfd::FileDialog;
@@ -6,12 +10,15 @@ use tauri::{AppHandle, Emitter, Manager, State};
use uuid::Uuid;
use crate::{
+ commands::editor::css::TabCssResponse,
defaults::{default_keys, default_positions},
errors::{CmdResult, CommandError},
models::{
- CustomCssPatch, CustomJsPatch, FontType, GraphPositions, KeyMappings, KeyPositions,
- KnobPositions, NoteSettingsPatch, SettingsPatchInput, StatPositions,
+ CustomCssPatch, CustomJsPatch, FontSettings, FontType, GraphPositions, KeyMappings,
+ KeyPositions, KnobPositions, NoteSettingsPatch, SettingsPatchInput, StatPositions,
+ TabCssOverrides,
},
+ services::settings::apply_patch_to_store,
state::AppState,
};
@@ -50,8 +57,11 @@ pub fn preset_load(state: State<'_, AppState>, app: AppHandle) -> CmdResult, app: AppHandle) -> CmdResult, app: AppHandle) -> CmdResult CmdResult<()> {
+ let tab_ids: BTreeSet = previous.keys().chain(current.keys()).cloned().collect();
+
+ for tab_id in tab_ids {
+ if previous.get(&tab_id) == current.get(&tab_id) {
+ continue;
+ }
+
+ state.unwatch_tab_css(&tab_id);
+ let css = current.get(&tab_id).cloned();
+ if let Some(tab_css) = css.as_ref() {
+ if tab_css.enabled {
+ if let Some(path) = tab_css.path.as_deref() {
+ if let Err(error) = state.watch_tab_css(path, &tab_id) {
+ log::warn!("[Preset] 탭 CSS 감시 시작 실패 (tab={tab_id}): {error}");
+ }
+ }
+ }
+ }
+
+ app.emit(
+ "tabCss:changed",
+ &TabCssResponse {
+ tab_id: tab_id.clone(),
+ css,
+ },
+ )?;
+ }
+
+ Ok(())
+}
+
fn choose_tab_preset_source_tab(
keys: &KeyMappings,
selected_key_type: Option<&str>,
@@ -355,9 +504,69 @@ fn choose_tab_preset_source_tab(
Err(CommandError::msg("tab-preset-ambiguous-source"))
}
+fn merge_tab_preset_fonts(
+ existing_font_settings: &FontSettings,
+ mut imported_font_settings: FontSettings,
+ restore_fonts: impl FnOnce(&mut FontSettings) -> CmdResult<()>,
+) -> CmdResult> {
+ let mut existing_names: HashSet = existing_font_settings
+ .custom_fonts
+ .iter()
+ .map(|font| font.name.clone())
+ .collect();
+
+ // 같은 이름은 기존 정의 유지 — 수용한 이름도 반영해 프리셋 내부 중복 방어
+ imported_font_settings
+ .custom_fonts
+ .retain(|font| existing_names.insert(font.name.clone()));
+ if imported_font_settings.custom_fonts.is_empty() {
+ return Ok(None);
+ }
+
+ // 이름 필터 후 파일 복원 — 제외할 로컬 폰트의 고아 파일 생성 방지
+ restore_fonts(&mut imported_font_settings)?;
+
+ let mut existing_ids: HashSet = existing_font_settings
+ .custom_fonts
+ .iter()
+ .map(|font| font.id.clone())
+ .collect();
+ for font in imported_font_settings.custom_fonts.iter_mut() {
+ if existing_ids.contains(&font.id) {
+ font.id = Uuid::new_v4().to_string();
+ }
+ existing_ids.insert(font.id.clone());
+ }
+
+ let mut merged = existing_font_settings.clone();
+ merged
+ .custom_fonts
+ .extend(imported_font_settings.custom_fonts);
+ Ok(Some(merged))
+}
+
fn restore_preset_local_fonts(
app: &AppHandle,
- font_settings: &mut crate::models::FontSettings,
+ font_settings: &mut FontSettings,
+ embedded_local_fonts: Option<&[EmbeddedLocalFont]>,
+) -> CmdResult<()> {
+ let has_local_fonts = font_settings
+ .custom_fonts
+ .iter()
+ .any(|font| font.font_type == FontType::Local);
+ if !has_local_fonts {
+ return Ok(());
+ }
+
+ let app_data_dir = app.path().app_data_dir()?;
+ let fonts_dir = app_data_dir.join("fonts");
+
+ restore_preset_local_fonts_in_dir(&fonts_dir, font_settings, embedded_local_fonts)
+}
+
+fn restore_preset_local_fonts_in_dir(
+ fonts_dir: &Path,
+ font_settings: &mut FontSettings,
embedded_local_fonts: Option<&[EmbeddedLocalFont]>,
) -> CmdResult<()> {
let has_local_fonts = font_settings
@@ -374,9 +583,7 @@ fn restore_preset_local_fonts(
.map(|font| (font.font_id.as_str(), font))
.collect();
- let app_data_dir = app.path().app_data_dir()?;
- let fonts_dir = app_data_dir.join("fonts");
- fs::create_dir_all(&fonts_dir)?;
+ fs::create_dir_all(fonts_dir)?;
for font in font_settings.custom_fonts.iter_mut() {
if font.font_type != FontType::Local {
@@ -645,6 +852,7 @@ fn restore_preset_local_sounds(
key_positions: &mut KeyPositions,
stat_positions: &mut StatPositions,
graph_positions: &mut GraphPositions,
+ knob_positions: &mut KnobPositions,
embedded_local_sounds: Option<&[EmbeddedLocalSound]>,
) -> CmdResult<()> {
let has_any_sounds = key_positions.values().any(|positions| {
@@ -659,28 +867,51 @@ fn restore_preset_local_sounds(
positions
.iter()
.any(|graph_position| option_has_non_empty_text(&graph_position.position.sound_path))
+ }) || knob_positions.values().any(|positions| {
+ positions
+ .iter()
+ .any(|knob_position| option_has_non_empty_text(&knob_position.position.sound_path))
});
if !has_any_sounds {
return Ok(());
}
+ let app_data_dir = app.path().app_data_dir()?;
+ let sounds_dir = app_data_dir.join("sounds");
+
+ restore_preset_local_sounds_in_dir(
+ &sounds_dir,
+ key_positions,
+ stat_positions,
+ graph_positions,
+ knob_positions,
+ embedded_local_sounds,
+ )
+}
+
+fn restore_preset_local_sounds_in_dir(
+ sounds_dir: &Path,
+ key_positions: &mut KeyPositions,
+ stat_positions: &mut StatPositions,
+ graph_positions: &mut GraphPositions,
+ knob_positions: &mut KnobPositions,
+ embedded_local_sounds: Option<&[EmbeddedLocalSound]>,
+) -> CmdResult<()> {
+ fs::create_dir_all(sounds_dir)?;
+
let embedded_map: HashMap<&str, &EmbeddedLocalSound> = embedded_local_sounds
.unwrap_or(&[])
.iter()
.map(|sound| (sound.sound_id.as_str(), sound))
.collect();
- let app_data_dir = app.path().app_data_dir()?;
- let sounds_dir = app_data_dir.join("sounds");
- fs::create_dir_all(&sounds_dir)?;
-
let mut restored_path_cache: HashMap = HashMap::new();
for positions in key_positions.values_mut() {
for position in positions.iter_mut() {
restore_position_sound_reference(
- &sounds_dir,
+ sounds_dir,
&embedded_map,
&mut restored_path_cache,
&mut position.sound_path,
@@ -691,7 +922,7 @@ fn restore_preset_local_sounds(
for positions in stat_positions.values_mut() {
for stat_position in positions.iter_mut() {
restore_position_sound_reference(
- &sounds_dir,
+ sounds_dir,
&embedded_map,
&mut restored_path_cache,
&mut stat_position.position.sound_path,
@@ -702,7 +933,7 @@ fn restore_preset_local_sounds(
for positions in graph_positions.values_mut() {
for graph_position in positions.iter_mut() {
restore_position_sound_reference(
- &sounds_dir,
+ sounds_dir,
&embedded_map,
&mut restored_path_cache,
&mut graph_position.position.sound_path,
@@ -710,6 +941,17 @@ fn restore_preset_local_sounds(
}
}
+ for positions in knob_positions.values_mut() {
+ for knob_position in positions.iter_mut() {
+ restore_position_sound_reference(
+ sounds_dir,
+ &embedded_map,
+ &mut restored_path_cache,
+ &mut knob_position.position.sound_path,
+ )?;
+ }
+ }
+
Ok(())
}
@@ -810,3 +1052,146 @@ fn choose_selected_key_type(
}
"4key".to_string()
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{
+ defaults::default_positions,
+ models::{CustomFont, KnobPosition},
+ };
+
+ #[test]
+ fn tab_preset_duplicate_font_does_not_create_embedded_file() {
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-tab-preset-font-load-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let fonts_dir = temp_dir.join("fonts");
+ std::fs::create_dir_all(&fonts_dir).unwrap();
+ let existing_path = fonts_dir.join("existing.ttf");
+ std::fs::write(&existing_path, b"existing-font").unwrap();
+
+ let existing_fonts = FontSettings {
+ custom_fonts: vec![CustomFont {
+ id: "existing-id".to_string(),
+ font_type: FontType::Local,
+ name: "SharedFont".to_string(),
+ display_name: "Existing Font".to_string(),
+ enabled: true,
+ local_path: Some(existing_path.to_string_lossy().to_string()),
+ css_content: None,
+ }],
+ };
+ let imported_font_id = "imported-id".to_string();
+ let imported_fonts = FontSettings {
+ custom_fonts: vec![CustomFont {
+ id: imported_font_id.clone(),
+ font_type: FontType::Local,
+ name: "SharedFont".to_string(),
+ display_name: "Imported Font".to_string(),
+ enabled: true,
+ local_path: None,
+ css_content: None,
+ }],
+ };
+ let embedded_fonts = vec![EmbeddedLocalFont {
+ font_id: imported_font_id,
+ extension: Some("ttf".to_string()),
+ data_base64: BASE64_STANDARD.encode(b"imported-font"),
+ }];
+ let file_count_before = std::fs::read_dir(&fonts_dir).unwrap().count();
+
+ let merged = merge_tab_preset_fonts(&existing_fonts, imported_fonts, |filtered_fonts| {
+ restore_preset_local_fonts_in_dir(&fonts_dir, filtered_fonts, Some(&embedded_fonts))
+ })
+ .unwrap();
+
+ assert!(merged.is_none());
+ assert_eq!(
+ std::fs::read_dir(&fonts_dir).unwrap().count(),
+ file_count_before
+ );
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+
+ #[test]
+ fn legacy_percent_encoded_file_url_is_copied_on_import() {
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-preset-image-url-load-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let source_dir = temp_dir.join("source folder");
+ let images_dir = temp_dir.join("restored-images");
+ std::fs::create_dir_all(&source_dir).unwrap();
+ std::fs::create_dir_all(&images_dir).unwrap();
+ let source_path = source_dir.join("image with space.png");
+ std::fs::write(&source_path, b"legacy-image").unwrap();
+ let mut image_ref = Some(url::Url::from_file_path(&source_path).unwrap().to_string());
+
+ restore_position_image_reference(
+ &images_dir,
+ &HashMap::new(),
+ &mut HashMap::new(),
+ &mut image_ref,
+ )
+ .unwrap();
+
+ let restored_path = Path::new(image_ref.as_deref().unwrap());
+ assert!(restored_path.starts_with(&images_dir));
+ assert_eq!(std::fs::read(restored_path).unwrap(), b"legacy-image");
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+
+ #[test]
+ fn sound_restore_restores_knob_sound() {
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-preset-knob-load-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ let sounds_dir = temp_dir.join("sounds");
+ let sound_id = "knob-sound";
+ let embedded = vec![EmbeddedLocalSound {
+ sound_id: sound_id.to_string(),
+ extension: Some("wav".to_string()),
+ data_base64: BASE64_STANDARD.encode(b"restored-knob-sound"),
+ }];
+
+ let mut position = default_positions()["4key"][0].clone();
+ position.sound_path = Some(format!("{PRESET_LOCAL_SOUND_PREFIX}{sound_id}"));
+ let mut knob_positions = KnobPositions::new();
+ knob_positions.insert(
+ "4key".to_string(),
+ vec![KnobPosition {
+ axis_id: "axis".to_string(),
+ sensitivity: 1.0,
+ reverse: false,
+ position,
+ }],
+ );
+
+ restore_preset_local_sounds_in_dir(
+ &sounds_dir,
+ &mut KeyPositions::new(),
+ &mut StatPositions::new(),
+ &mut GraphPositions::new(),
+ &mut knob_positions,
+ Some(&embedded),
+ )
+ .unwrap();
+
+ let restored_path = Path::new(
+ knob_positions["4key"][0]
+ .position
+ .sound_path
+ .as_deref()
+ .unwrap(),
+ );
+ assert!(restored_path.starts_with(&sounds_dir));
+ assert_eq!(
+ std::fs::read(restored_path).unwrap(),
+ b"restored-knob-sound"
+ );
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+}
diff --git a/src-tauri/src/commands/preset/mod.rs b/src-tauri/src/commands/preset/mod.rs
index e5bed0a4..c189a66e 100644
--- a/src-tauri/src/commands/preset/mod.rs
+++ b/src-tauri/src/commands/preset/mod.rs
@@ -8,8 +8,9 @@ use serde::{Deserialize, Serialize};
use crate::models::{
CustomCss, CustomJs, CustomTab, FontSettings, GraphPositions, KeyMappings, KeyPositions,
- KnobPositions, NoteSettings, StatPositions, TabNoteOverrides,
+ KnobPositions, LayerGroups, NoteSettings, StatPositions, TabCssOverrides, TabNoteOverrides,
};
+use crate::state::local_asset_path::{file_url_to_path, FileUrlPath};
#[derive(Serialize)]
pub struct PresetOperationResult {
@@ -58,6 +59,10 @@ pub(crate) struct PresetFile {
pub font_settings: Option,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tab_note_overrides: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub layer_groups: Option,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub tab_css_overrides: Option,
pub embedded_local_fonts: Option>,
pub embedded_local_images: Option>,
pub embedded_local_sounds: Option>,
@@ -181,18 +186,10 @@ pub(crate) fn local_source_path_from_image_ref(value: &str) -> Option {
return None;
}
- if let Some(stripped) = trimmed
- .strip_prefix("file:///")
- .or_else(|| trimmed.strip_prefix("file://"))
- {
- let mut candidate = stripped.to_string();
- if cfg!(target_os = "windows") {
- if candidate.starts_with('/') && candidate.as_bytes().get(2) == Some(&b':') {
- candidate = candidate[1..].to_string();
- }
- candidate = candidate.replace('/', "\\");
- }
- return Some(PathBuf::from(candidate));
+ match file_url_to_path(trimmed) {
+ FileUrlPath::Path(path) => return Some(path),
+ FileUrlPath::Invalid => return legacy_file_url_path(trimmed),
+ FileUrlPath::NotFileUrl => {}
}
let path = PathBuf::from(trimmed);
@@ -203,6 +200,27 @@ pub(crate) fn local_source_path_from_image_ref(value: &str) -> Option {
}
}
+fn legacy_file_url_path(value: &str) -> Option {
+ let scheme_end = value.find(':')?;
+ if !value[..scheme_end].eq_ignore_ascii_case("file") {
+ return None;
+ }
+ let remainder = &value[scheme_end + 1..];
+ let stripped = remainder
+ .strip_prefix("///")
+ .or_else(|| remainder.strip_prefix("//"))?;
+ let mut candidate = stripped.to_string();
+ if cfg!(target_os = "windows") {
+ if candidate.starts_with('/') && candidate.as_bytes().get(2) == Some(&b':') {
+ candidate = candidate[1..].to_string();
+ }
+ candidate = candidate.replace('/', "\\");
+ } else if remainder.starts_with("///") {
+ candidate.insert(0, '/');
+ }
+ Some(PathBuf::from(candidate))
+}
+
pub(crate) fn is_remote_or_virtual_image_ref(value: &str) -> bool {
let lower = value.trim().to_ascii_lowercase();
lower.starts_with("http://")
@@ -218,3 +236,110 @@ pub(crate) fn option_has_non_empty_text(value: &Option) -> bool {
.map(|text| !text.trim().is_empty())
.unwrap_or(false)
}
+
+#[cfg(test)]
+mod tests {
+ use super::{local_source_path_from_image_ref, PresetFile};
+ use crate::models::NoteColor;
+ use serde_json::json;
+
+ #[test]
+ fn preset_round_trip_preserves_layer_groups_and_tab_css_overrides() {
+ let value = json!({
+ "layerGroups": { "4key": [] },
+ "tabCssOverrides": {
+ "4key": {
+ "path": "/tmp/tab.css",
+ "content": ".key { color: red; }",
+ "enabled": true
+ }
+ }
+ });
+ let preset: PresetFile = serde_json::from_value(value.clone()).unwrap();
+ let serialized = serde_json::to_value(preset).unwrap();
+
+ assert_eq!(serialized["layerGroups"], value["layerGroups"]);
+ assert_eq!(serialized["tabCssOverrides"], value["tabCssOverrides"]);
+ }
+
+ #[test]
+ fn legacy_preset_defaults_new_fields_to_none() {
+ let preset: PresetFile = serde_json::from_value(json!({})).unwrap();
+
+ assert!(preset.layer_groups.is_none());
+ assert!(preset.tab_css_overrides.is_none());
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn file_url_image_source_preserves_its_absolute_path() {
+ assert_eq!(
+ local_source_path_from_image_ref("file:///tmp/dmnote-image.png"),
+ Some(std::path::PathBuf::from("/tmp/dmnote-image.png"))
+ );
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn file_url_image_source_decodes_percent_sequences_only() {
+ assert_eq!(
+ local_source_path_from_image_ref(
+ "file:///tmp/Application%20Support/%ED%95%9C%EA%B8%80%25+a.png"
+ ),
+ Some(std::path::PathBuf::from(
+ "/tmp/Application Support/한글%+a.png"
+ ))
+ );
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn invalid_file_url_uses_legacy_literal_path_for_preset_compatibility() {
+ assert_eq!(
+ local_source_path_from_image_ref("file://[invalid/path.png"),
+ Some(std::path::PathBuf::from("[invalid/path.png"))
+ );
+ assert_eq!(
+ local_source_path_from_image_ref("file:///tmp/broken%ZZ.png"),
+ Some(std::path::PathBuf::from("/tmp/broken%ZZ.png"))
+ );
+ }
+
+ #[test]
+ fn preset_1_0_fixture_preserves_values_and_fills_visual_defaults() {
+ // 1.0.0이 실제 저장하던 프리셋 형식 — height/noteColor/noteOpacity 없음
+ let fixture = r#"{
+ "keys": {
+ "4key": ["Q"],
+ "5key": [],
+ "6key": [],
+ "8key": []
+ },
+ "keyPositions": {
+ "4key": [
+ {
+ "dx": 777,
+ "dy": 130,
+ "width": 60,
+ "activeImage": "",
+ "inactiveImage": "",
+ "count": 42
+ }
+ ],
+ "5key": [],
+ "6key": [],
+ "8key": []
+ },
+ "backgroundColor": "transparent"
+ }"#;
+ let preset: PresetFile = serde_json::from_str(fixture).unwrap();
+ let positions = preset.key_positions.unwrap();
+ let position = &positions["4key"][0];
+
+ assert_eq!(position.dx, 777.0);
+ assert_eq!(position.count, 42);
+ assert_eq!(position.height, 60.0);
+ assert_eq!(position.note_color, NoteColor::Solid("#FFFFFF".to_string()));
+ assert_eq!(position.note_opacity, 80);
+ }
+}
diff --git a/src-tauri/src/commands/preset/save.rs b/src-tauri/src/commands/preset/save.rs
index 2b1badf8..6e274be8 100644
--- a/src-tauri/src/commands/preset/save.rs
+++ b/src-tauri/src/commands/preset/save.rs
@@ -1,7 +1,7 @@
use std::{
collections::{HashMap, HashSet},
fs,
- path::PathBuf,
+ path::{Path, PathBuf},
};
use base64::{engine::general_purpose::STANDARD as BASE64_STANDARD, Engine as _};
@@ -12,9 +12,9 @@ use crate::{
errors::CmdResult,
models::{
FontSettings, FontType, GraphPositions, KeyMappings, KeyPositions, KnobPositions,
- StatPositions, TabNoteOverrides,
+ LayerGroups, StatPositions, TabCssOverrides, TabNoteOverrides,
},
- state::AppState,
+ state::{atomic_file::atomic_replace, AppState},
};
use super::{
@@ -43,6 +43,7 @@ pub fn preset_save(state: State<'_, AppState>) -> CmdResult) -> CmdResult) -> CmdResult) -> CmdResult) -> CmdResult) -> CmdResult) -> CmdResult) -> CmdResult CmdResult<()> {
+ atomic_replace(path, json.as_bytes(), "preset")?;
+ Ok(())
+}
+
fn collect_used_font_families(
key_positions: &KeyPositions,
stat_positions: &StatPositions,
graph_positions: &GraphPositions,
+ knob_positions: &KnobPositions,
) -> HashSet {
let mut used = HashSet::new();
@@ -253,6 +292,16 @@ fn collect_used_font_families(
}
}
+ for positions in knob_positions.values() {
+ for knob_position in positions {
+ maybe_insert_font_family(knob_position.position.font_family.as_ref(), &mut used);
+ maybe_insert_font_family(
+ knob_position.position.counter.font_family.as_ref(),
+ &mut used,
+ );
+ }
+ }
+
used
}
@@ -493,15 +542,18 @@ fn build_preset_sound_payload(
key_positions: &KeyPositions,
stat_positions: &StatPositions,
graph_positions: &GraphPositions,
+ knob_positions: &KnobPositions,
) -> CmdResult<(
KeyPositions,
StatPositions,
GraphPositions,
+ KnobPositions,
Vec,
)> {
let mut exported_key_positions = key_positions.clone();
let mut exported_stat_positions = stat_positions.clone();
let mut exported_graph_positions = graph_positions.clone();
+ let mut exported_knob_positions = knob_positions.clone();
let mut embedded_local_sounds = Vec::new();
let mut path_to_sound_id: HashMap = HashMap::new();
@@ -535,10 +587,21 @@ fn build_preset_sound_payload(
}
}
+ for positions in exported_knob_positions.values_mut() {
+ for knob_position in positions.iter_mut() {
+ rewrite_position_sound_reference(
+ &mut knob_position.position.sound_path,
+ &mut embedded_local_sounds,
+ &mut path_to_sound_id,
+ )?;
+ }
+ }
+
Ok((
exported_key_positions,
exported_stat_positions,
exported_graph_positions,
+ exported_knob_positions,
embedded_local_sounds,
))
}
@@ -589,3 +652,123 @@ fn rewrite_position_sound_reference(
*sound_ref = Some(format!("{PRESET_LOCAL_SOUND_PREFIX}{sound_id}"));
Ok(())
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{defaults::default_positions, models::KnobPosition};
+
+ #[test]
+ fn image_payload_embeds_percent_encoded_file_url() {
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-preset-image-url-save-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&temp_dir).unwrap();
+ let image_path = temp_dir.join("image with space.png");
+ std::fs::write(&image_path, b"image-bytes").unwrap();
+ let image_url = url::Url::from_file_path(&image_path).unwrap().to_string();
+ assert!(image_url.contains("%20"));
+
+ let mut position = default_positions()["4key"][0].clone();
+ position.active_image = Some(image_url);
+ let key_positions = KeyPositions::from([("4key".to_string(), vec![position])]);
+
+ let (exported, _, _, _, embedded) = build_preset_image_payload(
+ &key_positions,
+ &StatPositions::new(),
+ &GraphPositions::new(),
+ &KnobPositions::new(),
+ )
+ .unwrap();
+
+ assert_eq!(embedded.len(), 1);
+ assert_eq!(
+ BASE64_STANDARD.decode(&embedded[0].data_base64).unwrap(),
+ b"image-bytes"
+ );
+ assert_eq!(
+ exported["4key"][0].active_image.as_deref(),
+ Some(format!("{PRESET_LOCAL_IMAGE_PREFIX}{}", embedded[0].image_id).as_str())
+ );
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+
+ #[test]
+ fn sound_payload_embeds_knob_sound() {
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-preset-knob-save-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&temp_dir).unwrap();
+ let sound_path = temp_dir.join("knob.wav");
+ std::fs::write(&sound_path, b"knob-sound").unwrap();
+
+ let mut position = default_positions()["4key"][0].clone();
+ position.sound_path = Some(sound_path.to_string_lossy().to_string());
+ let mut knob_positions = KnobPositions::new();
+ knob_positions.insert(
+ "4key".to_string(),
+ vec![KnobPosition {
+ axis_id: "axis".to_string(),
+ sensitivity: 1.0,
+ reverse: false,
+ position,
+ }],
+ );
+
+ let (_, _, _, exported_knobs, embedded) = build_preset_sound_payload(
+ &KeyPositions::new(),
+ &StatPositions::new(),
+ &GraphPositions::new(),
+ &knob_positions,
+ )
+ .unwrap();
+
+ assert_eq!(embedded.len(), 1);
+ let sound_ref = exported_knobs["4key"][0]
+ .position
+ .sound_path
+ .as_deref()
+ .unwrap();
+ let sound_id = sound_ref.strip_prefix(PRESET_LOCAL_SOUND_PREFIX).unwrap();
+ assert_eq!(sound_id, embedded[0].sound_id);
+ assert_eq!(
+ BASE64_STANDARD.decode(&embedded[0].data_base64).unwrap(),
+ b"knob-sound"
+ );
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+
+ // 단독 실행: cargo test --lib commands::preset::save::tests::preset_atomic_write_survives_file_size_limit -- --ignored --exact
+ #[cfg(unix)]
+ #[test]
+ #[ignore = "RLIMIT_FSIZE는 프로세스 전역이므로 단독 실행"]
+ fn preset_atomic_write_survives_file_size_limit() {
+ use crate::state::atomic_file::test_support::FileSizeLimit;
+
+ let temp_dir = std::env::temp_dir().join(format!(
+ "dmnote-preset-rlimit-test-{}",
+ uuid::Uuid::new_v4()
+ ));
+ std::fs::create_dir_all(&temp_dir).unwrap();
+ let path = temp_dir.join("preset.json");
+ let original = vec![b'o'; 512];
+ std::fs::write(&path, &original).unwrap();
+
+ {
+ let _limit = FileSizeLimit::set(1_024);
+ let oversized = "x".repeat(4_096);
+ assert!(write_preset_file(&path, &oversized).is_err());
+ assert_eq!(std::fs::read(&path).unwrap(), original);
+ }
+
+ assert!(!std::fs::read_dir(&temp_dir).unwrap().any(|entry| {
+ entry
+ .ok()
+ .and_then(|entry| entry.file_name().into_string().ok())
+ .is_some_and(|name| name.ends_with(".tmp"))
+ }));
+ let _ = std::fs::remove_dir_all(temp_dir);
+ }
+}
diff --git a/src-tauri/src/keyboard/daemon/mod.rs b/src-tauri/src/keyboard/daemon/mod.rs
index dfec6281..33305846 100644
--- a/src-tauri/src/keyboard/daemon/mod.rs
+++ b/src-tauri/src/keyboard/daemon/mod.rs
@@ -1,4 +1,7 @@
-use std::io::Write;
+use std::{
+ io::{self, Read, Write},
+ thread,
+};
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
use anyhow::anyhow;
@@ -27,6 +30,32 @@ fn load_hotkeys_from_env() -> ShortcutsState {
.unwrap_or_default()
}
+fn wait_for_parent_disconnect(reader: &mut impl Read) -> io::Result<()> {
+ let mut buffer = [0_u8; 1];
+ loop {
+ match reader.read(&mut buffer) {
+ Ok(0) => return Ok(()),
+ Ok(_) => {}
+ Err(err) if err.kind() == io::ErrorKind::Interrupted => {}
+ Err(err) => return Err(err),
+ }
+ }
+}
+
+pub fn start_parent_liveness_watch() -> io::Result<()> {
+ thread::Builder::new()
+ .name("keyboard-parent-watch".into())
+ .spawn(|| {
+ let stdin = io::stdin();
+ let mut stdin = stdin.lock();
+ if let Err(err) = wait_for_parent_disconnect(&mut stdin) {
+ eprintln!("keyboard parent watch failed: {err}");
+ }
+ std::process::exit(0);
+ })
+ .map(|_| ())
+}
+
fn write_message(sink: &mut Box, message: &HookMessage) -> Result<()> {
let line = to_string(message)?;
sink.write_all(line.as_bytes())?;
@@ -67,3 +96,23 @@ pub fn run() -> Result<()> {
))
}
}
+
+#[cfg(test)]
+mod tests {
+ use std::io::Cursor;
+
+ use super::wait_for_parent_disconnect;
+
+ #[test]
+ fn parent_watch_returns_after_pipe_eof() {
+ let mut reader = Cursor::new(Vec::::new());
+ wait_for_parent_disconnect(&mut reader).unwrap();
+ }
+
+ #[test]
+ fn parent_watch_ignores_bytes_until_pipe_eof() {
+ let mut reader = Cursor::new(b"keepalive".to_vec());
+ wait_for_parent_disconnect(&mut reader).unwrap();
+ assert_eq!(reader.position(), b"keepalive".len() as u64);
+ }
+}
diff --git a/src-tauri/src/keyboard/manager.rs b/src-tauri/src/keyboard/manager.rs
index 92102b54..d65d518c 100644
--- a/src-tauri/src/keyboard/manager.rs
+++ b/src-tauri/src/keyboard/manager.rs
@@ -9,6 +9,7 @@ pub struct KeyboardManager {
mappings: Arc>,
current_mode: Arc>,
valid_keys: Arc>>,
+ active_keys: Arc>>,
}
impl KeyboardManager {
@@ -19,51 +20,311 @@ impl KeyboardManager {
mappings,
current_mode,
valid_keys: Arc::new(RwLock::new(HashSet::new())),
+ active_keys: Arc::new(RwLock::new(HashSet::new())),
};
manager.rebuild_valid_keys();
manager
}
pub fn update_mappings(&self, mappings: KeyMappings) {
- *self.mappings.write() = mappings;
- self.rebuild_valid_keys();
+ let mut mappings_guard = self.mappings.write();
+ let current_mode = self.current_mode.read();
+ let next_valid_keys = Self::valid_keys_for_mode(&mappings, ¤t_mode);
+ let mut valid_keys = self.valid_keys.write();
+ let mut active_keys = self.active_keys.write();
+
+ Self::retain_active_keys(&mut active_keys, ¤t_mode, &next_valid_keys);
+ *mappings_guard = mappings;
+ *valid_keys = next_valid_keys;
}
pub fn set_mode(&self, mode: impl Into) -> bool {
let mode = mode.into();
- let exists = self.mappings.read().contains_key(&mode);
- if exists {
- *self.current_mode.write() = mode;
- self.rebuild_valid_keys();
+ let mappings = self.mappings.read();
+ if !mappings.contains_key(&mode) {
+ return false;
}
- exists
+
+ let next_valid_keys = Self::valid_keys_for_mode(&mappings, &mode);
+ let mut current_mode = self.current_mode.write();
+ let mut valid_keys = self.valid_keys.write();
+ let mut active_keys = self.active_keys.write();
+
+ Self::rekey_active_keys(&mut active_keys, ¤t_mode, &mode, &next_valid_keys);
+ *current_mode = mode;
+ *valid_keys = next_valid_keys;
+ true
+ }
+
+ pub fn update_mappings_and_set_mode(
+ &self,
+ mappings: KeyMappings,
+ mode: impl Into,
+ ) -> bool {
+ let mode = mode.into();
+ let mode_exists = mappings.contains_key(&mode);
+ let mut mappings_guard = self.mappings.write();
+ let mut current_mode = self.current_mode.write();
+ let next_mode = if mode_exists {
+ mode.as_str()
+ } else {
+ current_mode.as_str()
+ };
+ let next_valid_keys = Self::valid_keys_for_mode(&mappings, next_mode);
+ let mut valid_keys = self.valid_keys.write();
+ let mut active_keys = self.active_keys.write();
+
+ if mode_exists {
+ Self::rekey_active_keys(&mut active_keys, ¤t_mode, &mode, &next_valid_keys);
+ *current_mode = mode;
+ } else {
+ Self::retain_active_keys(&mut active_keys, ¤t_mode, &next_valid_keys);
+ }
+
+ *mappings_guard = mappings;
+ *valid_keys = next_valid_keys;
+ mode_exists
}
pub fn current_mode(&self) -> String {
self.current_mode.read().clone()
}
- pub fn match_candidate<'a>(
+ pub fn match_and_register<'a>(
&self,
candidates: impl IntoIterator- ,
- ) -> Option {
- let guard = self.valid_keys.read();
- for candidate in candidates {
- if guard.contains(candidate) {
- return Some(candidate.to_string());
- }
+ is_down: bool,
+ ) -> Option<(String, String, bool)> {
+ let current_mode = self.current_mode.read();
+ let valid_keys = self.valid_keys.read();
+ let key = candidates
+ .into_iter()
+ .find(|candidate| valid_keys.contains(*candidate))?
+ .to_string();
+ let mut active_keys = self.active_keys.write();
+ let active_key = Self::compose_active_key(¤t_mode, &key);
+ let changed = if is_down {
+ active_keys.insert(active_key)
+ } else {
+ active_keys.remove(&active_key)
+ };
+
+ Some((current_mode.clone(), key, changed))
+ }
+
+ #[cfg(test)]
+ pub fn register_key_down(&self, mode: &str, key: &str) -> bool {
+ let current_mode = self.current_mode.read();
+ if current_mode.as_str() != mode {
+ return false;
+ }
+ let valid_keys = self.valid_keys.read();
+ if !valid_keys.contains(key) {
+ return false;
+ }
+ self.active_keys
+ .write()
+ .insert(Self::compose_active_key(¤t_mode, key))
+ }
+
+ #[cfg(test)]
+ pub fn register_key_up(&self, mode: &str, key: &str) -> bool {
+ let current_mode = self.current_mode.read();
+ if current_mode.as_str() != mode {
+ return false;
+ }
+ let valid_keys = self.valid_keys.read();
+ if !valid_keys.contains(key) {
+ return false;
}
- None
+ self.active_keys
+ .write()
+ .remove(&Self::compose_active_key(¤t_mode, key))
+ }
+
+ pub fn clear_active_keys(&self) {
+ self.active_keys.write().clear();
+ }
+
+ pub fn pressed_keys(&self) -> Vec {
+ let current_mode = self.current_mode.read();
+ let prefix = format!("{current_mode}::");
+ let active_keys = self.active_keys.read();
+ let mut keys: Vec = active_keys
+ .iter()
+ .filter_map(|entry| entry.strip_prefix(&prefix).map(str::to_string))
+ .collect();
+ keys.sort();
+ keys
}
fn rebuild_valid_keys(&self) {
let mappings = self.mappings.read();
let mode = self.current_mode.read();
- let keys = mappings.get(mode.as_str()).cloned().unwrap_or_default();
- let mut guard = self.valid_keys.write();
- guard.clear();
- for key in keys {
- guard.insert(key);
- }
+ *self.valid_keys.write() = Self::valid_keys_for_mode(&mappings, &mode);
+ }
+
+ fn valid_keys_for_mode(mappings: &KeyMappings, mode: &str) -> HashSet {
+ mappings.get(mode).into_iter().flatten().cloned().collect()
+ }
+
+ fn retain_active_keys(
+ active_keys: &mut HashSet,
+ mode: &str,
+ valid_keys: &HashSet,
+ ) {
+ let prefix = format!("{mode}::");
+ active_keys.retain(|entry| {
+ entry
+ .strip_prefix(&prefix)
+ .is_some_and(|key| valid_keys.contains(key))
+ });
+ }
+
+ fn rekey_active_keys(
+ active_keys: &mut HashSet,
+ current_mode: &str,
+ next_mode: &str,
+ next_valid_keys: &HashSet,
+ ) {
+ let prefix = format!("{current_mode}::");
+ *active_keys = active_keys
+ .drain()
+ .filter_map(|entry| {
+ let key = entry.strip_prefix(&prefix)?;
+ next_valid_keys
+ .contains(key)
+ .then(|| Self::compose_active_key(next_mode, key))
+ })
+ .collect();
+ }
+
+ fn compose_active_key(mode: &str, key: &str) -> String {
+ format!("{mode}::{key}")
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use std::collections::HashMap;
+
+ use super::KeyboardManager;
+
+ #[test]
+ fn pressed_keys_use_event_key_names_for_current_mode() {
+ let mappings = HashMap::from([
+ (
+ "4key".to_string(),
+ vec!["KeyD".to_string(), "KeyF".to_string()],
+ ),
+ (
+ "8key".to_string(),
+ vec!["KeyD".to_string(), "KeyF".to_string()],
+ ),
+ ]);
+ let manager = KeyboardManager::new(mappings, "4key");
+
+ assert!(manager.register_key_down("4key", "KeyF"));
+ assert!(manager.register_key_down("4key", "KeyD"));
+ assert_eq!(manager.pressed_keys(), vec!["KeyD", "KeyF"]);
+
+ assert!(manager.set_mode("8key"));
+ assert_eq!(manager.pressed_keys(), vec!["KeyD", "KeyF"]);
+ assert!(manager.register_key_up("8key", "KeyD"));
+ assert_eq!(manager.pressed_keys(), vec!["KeyF"]);
+ }
+
+ #[test]
+ fn mode_switch_retains_only_shared_active_keys() {
+ let mappings = HashMap::from([
+ (
+ "source".to_string(),
+ vec!["KeyD".to_string(), "KeyF".to_string()],
+ ),
+ (
+ "target".to_string(),
+ vec!["KeyF".to_string(), "KeyJ".to_string()],
+ ),
+ ]);
+ let manager = KeyboardManager::new(mappings, "source");
+
+ assert!(manager.register_key_down("source", "KeyD"));
+ assert!(manager.register_key_down("source", "KeyF"));
+ assert!(manager.set_mode("target"));
+
+ assert_eq!(manager.pressed_keys(), vec!["KeyF"]);
+ assert!(!manager.register_key_up("target", "KeyD"));
+ assert!(manager.register_key_up("target", "KeyF"));
+ }
+
+ #[test]
+ fn reset_to_empty_mapping_clears_active_keys() {
+ let manager = KeyboardManager::new(
+ HashMap::from([("custom".to_string(), vec!["KeyD".to_string()])]),
+ "custom",
+ );
+ assert!(manager.register_key_down("custom", "KeyD"));
+
+ manager.update_mappings(HashMap::from([("custom".to_string(), Vec::new())]));
+
+ assert!(manager.pressed_keys().is_empty());
+ assert!(!manager.register_key_up("custom", "KeyD"));
+ }
+
+ #[test]
+ fn update_mappings_prunes_removed_active_keys() {
+ let manager = KeyboardManager::new(
+ HashMap::from([(
+ "4key".to_string(),
+ vec!["KeyD".to_string(), "KeyF".to_string()],
+ )]),
+ "4key",
+ );
+ assert!(manager.register_key_down("4key", "KeyD"));
+ assert!(manager.register_key_down("4key", "KeyF"));
+
+ manager.update_mappings(HashMap::from([(
+ "4key".to_string(),
+ vec!["KeyF".to_string(), "KeyJ".to_string()],
+ )]));
+
+ assert_eq!(manager.pressed_keys(), vec!["KeyF"]);
+ assert!(!manager.register_key_up("4key", "KeyD"));
+ assert!(manager.register_key_up("4key", "KeyF"));
+ }
+
+ #[test]
+ fn stale_mode_or_invalid_key_registration_is_rejected() {
+ let manager = KeyboardManager::new(
+ HashMap::from([
+ ("source".to_string(), vec!["KeyD".to_string()]),
+ ("target".to_string(), vec!["KeyF".to_string()]),
+ ]),
+ "source",
+ );
+
+ assert!(manager.set_mode("target"));
+ assert!(!manager.register_key_down("target", "KeyD"));
+ assert!(!manager.register_key_down("source", "KeyD"));
+ assert!(manager.pressed_keys().is_empty());
+ }
+
+ #[test]
+ fn matching_and_registration_share_one_mode_snapshot() {
+ let manager = KeyboardManager::new(
+ HashMap::from([
+ ("source".to_string(), vec!["KeyD".to_string()]),
+ ("target".to_string(), vec!["KeyF".to_string()]),
+ ]),
+ "source",
+ );
+
+ assert_eq!(
+ manager.match_and_register(["KeyD"], true),
+ Some(("source".to_string(), "KeyD".to_string(), true))
+ );
+ assert!(manager.set_mode("target"));
+ assert!(manager.pressed_keys().is_empty());
+ assert_eq!(manager.match_and_register(["KeyD"], true), None);
}
}
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index 2c6916af..c74e0885 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -52,6 +52,10 @@ fn main() {
}
if std::env::args().any(|arg| arg == "--keyboard-daemon") {
+ if let Err(err) = keyboard::daemon::start_parent_liveness_watch() {
+ eprintln!("failed to start keyboard parent watch: {err}");
+ std::process::exit(1);
+ }
if let Err(err) = keyboard::daemon::run() {
eprintln!("keyboard daemon error: {err:?}");
std::process::exit(1);
@@ -71,7 +75,7 @@ fn main() {
let context = tauri::generate_context!();
- tauri::Builder::default()
+ let app = tauri::Builder::default()
.on_page_load(|webview, payload| {
if matches!(payload.event(), PageLoadEvent::Finished) {
let zoom = compute_compensating_zoom();
@@ -85,7 +89,11 @@ fn main() {
}
})
.plugin(tauri_plugin_single_instance::init(|app, _args, _cwd| {
- if let Some(window) = app.get_webview_window("main") {
+ if let Some(state) = app.try_state::() {
+ if let Err(err) = state.show_main_window(app) {
+ log::warn!("failed to show main window from second instance: {err}");
+ }
+ } else if let Some(window) = app.get_webview_window("main") {
let _ = window.unminimize();
let _ = window.show();
let _ = window.set_focus();
@@ -264,8 +272,25 @@ fn main() {
commands::plugin::storage::plugin_storage_has_data,
commands::plugin::storage::plugin_storage_clear_by_prefix,
])
- .run(context)
- .expect("error while running tauri application");
+ .build(context)
+ .expect("error while building tauri application");
+
+ app.run(|app_handle, event| match event {
+ tauri::RunEvent::ExitRequested { .. } | tauri::RunEvent::Exit => {
+ if let Some(state) = app_handle.try_state::() {
+ state.shutdown();
+ }
+ }
+ #[cfg(target_os = "macos")]
+ tauri::RunEvent::Reopen { .. } => {
+ if let Some(state) = app_handle.try_state::() {
+ if let Err(err) = state.show_main_window(app_handle) {
+ log::warn!("failed to show main window from Dock helper: {err}");
+ }
+ }
+ }
+ _ => {}
+ });
}
#[cfg(target_os = "windows")]
@@ -534,7 +559,8 @@ fn launch_macos_dock_helper() {
};
let mut cmd = Command::new("/usr/bin/open");
- cmd.arg(&helper_path)
+ cmd.arg("-n")
+ .arg(&helper_path)
.arg("--args")
.arg("--main-pid")
.arg(std::process::id().to_string())
diff --git a/src-tauri/src/models/mod.rs b/src-tauri/src/models/mod.rs
index 22581232..e93592a4 100644
--- a/src-tauri/src/models/mod.rs
+++ b/src-tauri/src/models/mod.rs
@@ -92,6 +92,13 @@ impl Default for SoundLibraryEntry {
}
}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct PendingProcessedWavReplacement {
+ pub sound_path: String,
+ pub had_original: bool,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(
tag = "kind",
@@ -178,6 +185,7 @@ pub struct KeyPosition {
pub dx: f64,
pub dy: f64,
pub width: f64,
+ #[serde(default = "default_key_height")]
pub height: f64,
/// 레이어 표시 여부 (true면 숨김)
#[serde(default)]
@@ -200,9 +208,15 @@ pub struct KeyPosition {
#[serde(default)]
pub idle_transparent: bool,
pub count: u32,
+ #[serde(default = "default_key_note_color")]
pub note_color: NoteColor,
+ #[serde(default = "default_key_note_opacity")]
pub note_opacity: u32,
#[serde(default)]
+ pub note_opacity_top: Option,
+ #[serde(default)]
+ pub note_opacity_bottom: Option,
+ #[serde(default)]
pub note_border_radius: Option,
/// 노트 넓이(px). None이면 키 width를 사용(자동).
#[serde(default)]
@@ -219,6 +233,10 @@ pub struct KeyPosition {
#[serde(default = "default_note_glow_opacity")]
pub note_glow_opacity: u32,
#[serde(default)]
+ pub note_glow_opacity_top: Option,
+ #[serde(default)]
+ pub note_glow_opacity_bottom: Option,
+ #[serde(default)]
pub note_glow_color: Option,
#[serde(default = "default_note_auto_y_correction")]
pub note_auto_y_correction: bool,
@@ -303,6 +321,72 @@ pub struct KeyPosition {
pub group_id: Option,
}
+impl Default for KeyPosition {
+ fn default() -> Self {
+ Self {
+ dx: 0.0,
+ dy: 0.0,
+ width: 60.0,
+ height: default_key_height(),
+ hidden: false,
+ active_image: None,
+ inactive_image: None,
+ sound_enabled: None,
+ sound_path: None,
+ sound_volume: None,
+ active_transparent: false,
+ idle_transparent: false,
+ count: 0,
+ note_color: default_key_note_color(),
+ note_opacity: default_key_note_opacity(),
+ note_opacity_top: None,
+ note_opacity_bottom: None,
+ note_border_radius: None,
+ note_width: None,
+ note_alignment: NoteAlignment::default(),
+ note_effect_enabled: default_note_effect_enabled(),
+ note_glow_enabled: default_note_glow_enabled(),
+ note_glow_size: default_note_glow_size(),
+ note_glow_opacity: default_note_glow_opacity(),
+ note_glow_opacity_top: None,
+ note_glow_opacity_bottom: None,
+ note_glow_color: None,
+ note_auto_y_correction: default_note_auto_y_correction(),
+ note_offset_x: None,
+ note_offset_y: None,
+ note_border_width: None,
+ note_border_color: None,
+ note_border_opacity: default_note_border_opacity(),
+ note_border_side: None,
+ class_name: None,
+ z_index: None,
+ counter: KeyCounterSettings::default(),
+ background_color: None,
+ active_background_color: None,
+ border_color: None,
+ active_border_color: None,
+ border_width: None,
+ border_radius: None,
+ font_size: None,
+ font_color: None,
+ active_font_color: None,
+ graph_animation_enabled: None,
+ font_family: None,
+ image_fit: None,
+ idle_image_fit: None,
+ active_image_fit: None,
+ use_inline_styles: None,
+ display_text: None,
+ font_weight: None,
+ font_italic: None,
+ font_underline: None,
+ font_strikethrough: None,
+ layer_name: None,
+ group_id: None,
+ }
+ }
+}
+
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum StatType {
@@ -780,6 +864,15 @@ fn default_counter_enabled() -> bool {
fn default_note_effect_enabled() -> bool {
true
}
+fn default_key_height() -> f64 {
+ 60.0
+}
+fn default_key_note_color() -> NoteColor {
+ NoteColor::Solid("#FFFFFF".to_string())
+}
+fn default_key_note_opacity() -> u32 {
+ 80
+}
fn default_note_glow_enabled() -> bool {
false
}
@@ -809,7 +902,7 @@ fn default_reverse_fade_bottom_px() -> u32 {
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", default)]
pub struct NoteSettings {
// Legacy: 전역 노트 라운딩 (개별 키 noteBorderRadius로 마이그레이션됨)
#[serde(default, skip_serializing)]
@@ -1306,6 +1399,9 @@ pub struct AppStoreData {
/// 사운드 라이브러리 메타데이터 (키: 절대 경로, 값: 메타데이터)
#[serde(default)]
pub sound_library: HashMap,
+ /// WAV 파일과 메타데이터 커밋 사이의 크래시 복구 저널
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub pending_processed_wav_replacement: Option,
#[serde(default)]
pub key_sound_output_backend: Option,
/// OBS 모드 활성화 여부
@@ -1368,6 +1464,7 @@ impl Default for AppStoreData {
grid_settings: GridSettings::default(),
shortcuts: ShortcutsState::default(),
sound_library: HashMap::new(),
+ pending_processed_wav_replacement: None,
key_sound_output_backend: None,
obs_mode_enabled: false,
obs_port: default_obs_port(),
@@ -1590,6 +1687,7 @@ pub struct BootstrapPayload {
pub custom_tabs: Vec,
pub selected_key_type: String,
pub current_mode: String,
+ pub active_keys: Vec,
pub overlay: BootstrapOverlayState,
pub key_counters: KeyCounters,
pub layer_groups: LayerGroups,
@@ -1846,7 +1944,7 @@ pub struct SettingsPatch {
#[cfg(test)]
mod tests {
- use super::KeyPosition;
+ use super::{FadePosition, KeyPosition, NoteColor, NoteSettings};
// 필수 필드만 채운 최소 KeyPosition JSON. 시각 px 필드는 호출부에서 주입
fn key_position_json(visual_px: &str) -> String {
@@ -1890,4 +1988,64 @@ mod tests {
assert_eq!(pos.note_glow_size, 20.0);
assert_eq!(pos.note_width, None);
}
+
+ #[test]
+ fn gradient_opacity_fields_survive_serde_round_trip() {
+ let json = key_position_json(
+ r#""noteOpacityTop": 91, "noteOpacityBottom": 37,
+ "noteGlowOpacityTop": 64, "noteGlowOpacityBottom": 18"#,
+ );
+ let position: KeyPosition = serde_json::from_str(&json).unwrap();
+
+ assert_eq!(position.note_opacity_top, Some(91));
+ assert_eq!(position.note_opacity_bottom, Some(37));
+ assert_eq!(position.note_glow_opacity_top, Some(64));
+ assert_eq!(position.note_glow_opacity_bottom, Some(18));
+
+ let serialized = serde_json::to_value(&position).unwrap();
+ assert_eq!(serialized["noteOpacityTop"], 91);
+ assert_eq!(serialized["noteOpacityBottom"], 37);
+ assert_eq!(serialized["noteGlowOpacityTop"], 64);
+ assert_eq!(serialized["noteGlowOpacityBottom"], 18);
+
+ let restored: KeyPosition = serde_json::from_value(serialized).unwrap();
+ assert_eq!(restored, position);
+ }
+
+ #[test]
+ fn note_settings_1_3_format_still_preserves_every_field() {
+ // 1.3 시절 noteSettings 전체 필드 실형식
+ let fixture = r#"{
+ "borderRadius": 9,
+ "speed": 456,
+ "trackHeight": 222,
+ "reverse": true,
+ "fadePosition": "bottom",
+ "delayedNoteEnabled": true,
+ "shortNoteThresholdMs": 73,
+ "shortNoteMinLengthPx": 41
+ }"#;
+ let settings: NoteSettings = serde_json::from_str(fixture).unwrap();
+
+ assert_eq!(settings.border_radius, Some(9));
+ assert_eq!(settings.speed, 456);
+ assert_eq!(settings.track_height, 222);
+ assert!(settings.reverse);
+ assert_eq!(settings.fade_position, FadePosition::Bottom);
+ assert!(settings.delayed_note_enabled);
+ assert_eq!(settings.short_note_threshold_ms, 73);
+ assert_eq!(settings.short_note_min_length_px, 41);
+ }
+
+ #[test]
+ fn key_position_1_0_missing_visual_fields_uses_legacy_defaults() {
+ let position: KeyPosition =
+ serde_json::from_str(r#"{"dx":777,"dy":12,"width":60,"count":42}"#).unwrap();
+
+ assert_eq!(position.dx, 777.0);
+ assert_eq!(position.count, 42);
+ assert_eq!(position.height, 60.0);
+ assert_eq!(position.note_color, NoteColor::Solid("#FFFFFF".to_string()));
+ assert_eq!(position.note_opacity, 80);
+ }
}
diff --git a/src-tauri/src/models/obs.rs b/src-tauri/src/models/obs.rs
index 12e7bd52..d1516802 100644
--- a/src-tauri/src/models/obs.rs
+++ b/src-tauri/src/models/obs.rs
@@ -27,8 +27,8 @@ pub struct ObsEnvelope {
pub struct HelloAckPayload {
pub server_version: String,
pub obs_mode: bool,
- /// OBS 클라이언트에 전달할 deny list (|로 끝나면 prefix 매칭)
- pub deny_list: Vec,
+ /// OBS 클라이언트에 전달할 정확 일치 allowlist
+ pub allowed_list: Vec,
}
/// invoke_request 페이로드 (클라이언트 → 서버)
@@ -87,3 +87,24 @@ fn timestamp_ms() -> u64 {
.unwrap_or_default()
.as_millis() as u64
}
+
+#[cfg(test)]
+mod tests {
+ use super::HelloAckPayload;
+
+ #[test]
+ fn hello_ack_exposes_allowed_list() {
+ let value = serde_json::to_value(HelloAckPayload {
+ server_version: "test".to_string(),
+ obs_mode: true,
+ allowed_list: vec!["settings_get".to_string()],
+ })
+ .unwrap();
+
+ assert_eq!(
+ value.get("allowedList"),
+ Some(&serde_json::json!(["settings_get"]))
+ );
+ assert!(value.get("denyList").is_none());
+ }
+}
diff --git a/src-tauri/src/services/obs_bridge.rs b/src-tauri/src/services/obs_bridge.rs
index a212cc32..1d61a15d 100644
--- a/src-tauri/src/services/obs_bridge.rs
+++ b/src-tauri/src/services/obs_bridge.rs
@@ -1,7 +1,10 @@
-use std::net::SocketAddr;
+use std::io::Cursor;
+use std::net::{IpAddr, SocketAddr};
use std::path::PathBuf;
+use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::Arc;
+use std::task::{Context, Poll};
use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
@@ -10,74 +13,290 @@ use serde_json::Value;
use tauri::ipc::{CallbackFn, InvokeBody, InvokeResponse, InvokeResponseBody};
use tauri::webview::InvokeRequest;
use tauri::{AppHandle, Listener, Manager, Wry};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{broadcast, oneshot};
-use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::{
+ accept_hdr_async,
+ tungstenite::{
+ handshake::server::{ErrorResponse, Request as WsRequest, Response as WsResponse},
+ http::{header, StatusCode},
+ Message,
+ },
+ WebSocketStream,
+};
use crate::models::obs::{
make_envelope, HelloAckPayload, InvokeRequestPayload, ObsBroadcast, ObsEnvelope, ObsStatus,
+ OBS_PROTOCOL_VERSION,
};
-/// 로컬 IP 조회 실패 시 Game Bar가 사용할 loopback fallback host
-const DEFAULT_LOOPBACK_HOST: &str = "127.0.0.1";
-
-/// OBS 클라이언트에서 실행 불가능한 커맨드 목록
-/// `|`로 끝나는 항목은 prefix 매칭 (예: "plugin:window|" → "plugin:window|*" 전부 차단)
-const DENIED_WS_COMMANDS: &[&str] = &[
- // 오버레이 제어 (OBS에서 조작 불가)
- "overlay_resize",
- "overlay_set_visible",
- "overlay_set_lock",
- "overlay_set_anchor",
- "overlay_get",
- // 윈도우/앱 제어
- "window_minimize",
- "window_close",
- "window_show_main",
- "window_open_devtools_all",
- "app_quit",
- "app_restart",
- "app_open_external",
- "app_auto_update",
- // OBS 서버 제어 (자기 자신 종료/재시작 방지)
- "obs_start",
- "obs_stop",
- "obs_regenerate_token",
- // 파일 대화상자 / 파일 쓰기 (로컬 파일 시스템 접근)
- "image_load",
- "font_load",
- "sound_load",
- "sound_save_processed_wav",
- "css_load",
- "css_reset",
- "js_load",
- "js_reset",
- "js_reload",
- "preset_load",
- "preset_load_tab",
- // Tauri 플러그인 (네이티브 윈도우/메뉴/리소스)
- "plugin:window|",
- "plugin:menu|",
- "plugin:resources|",
+const MAX_HTTP_HEADER_SIZE: usize = 16 * 1024;
+
+/// OBS 클라이언트에서 실행 가능한 커맨드 목록
+const ALLOWED_WS_COMMANDS: &[&str] = &[
+ "app_bootstrap",
+ "settings_get",
+ "layer_groups_get",
+ "note_tab_get_all",
+ "note_tab_get",
+ "css_get",
+ "css_get_use",
+ "css_tab_get_all",
+ "css_tab_get",
+ "js_get",
+ "js_get_use",
+ "get_cursor_settings",
+ "keys_get",
+ "keys_get_counters",
+ "positions_get",
+ "stat_positions_get",
+ "graph_positions_get",
+ "knob_positions_get",
+ "custom_tabs_list",
+ "counter_animation_list",
+ "plugin_bridge_send",
+ "plugin_bridge_send_to",
+ "raw_input_subscribe",
+ "raw_input_unsubscribe",
+ "plugin_storage_get",
+ "plugin_storage_set",
+ "plugin_storage_remove",
+ "plugin_storage_keys",
+ "plugin_storage_has_data",
+ "plugin_storage_clear_by_prefix",
];
-/// 커맨드가 deny list에 해당하는지 확인
-fn is_denied(cmd: &str) -> bool {
- DENIED_WS_COMMANDS.iter().any(|entry| {
- if let Some(prefix) = entry.strip_suffix('|') {
- cmd.starts_with(prefix)
- && cmd.len() > prefix.len()
- && cmd.as_bytes()[prefix.len()] == b'|'
- } else {
- cmd == *entry
+fn is_allowed_command(command: &str) -> bool {
+ ALLOWED_WS_COMMANDS.contains(&command)
+}
+
+fn build_allowed_list() -> Vec {
+ ALLOWED_WS_COMMANDS
+ .iter()
+ .map(|command| command.to_string())
+ .collect()
+}
+
+struct PrefixedStream {
+ prefix: Cursor>,
+ stream: TcpStream,
+}
+
+impl PrefixedStream {
+ fn new(prefix: Vec, stream: TcpStream) -> Self {
+ Self {
+ prefix: Cursor::new(prefix),
+ stream,
+ }
+ }
+}
+
+impl AsyncRead for PrefixedStream {
+ fn poll_read(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ buffer: &mut ReadBuf<'_>,
+ ) -> Poll> {
+ let this = self.get_mut();
+ let position = this.prefix.position() as usize;
+ let prefix = this.prefix.get_ref();
+ if position < prefix.len() {
+ let count = (prefix.len() - position).min(buffer.remaining());
+ buffer.put_slice(&prefix[position..position + count]);
+ this.prefix.set_position((position + count) as u64);
+ return Poll::Ready(Ok(()));
+ }
+ Pin::new(&mut this.stream).poll_read(cx, buffer)
+ }
+}
+
+impl AsyncWrite for PrefixedStream {
+ fn poll_write(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ buffer: &[u8],
+ ) -> Poll> {
+ Pin::new(&mut self.get_mut().stream).poll_write(cx, buffer)
+ }
+
+ fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> {
+ Pin::new(&mut self.get_mut().stream).poll_flush(cx)
+ }
+
+ fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> {
+ Pin::new(&mut self.get_mut().stream).poll_shutdown(cx)
+ }
+}
+
+async fn read_http_request_headers(stream: &mut TcpStream) -> std::io::Result> {
+ let mut request = Vec::with_capacity(1024);
+ let mut chunk = [0u8; 1024];
+
+ loop {
+ if request.len() == MAX_HTTP_HEADER_SIZE {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::InvalidData,
+ "HTTP request headers too large",
+ ));
+ }
+
+ let remaining = MAX_HTTP_HEADER_SIZE - request.len();
+ let chunk_len = remaining.min(chunk.len());
+ let read = stream.read(&mut chunk[..chunk_len]).await?;
+ if read == 0 {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::UnexpectedEof,
+ "incomplete HTTP request headers",
+ ));
+ }
+ request.extend_from_slice(&chunk[..read]);
+
+ if http_header_end(&request).is_some() {
+ return Ok(request);
}
+ }
+}
+
+fn http_header_end(request: &[u8]) -> Option {
+ request
+ .windows(4)
+ .position(|window| window == b"\r\n\r\n")
+ .map(|position| position + 4)
+}
+
+fn http_header_values<'a>(request: &'a str, name: &str) -> Vec<&'a str> {
+ request
+ .lines()
+ .skip(1)
+ .take_while(|line| !line.trim_end_matches('\r').is_empty())
+ .filter_map(|line| line.trim_end_matches('\r').split_once(':'))
+ .filter_map(|(header_name, value)| {
+ header_name
+ .eq_ignore_ascii_case(name)
+ .then_some(value.trim())
+ })
+ .collect()
+}
+
+fn is_websocket_upgrade_request(request: &str) -> bool {
+ http_header_values(request, "upgrade").iter().any(|value| {
+ value
+ .split(',')
+ .any(|token| token.trim().eq_ignore_ascii_case("websocket"))
})
}
-/// deny list를 Vec으로 변환 (hello_ack 전송용)
-fn build_deny_list() -> Vec {
- DENIED_WS_COMMANDS.iter().map(|s| s.to_string()).collect()
+fn is_allowed_host_name(host: &str) -> bool {
+ if host.eq_ignore_ascii_case("localhost") {
+ return true;
+ }
+
+ let ip_literal = host
+ .strip_prefix('[')
+ .and_then(|value| value.strip_suffix(']'))
+ .unwrap_or(host);
+ ip_literal.parse::().is_ok()
+}
+
+fn is_allowed_host_header(value: &str) -> bool {
+ let value = value.trim();
+ if value.is_empty() || value.bytes().any(|byte| byte.is_ascii_whitespace()) {
+ return false;
+ }
+ if is_allowed_host_name(value) {
+ return true;
+ }
+
+ if let Some(closing_bracket) = value.find(']') {
+ let (host, suffix) = value.split_at(closing_bracket + 1);
+ return is_allowed_host_name(host)
+ && suffix
+ .strip_prefix(':')
+ .is_some_and(|port| port.parse::().is_ok());
+ }
+
+ value
+ .rsplit_once(':')
+ .is_some_and(|(host, port)| is_allowed_host_name(host) && port.parse::().is_ok())
+}
+
+/// 이 머신 자신의 IP인지 판정 (loopback 또는 로컬 인터페이스에 실제 할당된 IP)
+fn is_local_machine_ip(ip: &IpAddr) -> bool {
+ if ip.is_loopback() {
+ return true;
+ }
+ local_ip_address::list_afinet_netifas()
+ .map(|interfaces| {
+ interfaces
+ .iter()
+ .any(|(_, interface_ip)| interface_ip == ip)
+ })
+ .unwrap_or(false)
+}
+
+/// Origin은 브라우저가 강제하는 헤더 — 이 머신이 서빙한 페이지만 신뢰
+/// (localhost/loopback 또는 로컬 인터페이스에 실제 할당된 IP만 허용, OWASP 권고 allowlist)
+fn is_local_machine_host(host: &str) -> bool {
+ if host.eq_ignore_ascii_case("localhost") {
+ return true;
+ }
+
+ let ip_literal = host
+ .strip_prefix('[')
+ .and_then(|value| value.strip_suffix(']'))
+ .unwrap_or(host);
+ let Ok(ip) = ip_literal.parse::() else {
+ return false;
+ };
+ is_local_machine_ip(&ip)
+}
+
+fn is_allowed_origin(value: &str) -> bool {
+ tauri::Url::parse(value)
+ .ok()
+ .and_then(|url| url.host_str().map(str::to_string))
+ .is_some_and(|host| is_local_machine_host(&host))
+}
+
+fn has_allowed_http_host(request: &str) -> bool {
+ let hosts = http_header_values(request, "host");
+ hosts.len() == 1 && is_allowed_host_header(hosts[0])
+}
+
+fn validate_websocket_request(request: &WsRequest) -> Result<(), &'static str> {
+ let hosts: Vec<_> = request.headers().get_all(header::HOST).iter().collect();
+ if hosts.len() != 1 || !hosts[0].to_str().ok().is_some_and(is_allowed_host_header) {
+ return Err("Invalid Host header");
+ }
+
+ let origins: Vec<_> = request.headers().get_all(header::ORIGIN).iter().collect();
+ if origins.len() > 1
+ || origins
+ .first()
+ .is_some_and(|origin| !origin.to_str().ok().is_some_and(is_allowed_origin))
+ {
+ return Err("Invalid Origin header");
+ }
+
+ Ok(())
+}
+
+fn websocket_forbidden_response(reason: &str) -> ErrorResponse {
+ let mut response = ErrorResponse::new(Some(reason.to_string()));
+ *response.status_mut() = StatusCode::FORBIDDEN;
+ response
+}
+
+// OBS 모드는 같은 네트워크의 다른 PC 접속이 제품 계약 — 항상 전체 인터페이스에 바인딩
+// (WS/미디어는 토큰 인증, 커맨드는 allowlist로 보호)
+fn bind_address(port: u16) -> SocketAddr {
+ SocketAddr::from(([0, 0, 0, 0], port))
+}
+
+async fn write_empty_http_response(stream: &mut TcpStream, status: &str) {
+ let response = format!("HTTP/1.1 {status}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+ let _ = stream.write_all(response.as_bytes()).await;
}
/// 임베딩 에셋 조회 함수 타입 (path → Option<(bytes, mime_type)>)
@@ -212,6 +431,7 @@ impl ObsBridgeService {
Some(t.clone())
}
};
+ // 같은 네트워크의 다른 PC 접속 안내용 LAN IP (조회 실패 시 프론트가 localhost로 fallback)
let local_ip = local_ip_address::local_ip().ok().map(|ip| ip.to_string());
ObsStatus {
running: self.is_running(),
@@ -266,7 +486,7 @@ impl ObsBridgeService {
let mut last_err = String::new();
for offset in 0u16..10 {
let try_port = port.saturating_add(offset);
- let addr = SocketAddr::from(([0, 0, 0, 0], try_port));
+ let addr = bind_address(try_port);
match TcpListener::bind(addr).await {
Ok(l) => {
if offset > 0 {
@@ -330,6 +550,12 @@ impl ObsBridgeService {
/// 세션 토큰 교체 (실행 중 호출 가능)
pub fn set_token(&self, token: String) {
*self.session_token.write() = token;
+ // 기존 인증 세션 종료
+ let _ = self.broadcast_tx.send(ObsBroadcast::Shutdown);
+ }
+
+ fn is_current_session_token(&self, token: &str) -> bool {
+ self.session_token.read().as_str() == token
}
async fn server_loop(
@@ -362,22 +588,47 @@ impl ObsBridgeService {
}
async fn handle_connection(self: &Arc, mut stream: TcpStream, addr: SocketAddr) {
- // TCP 스트림을 peek하여 WebSocket upgrade 요청인지 판별
- let mut peek_buf = [0u8; 4096];
- let n = match stream.peek(&mut peek_buf).await {
- Ok(n) if n > 0 => n,
- _ => return,
+ let request_bytes = match tokio::time::timeout(
+ Duration::from_secs(5),
+ read_http_request_headers(&mut stream),
+ )
+ .await
+ {
+ Ok(Ok(request)) => request,
+ Ok(Err(error)) => {
+ log::debug!("[ObsBridge] HTTP 요청 헤더 파싱 실패 from {addr}: {error}");
+ write_empty_http_response(&mut stream, "400 Bad Request").await;
+ return;
+ }
+ Err(_) => {
+ log::debug!("[ObsBridge] HTTP 요청 헤더 타임아웃 from {addr}");
+ write_empty_http_response(&mut stream, "408 Request Timeout").await;
+ return;
+ }
};
- let request_preview = String::from_utf8_lossy(&peek_buf[..n]);
- let is_websocket = request_preview.lines().any(|line| {
- line.to_ascii_lowercase().starts_with("upgrade:")
- && line.to_ascii_lowercase().contains("websocket")
- });
+ let header_end = http_header_end(&request_bytes).unwrap_or(request_bytes.len());
+ let request = match std::str::from_utf8(&request_bytes[..header_end]) {
+ Ok(request) => request,
+ Err(error) => {
+ log::debug!("[ObsBridge] HTTP 요청 헤더 인코딩 오류 from {addr}: {error}");
+ write_empty_http_response(&mut stream, "400 Bad Request").await;
+ return;
+ }
+ };
- if is_websocket {
+ if is_websocket_upgrade_request(request) {
// WebSocket 핸드셰이크
- let ws_stream = match tokio_tungstenite::accept_async(stream).await {
+ #[allow(clippy::result_large_err)]
+ let callback = move |request: &WsRequest, response: WsResponse| {
+ if let Err(reason) = validate_websocket_request(request) {
+ log::warn!("[ObsBridge] WS 요청 거부 from {addr}: {reason}");
+ return Err(websocket_forbidden_response(reason));
+ }
+ Ok(response)
+ };
+ let prefixed_stream = PrefixedStream::new(request_bytes, stream);
+ let ws_stream = match accept_hdr_async(prefixed_stream, callback).await {
Ok(ws) => ws,
Err(e) => {
log::debug!("[ObsBridge] WS 핸드셰이크 실패 from {addr}: {e}");
@@ -387,16 +638,17 @@ impl ObsBridgeService {
self.handle_ws_client(ws_stream, addr).await;
} else {
// HTTP 정적 파일 서빙
- self.handle_http_request(&mut stream, &request_preview)
- .await;
+ self.handle_http_request(&mut stream, addr, request).await;
}
}
/// HTTP GET 요청에 대해 정적 파일 서빙
- async fn handle_http_request(&self, stream: &mut TcpStream, request: &str) {
- // 요청 소비 (peek 데이터를 실제로 읽어야 함)
- let mut discard = vec![0u8; request.len()];
- let _ = stream.read(&mut discard).await;
+ async fn handle_http_request(&self, stream: &mut TcpStream, addr: SocketAddr, request: &str) {
+ if !has_allowed_http_host(request) {
+ log::warn!("[ObsBridge] HTTP 요청 거부 from {addr}: 허용되지 않은 Host");
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ }
// GET 경로 파싱
let path = request
@@ -407,19 +659,24 @@ impl ObsBridgeService {
let route = path.split('?').next().unwrap_or(path);
let query = path.split_once('?').map(|(_, q)| q).unwrap_or("");
- if route == "/gamebar" {
- self.handle_gamebar_entry(stream).await;
- return;
- }
-
- if route == "/gamebar/bootstrap.json" {
- self.handle_gamebar_bootstrap(stream).await;
+ // /media/?token=xxx — 사용자 로컬 미디어 파일 서빙
+ // dev 리다이렉트보다 먼저 처리 — 미디어는 Vite가 아니라 브릿지가 직접 서빙
+ if let Some(rest) = path.strip_prefix("/media/") {
+ self.handle_media_request(stream, rest).await;
return;
}
// dev 모드: Vite dev server로 리다이렉트
let dev_url = self.dev_url.read().clone();
if let Some(dev_base) = &dev_url {
+ // 리다이렉트가 token을 쿼리로 전달하므로 이 머신 자신의 요청에만 허용 —
+ // 원격 LAN peer가 debug 서버에서 무인증 토큰을 얻는 경로 차단.
+ // 같은 PC가 자기 LAN IP로 접속하는 경우(URL 복사 기본값)는 peer도 로컬 인터페이스 IP라 유지됨
+ if !is_local_machine_ip(&addr.ip()) {
+ log::warn!("[ObsBridge] dev 리다이렉트 거부 from {addr}: 원격 peer");
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ }
let is_root_route = route == "/" || route.is_empty();
let redirect_path = if is_root_route {
if query.is_empty() {
@@ -448,12 +705,6 @@ impl ObsBridgeService {
return;
}
- // /media/?token=xxx — 사용자 로컬 미디어 파일 서빙
- if let Some(rest) = path.strip_prefix("/media/") {
- self.handle_media_request(stream, rest).await;
- return;
- }
-
// 경로 정규화: "/" → "obs/index.html"
let normalized = if route == "/" || route.is_empty() {
"obs/index.html"
@@ -508,50 +759,6 @@ impl ObsBridgeService {
.await;
}
- async fn handle_gamebar_entry(&self, stream: &mut TcpStream) {
- let location = self.build_gamebar_target_url();
- let response = format!(
- "HTTP/1.1 302 Found\r\nLocation: {location}\r\nContent-Length: 0\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n"
- );
- let _ = stream.write_all(response.as_bytes()).await;
- }
-
- async fn handle_gamebar_bootstrap(&self, stream: &mut TcpStream) {
- let port = *self.port.read();
- let token = self.session_token.read().clone();
- let body = serde_json::json!({
- "running": self.is_running(),
- "port": port,
- "token": token,
- "url": self.build_gamebar_target_url(),
- })
- .to_string();
- let response = format!(
- "HTTP/1.1 200 OK\r\nContent-Type: application/json; charset=utf-8\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n{}",
- body.len(),
- body
- );
- let _ = stream.write_all(response.as_bytes()).await;
- }
-
- /// Game Bar 셸이 최종적으로 열어야 할 오버레이 진입 URL 구성
- fn build_gamebar_target_url(&self) -> String {
- let port = *self.port.read();
- let token = self.session_token.read().clone();
- let host = self.resolve_gamebar_access_host();
- format!("http://{host}:{port}/?host={host}&port={port}&token={token}")
- }
-
- /// Game Bar WebView가 접근할 host 결정
- /// 우선 로컬 네트워크 IP를 사용하고, 실패 시 loopback으로 fallback
- fn resolve_gamebar_access_host(&self) -> String {
- local_ip_address::local_ip()
- .ok()
- .map(|ip| ip.to_string())
- .filter(|host| !host.is_empty())
- .unwrap_or_else(|| DEFAULT_LOOPBACK_HOST.to_string())
- }
-
/// Tauri 임베딩 에셋 조회
async fn resolve_asset(&self, path: &str) -> Option<(Vec, String)> {
let fetcher = self.asset_fetcher.read().clone();
@@ -561,11 +768,10 @@ impl ObsBridgeService {
None
}
- async fn handle_ws_client(
- self: &Arc,
- ws: tokio_tungstenite::WebSocketStream,
- addr: SocketAddr,
- ) {
+ async fn handle_ws_client
(self: &Arc, ws: WebSocketStream, addr: SocketAddr)
+ where
+ S: AsyncRead + AsyncWrite + Unpin + Send,
+ {
self.client_count.fetch_add(1, Ordering::Relaxed);
log::info!(
"[ObsBridge] 클라이언트 연결: {addr} (총 {})",
@@ -611,6 +817,30 @@ impl ObsBridgeService {
}
};
+ // 프로토콜 버전 검증 — handshake 계약이 다른 클라이언트는 fail-closed로 거부
+ let client_protocol = hello.payload.get("protocol").and_then(Value::as_u64);
+ if hello.v != OBS_PROTOCOL_VERSION
+ || client_protocol != Some(u64::from(OBS_PROTOCOL_VERSION))
+ {
+ log::warn!(
+ "[ObsBridge] {addr}: 프로토콜 버전 불일치 (v={}, protocol={client_protocol:?}), 연결 거부",
+ hello.v
+ );
+ let err_msg = make_envelope(
+ "error",
+ 0,
+ serde_json::json!({
+ "code": "PROTOCOL_MISMATCH",
+ "message": format!(
+ "Unsupported protocol version (expected {OBS_PROTOCOL_VERSION})"
+ ),
+ }),
+ );
+ let _ = ws_tx.send(Message::Text(err_msg.to_string())).await;
+ self.client_count.fetch_sub(1, Ordering::Relaxed);
+ return;
+ }
+
// 보안 토큰 검증
let expected_token = self.session_token.read().clone();
if !expected_token.is_empty() {
@@ -632,11 +862,15 @@ impl ObsBridgeService {
}
}
- // hello_ack 전송 (deny list 포함)
+ // hello_ack 전송 (allowlist 포함)
+ if !self.is_current_session_token(&expected_token) {
+ self.client_count.fetch_sub(1, Ordering::Relaxed);
+ return;
+ }
let ack_payload = serde_json::to_value(HelloAckPayload {
server_version: self.server_version.clone(),
obs_mode: true,
- deny_list: build_deny_list(),
+ allowed_list: build_allowed_list(),
})
.unwrap_or_default();
let ack_msg = make_envelope("hello_ack", next_seq(), ack_payload);
@@ -650,6 +884,10 @@ impl ObsBridgeService {
}
// snapshot 전송
+ if !self.is_current_session_token(&expected_token) {
+ self.client_count.fetch_sub(1, Ordering::Relaxed);
+ return;
+ }
let snapshot = self.cached_snapshot.read().clone();
let snapshot_msg = make_envelope("snapshot", next_seq(), snapshot);
if ws_tx
@@ -672,6 +910,9 @@ impl ObsBridgeService {
tokio::select! {
// broadcast 채널에서 메시지 수신 → 클라이언트에 전송
result = broadcast_rx.recv() => {
+ if !self.is_current_session_token(&expected_token) {
+ break;
+ }
match result {
Ok(ObsBroadcast::Shutdown) => break,
Ok(broadcast) => {
@@ -694,6 +935,9 @@ impl ObsBridgeService {
}
// 클라이언트에서 메시지 수신
msg = ws_rx.next() => {
+ if !self.is_current_session_token(&expected_token) {
+ break;
+ }
match msg {
Some(Ok(Message::Text(text))) => {
if let Ok(envelope) = serde_json::from_str::(&text) {
@@ -731,6 +975,9 @@ impl ObsBridgeService {
}
// RPC 응답 전송 (invoke_request → invoke_response)
Some((request_id, result)) = rpc_rx.recv() => {
+ if !self.is_current_session_token(&expected_token) {
+ break;
+ }
let payload = match result {
Ok(data) => serde_json::json!({ "requestId": request_id, "result": data }),
Err(err) => serde_json::json!({ "requestId": request_id, "error": err }),
@@ -742,6 +989,9 @@ impl ObsBridgeService {
}
// 서버 주도 ping (연결 유지)
_ = ping_interval.tick() => {
+ if !self.is_current_session_token(&expected_token) {
+ break;
+ }
let ping_msg = make_envelope("ping", next_seq(), Value::Null);
if ws_tx.send(Message::Text(ping_msg.to_string())).await.is_err() {
break;
@@ -779,13 +1029,13 @@ impl ObsBridgeService {
}
};
- // deny 체크 (이중 안전망 — 프론트엔드에서도 차단하지만 백엔드에서 한번 더)
- if is_denied(&req.command) {
- log::debug!("[ObsBridge] {addr}: denied cmd={}", req.command);
+ // allowlist 검사 (클라이언트 검사와 별도인 백엔드 안전망)
+ if !is_allowed_command(&req.command) {
+ log::debug!("[ObsBridge] {addr}: 허용되지 않은 cmd={}", req.command);
let _ = rpc_tx.send((
req.request_id,
Err(serde_json::json!(format!(
- "Command denied: {}",
+ "Command not allowed: {}",
req.command
))),
));
@@ -921,8 +1171,46 @@ impl ObsBridgeService {
}
};
+ if !file_path.is_absolute() {
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ }
+
+ let app_data_dir = self
+ .app_handle
+ .read()
+ .clone()
+ .and_then(|app| app.path().app_data_dir().ok());
+ let Some(app_data_dir) = app_data_dir else {
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ };
+ let canonical_app_data = match tokio::fs::canonicalize(app_data_dir).await {
+ Ok(path) => path,
+ Err(error) => {
+ log::warn!("[ObsBridge] app data 경로 확인 실패: {error}");
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ }
+ };
+ let canonical_file_path = match tokio::fs::canonicalize(&file_path).await {
+ Ok(path) => path,
+ Err(_) => {
+ write_empty_http_response(stream, "404 Not Found").await;
+ return;
+ }
+ };
+ if !canonical_file_path.starts_with(&canonical_app_data) {
+ log::warn!(
+ "[ObsBridge] app data 밖 media 요청 차단: {}",
+ file_path.display()
+ );
+ write_empty_http_response(stream, "403 Forbidden").await;
+ return;
+ }
+
// 허용 확장자 화이트리스트 (미디어/폰트 파일만)
- let ext = file_path
+ let ext = canonical_file_path
.extension()
.and_then(|e| e.to_str())
.unwrap_or("")
@@ -952,9 +1240,9 @@ impl ObsBridgeService {
}
// 파일 읽기 및 서빙
- match tokio::fs::read(&file_path).await {
+ match tokio::fs::read(&canonical_file_path).await {
Ok(content) => {
- let mime = guess_mime(&file_path.to_string_lossy());
+ let mime = guess_mime(&canonical_file_path.to_string_lossy());
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nCache-Control: max-age=3600\r\nConnection: close\r\n\r\n",
content.len()
@@ -1034,3 +1322,403 @@ fn broadcast_to_envelope(broadcast: &ObsBroadcast, seq: u64) -> Value {
ObsBroadcast::Shutdown => unreachable!("Shutdown은 직접 처리됨"),
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use tokio_tungstenite::{connect_async, MaybeTlsStream};
+
+ type TestWebSocket = WebSocketStream>;
+
+ async fn receive_envelope(ws: &mut TestWebSocket, expected_type: &str) -> ObsEnvelope {
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ match ws.next().await {
+ Some(Ok(Message::Text(text))) => {
+ let envelope = serde_json::from_str::(&text)
+ .expect("OBS envelope 파싱 실패");
+ if envelope.msg_type == expected_type {
+ return envelope;
+ }
+ }
+ Some(Ok(_)) => {}
+ Some(Err(error)) => panic!("WS 메시지 수신 실패: {error}"),
+ None => panic!("WS 연결이 예기치 않게 종료됨"),
+ }
+ }
+ })
+ .await
+ .expect("WS 메시지 수신 타임아웃")
+ }
+
+ async fn connect_authenticated(port: u16, token: &str) -> TestWebSocket {
+ let (mut ws, _) = connect_async(format!("ws://127.0.0.1:{port}"))
+ .await
+ .expect("WS 연결 실패");
+ let hello = make_envelope(
+ "hello",
+ 0,
+ serde_json::json!({ "token": token, "protocol": OBS_PROTOCOL_VERSION }),
+ );
+ ws.send(Message::Text(hello.to_string()))
+ .await
+ .expect("hello 전송 실패");
+
+ receive_envelope(&mut ws, "hello_ack").await;
+ receive_envelope(&mut ws, "snapshot").await;
+ ws
+ }
+
+ #[test]
+ fn websocket_allowlist_uses_exact_matching() {
+ assert_eq!(ALLOWED_WS_COMMANDS.len(), 30);
+ assert!(is_allowed_command("app_bootstrap"));
+ assert!(is_allowed_command("plugin_storage_clear_by_prefix"));
+ assert!(!is_allowed_command("settings_update"));
+ assert!(!is_allowed_command("app_bootstrap_extra"));
+ assert!(!is_allowed_command("plugin:window|close"));
+ assert_eq!(build_allowed_list().len(), ALLOWED_WS_COMMANDS.len());
+ }
+
+ #[test]
+ fn host_header_allows_only_ip_literals_and_localhost() {
+ for allowed in [
+ "localhost",
+ "LOCALHOST:34891",
+ "127.0.0.1",
+ "127.0.0.1:34891",
+ "192.168.0.10:80",
+ "::1",
+ "[::1]",
+ "[2001:db8::1]:34891",
+ ] {
+ assert!(is_allowed_host_header(allowed), "{allowed}");
+ }
+
+ for rejected in [
+ "",
+ "example.com",
+ "example.com:34891",
+ "localhost.example.com",
+ "localhost:invalid",
+ "[localhost]:34891",
+ "127.0.0.1:99999",
+ ] {
+ assert!(!is_allowed_host_header(rejected), "{rejected}");
+ }
+ }
+
+ #[test]
+ fn http_host_validation_rejects_missing_or_duplicate_headers() {
+ assert!(has_allowed_http_host(
+ "GET / HTTP/1.1\r\nHost: localhost:34891\r\n\r\n"
+ ));
+ assert!(!has_allowed_http_host("GET / HTTP/1.1\r\n\r\n"));
+ assert!(!has_allowed_http_host(
+ "GET / HTTP/1.1\r\nHost: localhost\r\nHost: example.com\r\n\r\n"
+ ));
+ }
+
+ #[test]
+ fn websocket_origin_allows_absence_or_local_machine_hosts_only() {
+ let no_origin = WsRequest::builder()
+ .header(header::HOST, "127.0.0.1:34891")
+ .body(())
+ .unwrap();
+ assert!(validate_websocket_request(&no_origin).is_ok());
+
+ let local_origin = WsRequest::builder()
+ .header(header::HOST, "localhost:34891")
+ .header(header::ORIGIN, "http://[::1]:3400")
+ .body(())
+ .unwrap();
+ assert!(validate_websocket_request(&local_origin).is_ok());
+
+ // 이 머신에 할당된 LAN IP는 허용 (LAN 클라이언트가 접속에 쓰는 페이지 origin)
+ if let Ok(lan_ip) = local_ip_address::local_ip() {
+ let lan_origin = WsRequest::builder()
+ .header(header::HOST, format!("{lan_ip}:34891"))
+ .header(header::ORIGIN, format!("http://{lan_ip}:34891"))
+ .body(())
+ .unwrap();
+ assert!(validate_websocket_request(&lan_origin).is_ok());
+ }
+
+ let domain_origin = WsRequest::builder()
+ .header(header::HOST, "127.0.0.1:34891")
+ .header(header::ORIGIN, "https://example.com")
+ .body(())
+ .unwrap();
+ assert_eq!(
+ validate_websocket_request(&domain_origin),
+ Err("Invalid Origin header")
+ );
+
+ // 이 머신의 인터페이스가 아닌 임의 숫자 IP는 거부 (TEST-NET-3)
+ let foreign_ip_origin = WsRequest::builder()
+ .header(header::HOST, "127.0.0.1:34891")
+ .header(header::ORIGIN, "http://203.0.113.7")
+ .body(())
+ .unwrap();
+ assert_eq!(
+ validate_websocket_request(&foreign_ip_origin),
+ Err("Invalid Origin header")
+ );
+ }
+
+ async fn http_get(host: &str, port: u16, path: &str) -> String {
+ let mut stream = TcpStream::connect((host, port))
+ .await
+ .expect("TCP 연결 실패");
+ let request =
+ format!("GET {path} HTTP/1.1\r\nHost: {host}:{port}\r\nConnection: close\r\n\r\n");
+ stream
+ .write_all(request.as_bytes())
+ .await
+ .expect("요청 전송 실패");
+ let mut response = Vec::new();
+ stream
+ .read_to_end(&mut response)
+ .await
+ .expect("응답 수신 실패");
+ String::from_utf8_lossy(&response).into_owned()
+ }
+
+ #[test]
+ fn local_machine_ip_rejects_foreign_addresses() {
+ assert!(is_local_machine_ip(&"127.0.0.1".parse().unwrap()));
+ assert!(is_local_machine_ip(&"::1".parse().unwrap()));
+ // TEST-NET-3 — 로컬 인터페이스에 할당될 일 없는 주소
+ assert!(!is_local_machine_ip(&"203.0.113.7".parse().unwrap()));
+ if let Ok(lan_ip) = local_ip_address::local_ip() {
+ assert!(is_local_machine_ip(&lan_ip));
+ }
+ }
+
+ // dev 리다이렉트(token 쿼리 포함)는 이 머신 자신의 peer에만 허용 —
+ // 같은 PC가 자기 LAN IP로 접속하는 URL 복사 경로는 유지되어야 함
+ #[tokio::test]
+ async fn dev_redirect_serves_only_local_machine_peers() {
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ bridge.set_dev_url("http://localhost:3400".to_string());
+ let port = bridge
+ .start(0, "dev-token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+
+ // loopback peer → 기존 dev 부트스트랩(302 + token) 유지
+ let response = http_get("127.0.0.1", port, "/").await;
+ assert!(response.starts_with("HTTP/1.1 302"), "{response}");
+ assert!(response.contains("token=dev-token"), "{response}");
+
+ // 같은 머신의 LAN IP 경유 — peer도 로컬 인터페이스 IP이므로 유지되어야 함
+ if let Ok(lan_ip) = local_ip_address::local_ip() {
+ let response = http_get(&lan_ip.to_string(), port, "/").await;
+ assert!(
+ response.starts_with("HTTP/1.1 302"),
+ "같은 PC의 LAN IP 접속이 깨지면 안 됨: {response}"
+ );
+ }
+
+ bridge.stop();
+ }
+
+ // Game Bar 엔드포인트 제거 검증 — 어떤 경로도 무인증 HTTP 응답으로 토큰을 내주면 안 됨
+ #[tokio::test]
+ async fn gamebar_paths_no_longer_leak_token() {
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ let port = bridge
+ .start(0, "secret-token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+
+ for path in ["/gamebar", "/gamebar/bootstrap.json"] {
+ let mut stream = TcpStream::connect(("127.0.0.1", port))
+ .await
+ .expect("TCP 연결 실패");
+ let request =
+ format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n");
+ stream
+ .write_all(request.as_bytes())
+ .await
+ .expect("요청 전송 실패");
+ let mut response = Vec::new();
+ stream
+ .read_to_end(&mut response)
+ .await
+ .expect("응답 수신 실패");
+ let response = String::from_utf8_lossy(&response);
+ assert!(
+ !response.contains("secret-token"),
+ "{path} 응답에 토큰 노출: {response}"
+ );
+ }
+
+ bridge.stop();
+ }
+
+ // dev 모드에서도 /media는 Vite 리다이렉트가 아니라 브릿지가 직접 처리해야 함
+ #[tokio::test]
+ async fn media_requests_bypass_dev_redirect() {
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ bridge.set_dev_url("http://localhost:3400".to_string());
+ let port = bridge
+ .start(0, "media-token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+
+ let mut stream = TcpStream::connect(("127.0.0.1", port))
+ .await
+ .expect("TCP 연결 실패");
+ stream
+ .write_all(
+ b"GET /media/abc?token=wrong HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n",
+ )
+ .await
+ .expect("요청 전송 실패");
+ let mut response = Vec::new();
+ stream
+ .read_to_end(&mut response)
+ .await
+ .expect("응답 수신 실패");
+ let response = String::from_utf8_lossy(&response);
+ assert!(
+ response.starts_with("HTTP/1.1 403"),
+ "302 리다이렉트가 아닌 미디어 핸들러 403이어야 함: {response}"
+ );
+
+ bridge.stop();
+ }
+
+ #[tokio::test]
+ async fn protocol_mismatch_is_rejected_before_auth() {
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ let port = bridge
+ .start(0, "token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+
+ let (mut ws, _) = connect_async(format!("ws://127.0.0.1:{port}"))
+ .await
+ .expect("WS 연결 실패");
+ // 올바른 토큰이라도 프로토콜 버전이 다르면 거부되어야 함
+ let hello = serde_json::json!({
+ "v": 999,
+ "type": "hello",
+ "seq": 0,
+ "payload": { "token": "token", "protocol": 999 },
+ });
+ ws.send(Message::Text(hello.to_string()))
+ .await
+ .expect("hello 전송 실패");
+
+ let error = receive_envelope(&mut ws, "error").await;
+ assert_eq!(
+ error.payload.get("code").and_then(Value::as_str),
+ Some("PROTOCOL_MISMATCH")
+ );
+
+ bridge.stop();
+ }
+
+ #[test]
+ fn binding_listens_on_all_interfaces_for_lan_access() {
+ assert!(bind_address(34891).ip().is_unspecified());
+ assert_eq!(bind_address(34891).port(), 34891);
+ }
+
+ // 같은 네트워크의 다른 PC 접속은 제품 계약 — LAN IP 경유 인증 접속이 실제로 성립해야 함
+ #[tokio::test]
+ async fn lan_address_accepts_authenticated_clients() {
+ let Ok(lan_ip) = local_ip_address::local_ip() else {
+ eprintln!("LAN IP 조회 불가 환경, 테스트 스킵");
+ return;
+ };
+
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ bridge.update_snapshot(serde_json::json!({ "source": "lan" }));
+ let port = bridge
+ .start(0, "lan-token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+
+ assert_eq!(bridge.status().local_ip, Some(lan_ip.to_string()));
+
+ let (mut ws, _) = connect_async(format!("ws://{lan_ip}:{port}"))
+ .await
+ .expect("LAN IP로 WS 연결 실패");
+ let hello = make_envelope(
+ "hello",
+ 0,
+ serde_json::json!({ "token": "lan-token", "protocol": OBS_PROTOCOL_VERSION }),
+ );
+ ws.send(Message::Text(hello.to_string()))
+ .await
+ .expect("hello 전송 실패");
+ receive_envelope(&mut ws, "hello_ack").await;
+ let snapshot = receive_envelope(&mut ws, "snapshot").await;
+ assert_eq!(snapshot.payload, serde_json::json!({ "source": "lan" }));
+
+ bridge.stop();
+ }
+
+ #[tokio::test]
+ async fn token_rotation_disconnects_existing_sessions_and_keeps_server_running() {
+ let bridge = Arc::new(ObsBridgeService::new("test"));
+ bridge.update_snapshot(serde_json::json!({ "source": "initial" }));
+ let port = bridge
+ .start(0, "old-token".to_string())
+ .await
+ .expect("OBS bridge 시작 실패");
+ let mut old_ws = connect_authenticated(port, "old-token").await;
+
+ bridge.set_token("new-token".to_string());
+ assert!(bridge.is_running());
+ assert_eq!(bridge.status().port, port);
+
+ let resync = make_envelope("resync_request", 1, Value::Null);
+ let _ = old_ws.send(Message::Text(resync.to_string())).await;
+ bridge.broadcast_tauri_event(
+ "token-rotation-test".to_string(),
+ serde_json::json!({ "authenticated": false }),
+ );
+
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ match old_ws.next().await {
+ Some(Ok(Message::Text(text))) => {
+ let envelope: ObsEnvelope =
+ serde_json::from_str(&text).expect("OBS envelope 파싱 실패");
+ assert_ne!(envelope.msg_type, "snapshot");
+ if envelope.msg_type == "tauri_event" {
+ assert_ne!(
+ envelope.payload.get("event").and_then(Value::as_str),
+ Some("token-rotation-test")
+ );
+ }
+ }
+ Some(Ok(Message::Close(_))) | Some(Err(_)) | None => break,
+ Some(Ok(_)) => {}
+ }
+ }
+ })
+ .await
+ .expect("구 토큰 세션이 종료되지 않음");
+
+ let mut new_ws = connect_authenticated(port, "new-token").await;
+ bridge.broadcast_tauri_event(
+ "token-rotation-test".to_string(),
+ serde_json::json!({ "authenticated": true }),
+ );
+ let event = receive_envelope(&mut new_ws, "tauri_event").await;
+ assert_eq!(
+ event.payload,
+ serde_json::json!({
+ "event": "token-rotation-test",
+ "data": { "authenticated": true }
+ })
+ );
+
+ bridge.stop();
+ }
+}
diff --git a/src-tauri/src/services/settings.rs b/src-tauri/src/services/settings.rs
index 104322d5..ea73f164 100644
--- a/src-tauri/src/services/settings.rs
+++ b/src-tauri/src/services/settings.rs
@@ -1,10 +1,11 @@
use std::sync::Arc;
-use anyhow::Result;
+use anyhow::{Context, Result};
use crate::models::{
- CustomCss, CustomCssPatch, CustomJs, CustomJsPatch, FontType, NoteSettings, NoteSettingsPatch,
- SettingsDiff, SettingsPatch, SettingsPatchInput, SettingsState, ShortcutsState,
+ AppStoreData, CustomCss, CustomCssPatch, CustomJs, CustomJsPatch, FontType, NoteSettings,
+ NoteSettingsPatch, SettingsDiff, SettingsPatch, SettingsPatchInput, SettingsState,
+ ShortcutsState,
};
use crate::state::AppStore;
@@ -23,39 +24,78 @@ impl SettingsService {
}
pub fn apply_patch(&self, patch: SettingsPatchInput) -> Result {
- let current = self.snapshot();
- let normalized = normalize_patch(&patch, ¤t);
- let next = apply_changes(current.clone(), &normalized);
-
+ let mut diff = None;
self.store.update(|state| {
- state.hardware_acceleration = next.hardware_acceleration;
- state.always_on_top = next.always_on_top;
- state.overlay_locked = next.overlay_locked;
- state.note_effect = next.note_effect;
- state.note_settings = next.note_settings.clone();
- state.angle_mode = next.angle_mode.clone();
- state.language = next.language.clone();
- state.laboratory_enabled = next.laboratory_enabled;
- state.developer_mode_enabled = next.developer_mode_enabled;
- state.tray_enabled = next.tray_enabled;
- state.auto_update_enabled = next.auto_update_enabled;
- state.background_color = next.background_color.clone();
- state.use_custom_css = next.use_custom_css;
- state.custom_css = next.custom_css.clone();
- state.font_settings = next.font_settings.clone();
- state.use_custom_js = next.use_custom_js;
- state.custom_js = next.custom_js.clone();
- state.overlay_resize_anchor = next.overlay_resize_anchor.clone();
- state.key_counter_enabled = next.key_counter_enabled;
- state.grid_settings = next.grid_settings.clone();
- state.shortcuts = next.shortcuts.clone();
- state.obs_mode_enabled = next.obs_mode_enabled;
+ diff = Some(apply_patch_to_store(state, &patch));
})?;
+ diff.context("settings patch did not produce a diff")
+ }
+}
+
+pub(crate) fn settings_from_store(store: &AppStoreData) -> SettingsState {
+ let mut custom_js = store.custom_js.clone();
+ let _ = custom_js.normalize();
+
+ SettingsState {
+ hardware_acceleration: store.hardware_acceleration,
+ always_on_top: store.always_on_top,
+ overlay_locked: store.overlay_locked,
+ note_effect: store.note_effect,
+ note_settings: store.note_settings.clone(),
+ angle_mode: store.angle_mode.clone(),
+ language: store.language.clone(),
+ laboratory_enabled: store.laboratory_enabled,
+ developer_mode_enabled: store.developer_mode_enabled,
+ tray_enabled: store.tray_enabled,
+ auto_update_enabled: store.auto_update_enabled,
+ background_color: store.background_color.clone(),
+ use_custom_css: store.use_custom_css,
+ custom_css: store.custom_css.clone(),
+ font_settings: store.font_settings.clone(),
+ use_custom_js: store.use_custom_js,
+ custom_js,
+ overlay_resize_anchor: store.overlay_resize_anchor.clone(),
+ key_counter_enabled: store.key_counter_enabled,
+ grid_settings: store.grid_settings.clone(),
+ shortcuts: store.shortcuts.clone(),
+ obs_mode_enabled: store.obs_mode_enabled,
+ }
+}
+
+pub(crate) fn apply_patch_to_store(
+ store: &mut AppStoreData,
+ patch: &SettingsPatchInput,
+) -> SettingsDiff {
+ let current = settings_from_store(store);
+ let normalized = normalize_patch(patch, ¤t);
+ let next = apply_changes(current, &normalized);
+
+ store.hardware_acceleration = next.hardware_acceleration;
+ store.always_on_top = next.always_on_top;
+ store.overlay_locked = next.overlay_locked;
+ store.note_effect = next.note_effect;
+ store.note_settings = next.note_settings.clone();
+ store.angle_mode = next.angle_mode.clone();
+ store.language = next.language.clone();
+ store.laboratory_enabled = next.laboratory_enabled;
+ store.developer_mode_enabled = next.developer_mode_enabled;
+ store.tray_enabled = next.tray_enabled;
+ store.auto_update_enabled = next.auto_update_enabled;
+ store.background_color = next.background_color.clone();
+ store.use_custom_css = next.use_custom_css;
+ store.custom_css = next.custom_css.clone();
+ store.font_settings = next.font_settings.clone();
+ store.use_custom_js = next.use_custom_js;
+ store.custom_js = next.custom_js.clone();
+ store.overlay_resize_anchor = next.overlay_resize_anchor.clone();
+ store.key_counter_enabled = next.key_counter_enabled;
+ store.grid_settings = next.grid_settings.clone();
+ store.shortcuts = next.shortcuts.clone();
+ store.obs_mode_enabled = next.obs_mode_enabled;
- Ok(SettingsDiff {
- changed: normalized,
- full: Some(next),
- })
+ SettingsDiff {
+ changed: normalized,
+ full: Some(next),
}
}
diff --git a/src-tauri/src/state/app_state.rs b/src-tauri/src/state/app_state.rs
index 0f1b3eae..3c287d27 100644
--- a/src-tauri/src/state/app_state.rs
+++ b/src-tauri/src/state/app_state.rs
@@ -1,10 +1,9 @@
use std::time::Instant;
use std::{
- collections::HashSet,
io::{BufRead, BufReader},
- process::{Child, Command, Stdio},
+ process::{Child, ChildStdin, Command, Stdio},
sync::{
- atomic::{AtomicBool, Ordering},
+ atomic::{AtomicBool, AtomicU64, Ordering},
Arc,
},
thread::{self, JoinHandle},
@@ -47,6 +46,15 @@ const TRAY_MENU_QUIT_ID: &str = "tray-quit";
const DEFAULT_OVERLAY_WIDTH: f64 = 860.0;
const DEFAULT_OVERLAY_HEIGHT: f64 = 320.0;
const OVERLAY_MARGIN: f64 = 40.0;
+const OVERLAY_BOUNDS_DEBOUNCE_MS: u64 = 400;
+
+fn should_create_overlay_on_startup(obs_mode_enabled: bool, overlay_visible: bool) -> bool {
+ !obs_mode_enabled && overlay_visible
+}
+
+fn bootstrap_active_keys(keyboard: &KeyboardManager) -> Vec {
+ keyboard.pressed_keys()
+}
pub struct AppState {
pub store: Arc,
@@ -56,10 +64,10 @@ pub struct AppState {
overlay_force_close: Arc,
/// 오버레이 윈도우 초기화 중 Moved/Resized 이벤트에서 bounds 저장 억제
overlay_initializing: Arc,
+ overlay_bounds_generation: Arc,
keyboard_task: RwLock>,
key_counters: Arc>,
key_counter_enabled: Arc,
- active_keys: Arc>>,
/// Raw input stream subscriber count - emit only when > 0
raw_input_subscribers: Arc,
key_sound: Arc,
@@ -69,20 +77,24 @@ pub struct AppState {
pub obs_bridge: Arc,
/// OBS 모드 시작 전 오버레이 가시성 상태 (복원용)
obs_previous_overlay_visible: Arc>>,
+ shutdown_started: AtomicBool,
}
impl AppState {
pub fn initialize(store: AppStore) -> Result {
+ if let Err(err) = store.recover_interrupted_processed_wav_replacements_now() {
+ log::warn!("failed to recover interrupted processed WAVs during startup: {err}");
+ }
let store = Arc::new(store);
let snapshot = store.snapshot();
let keyboard =
KeyboardManager::new(snapshot.keys.clone(), snapshot.selected_key_type.clone());
let settings = SettingsService::new(store.clone());
- let key_counters = Arc::new(RwLock::new(snapshot.key_counters.clone()));
- Self::sync_counters_with_keys_impl(&key_counters, &snapshot.keys);
+ let mut initial_key_counters = snapshot.key_counters.clone();
+ Self::sync_counters_with_keys_impl(&mut initial_key_counters, &snapshot.keys);
+ let key_counters = Arc::new(RwLock::new(initial_key_counters));
let key_counter_enabled = Arc::new(AtomicBool::new(snapshot.key_counter_enabled));
- let active_keys = Arc::new(RwLock::new(HashSet::new()));
// 저장된 출력 백엔드로 엔진을 처음부터 초기화 → "기본 장치 → ASIO" 전환 깜빡임 제거.
let initial_backend = snapshot
.key_sound_output_backend
@@ -99,23 +111,23 @@ impl AppState {
overlay_visible: Arc::new(RwLock::new(false)),
overlay_force_close: Arc::new(AtomicBool::new(false)),
overlay_initializing: Arc::new(AtomicBool::new(false)),
+ overlay_bounds_generation: Arc::new(AtomicU64::new(0)),
keyboard_task: RwLock::new(None),
key_counters,
key_counter_enabled,
- active_keys,
raw_input_subscribers: Arc::new(std::sync::atomic::AtomicU32::new(0)),
key_sound,
css_watcher: RwLock::new(None),
obs_bridge,
obs_previous_overlay_visible: Arc::new(RwLock::new(None)),
+ shutdown_started: AtomicBool::new(false),
})
}
pub fn initialize_runtime(&self, app: &AppHandle) -> Result<()> {
self.attach_main_window_handlers(app);
let snapshot = self.store.snapshot();
- // OBS 모드가 활성화된 상태로 부팅하면 오버레이 생성 건너뛰기 (create→destroy 낭비 방지)
- if !snapshot.obs_mode_enabled {
+ if should_create_overlay_on_startup(snapshot.obs_mode_enabled, snapshot.overlay_visible) {
self.ensure_overlay_window(app)?;
}
// 개발자 모드가 켜져 있으면 시작 시 DevTools 오픈 허용 및 자동 오픈 시도
@@ -161,6 +173,29 @@ impl AppState {
});
}
+ pub fn show_main_window(&self, app: &AppHandle) -> Result<()> {
+ let app_handle = app.clone();
+ app.run_on_main_thread(move || {
+ let state = app_handle.state::();
+ if let Err(err) = state.show_main_window_inner(&app_handle) {
+ log::warn!("failed to show main window: {err}");
+ }
+ })?;
+ Ok(())
+ }
+
+ fn show_main_window_inner(&self, app: &AppHandle) -> Result<()> {
+ if let Some(main) = app.get_webview_window("main") {
+ let _ = main.unminimize();
+ main.show()?;
+ let _ = main.set_focus();
+ }
+
+ remove_tray_icon(app);
+ self.set_main_window_hidden(false)?;
+ Ok(())
+ }
+
pub fn ensure_tray_icon_for_background(&self, app: &AppHandle) -> Result<()> {
if app.tray_by_id(TRAY_ICON_ID).is_some() {
return Ok(());
@@ -195,14 +230,16 @@ impl AppState {
..
} = event
{
- if let Err(err) = show_main_window(tray.app_handle()) {
+ let state = tray.app_handle().state::();
+ if let Err(err) = state.show_main_window(tray.app_handle()) {
log::error!("failed to show main window from tray click: {err}");
}
}
})
.on_menu_event(move |app_handle, event| {
if event.id() == TRAY_MENU_SETTINGS_ID {
- if let Err(err) = show_main_window(app_handle) {
+ let state = app_handle.state::();
+ if let Err(err) = state.show_main_window(app_handle) {
log::error!("failed to show main window from tray: {err}");
}
return;
@@ -222,6 +259,13 @@ impl AppState {
}
pub fn set_main_window_hidden(&self, hidden: bool) -> Result<()> {
+ // 값이 그대로면 저장 생략 — 기동마다 전체 store 재기록(fsync) 방지
+ if self
+ .store
+ .with_state(|state| state.main_window_hidden == hidden)
+ {
+ return Ok(());
+ }
let _ = self.store.update(|state| {
state.main_window_hidden = hidden;
})?;
@@ -269,6 +313,7 @@ impl AppState {
custom_tabs: state.custom_tabs.clone(),
selected_key_type: state.selected_key_type.clone(),
current_mode: self.keyboard.current_mode(),
+ active_keys: bootstrap_active_keys(&self.keyboard),
overlay: BootstrapOverlayState {
visible: *self.overlay_visible.read(),
locked: state.overlay_locked,
@@ -313,21 +358,50 @@ impl AppState {
Ok(())
}
+ /// 저장된 토큰 재사용 또는 신규 생성 후 store에 저장
+ /// 기존 토큰은 commit-after-persist로 디스크 저장이 보장되므로 재저장 생략
+ pub fn resolve_and_save_obs_token(&self) -> Result {
+ if let Some(token) = self
+ .store
+ .with_state(|s| s.obs_token.clone())
+ .filter(|token| !token.is_empty())
+ {
+ return Ok(token);
+ }
+
+ let token = uuid::Uuid::new_v4().simple().to_string();
+ let t = token.clone();
+ self.store.update(|s| {
+ s.obs_token = Some(t.clone());
+ })?;
+ Ok(token)
+ }
+
/// 부팅 시 OBS 모드 자동 시작 (obs_mode_enabled=true일 때)
fn auto_start_obs(&self, app: &AppHandle) {
let bridge = self.obs_bridge.clone();
let store = self.store.clone();
- let (port, existing_token) = store.with_state(|s| (s.obs_port, s.obs_token.clone()));
- // 저장된 토큰 재사용 또는 신규 생성
- let token = match existing_token {
- Some(t) if !t.is_empty() => t,
- _ => {
- let t = uuid::Uuid::new_v4().simple().to_string();
- let tc = t.clone();
+ let port = store.with_state(|s| s.obs_port);
+
+ // 부팅 시에는 오버레이를 생성하지 않았으므로 이전 표시 상태만 저장
+ // (initialize_runtime에서 obs_mode_enabled일 때 ensure_overlay_window 건너뜀)
+ let was_visible = store.with_state(|s| s.overlay_visible);
+ *self.obs_previous_overlay_visible.write() = Some(was_visible);
+
+ // 저장 안 된 토큰으로 서버를 켜면 재부팅 후 기존 URL이 무효화되므로 시작 중단
+ let token = match self.resolve_and_save_obs_token() {
+ Ok(token) => token,
+ Err(e) => {
+ log::error!(
+ "[ObsBridge] auto-start 중단: 토큰 저장 실패 ({}) — obs_mode_enabled를 false로 복구",
+ e
+ );
let _ = store.update(|s| {
- s.obs_token = Some(tc.clone());
+ s.obs_mode_enabled = false;
});
- t
+ self.obs_restore_overlay(app);
+ let _ = app.emit("obs:status", &self.obs_bridge.status());
+ return;
}
};
let app_handle = app.clone();
@@ -355,11 +429,6 @@ impl AppState {
// Tauri 이벤트 → OBS WS 포워딩 리스너 등록
bridge.register_event_forwarding(app);
- // 부팅 시에는 오버레이를 생성하지 않았으므로 상태만 저장
- // (initialize_runtime에서 obs_mode_enabled일 때 ensure_overlay_window 건너뜀)
- let was_visible = self.store.with_state(|s| s.overlay_visible);
- *self.obs_previous_overlay_visible.write() = Some(was_visible);
-
// async start를 tokio 런타임에서 실행
tauri::async_runtime::spawn(async move {
match bridge.start(port, token).await {
@@ -481,6 +550,13 @@ impl AppState {
pub fn set_overlay_visibility(&self, app: &AppHandle, visible: bool) -> Result<()> {
log::debug!("[IPC] set_overlay_visibility: visible={}", visible);
+ if !visible {
+ flush_deferred_overlay_bounds(&self.store, &self.overlay_bounds_generation)?;
+ }
+ self.store.update(|state| {
+ state.overlay_visible = visible;
+ })?;
+
if visible {
// 오버레이를 열 때: 창이 없으면 생성하고 표시
let window = self.ensure_overlay_window(app)?;
@@ -501,11 +577,6 @@ impl AppState {
}
*self.overlay_visible.write() = visible;
- if let Err(err) = self.store.update(|state| {
- state.overlay_visible = visible;
- }) {
- log::warn!("failed to persist overlay visibility: {err}");
- }
app.emit("overlay:visibility", &json!({ "visible": visible }))?;
Ok(())
}
@@ -535,19 +606,23 @@ impl AppState {
}
pub fn shutdown(&self) {
- if let Err(err) = self.persist_key_counters() {
- log::warn!("failed to persist key counters during shutdown: {err}");
- }
- if let Err(err) = self.store.cleanup_orphan_assets_now() {
- log::warn!("failed to cleanup orphan assets during shutdown: {err}");
+ if self.shutdown_started.swap(true, Ordering::SeqCst) {
+ return;
}
+ self.overlay_bounds_generation
+ .fetch_add(1, Ordering::SeqCst);
if let Some(task) = self.keyboard_task.write().take() {
drop(task);
}
- // CSS 워처 정리
if let Some(watcher) = self.css_watcher.write().take() {
watcher.shutdown();
}
+ if let Err(err) = self.persist_key_counters() {
+ log::warn!("failed to persist key counters during shutdown: {err}");
+ }
+ if let Err(err) = self.store.flush_cleanup_and_shutdown() {
+ log::warn!("failed to finalize store during shutdown: {err:#}");
+ }
}
pub fn request_shutdown(&self, app_handle: AppHandle) {
@@ -603,6 +678,7 @@ impl AppState {
let mut new_x = position.x;
let mut new_y = position.y;
+ let mut next_content_top_offset = None;
// 초기화 중(첫 resize)에는 anchor 기반 position 재계산을 건너뛰고
// store에 저장된 위치를 사용 (빌더 position이 무시될 수 있으므로)
@@ -616,9 +692,7 @@ impl AppState {
// 초기화 중이라도 content_top_offset은 저장해야 다음 resize에서 delta 계산이 정확함
if let Some(offset) = content_top_offset {
if offset.is_finite() {
- let _ = self.store.update(|state| {
- state.overlay_last_content_top_offset = Some(offset);
- })?;
+ next_content_top_offset = Some(offset);
}
}
} else {
@@ -662,9 +736,7 @@ impl AppState {
_ => new_y -= delta,
}
}
- let _ = self.store.update(|state| {
- state.overlay_last_content_top_offset = Some(offset);
- })?;
+ next_content_top_offset = Some(offset);
}
}
}
@@ -679,10 +751,12 @@ impl AppState {
height,
};
- let _ = self.store.update(|state| {
- state.overlay_bounds = Some(bounds.clone());
- state.overlay_bounds_are_logical = true;
- })?;
+ defer_overlay_bounds(
+ &self.store,
+ &self.overlay_bounds_generation,
+ bounds.clone(),
+ next_content_top_offset,
+ )?;
log::debug!(
"[IPC] resize_overlay: emit overlay:resized ({}x{} at {}, {})",
@@ -739,12 +813,16 @@ impl AppState {
let mut child = Command::new(current_exe)
.arg("--keyboard-daemon")
.env("DMNOTE_HOTKEYS_V1", shortcuts_json)
- .stdin(Stdio::null())
+ .stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.context("failed to spawn keyboard daemon process")?;
+ let parent_stdin = child
+ .stdin
+ .take()
+ .context("keyboard daemon stdin unavailable")?;
let stdout = child
.stdout
.take()
@@ -938,36 +1016,36 @@ impl AppState {
}
}
- let Some(key_label) =
- keyboard.match_candidate(message.labels.iter().map(|s| s.as_str()))
+ let is_down = state == "DOWN";
+ let Some((mode, key_label, state_changed)) = keyboard.match_and_register(
+ message.labels.iter().map(|s| s.as_str()),
+ is_down,
+ )
else {
continue;
};
- let mode = keyboard.current_mode();
- let state_changed = if state == "DOWN" {
- let changed = app_state.register_key_down(&mode, &key_label);
- if changed {
- if let Some(count) = app_state.increment_key_counter(&mode, &key_label) {
- log::trace!(
- "[IPC] emit keys:counter: mode={}, key={}, count={}",
- mode, key_label, count
- );
- if let Err(err) = app_handle.emit(
- "keys:counter",
- &json!({
- "mode": mode.clone(),
- "key": key_label.clone(),
- "count": count,
- }),
- ) {
- error!("failed to emit keys:counter event: {err}");
- }
+ if is_down && state_changed {
+ if let Some(count) =
+ app_state.increment_key_counter(&mode, &key_label)
+ {
+ log::trace!(
+ "[IPC] emit keys:counter: mode={}, key={}, count={}",
+ mode,
+ key_label,
+ count
+ );
+ if let Err(err) = app_handle.emit(
+ "keys:counter",
+ &json!({
+ "mode": mode.clone(),
+ "key": key_label.clone(),
+ "count": count,
+ }),
+ ) {
+ error!("failed to emit keys:counter event: {err}");
}
}
- changed
- } else {
- app_state.register_key_up(&mode, &key_label)
- };
+ }
if !state_changed {
continue;
}
@@ -1142,6 +1220,7 @@ impl AppState {
running,
reader_handle: Some(reader_handle),
stderr_handle,
+ parent_stdin: Some(parent_stdin),
child: Some(child),
});
Ok(())
@@ -1306,6 +1385,7 @@ impl AppState {
let overlay_window = window.clone();
let force_close_flag = self.overlay_force_close.clone();
let initializing_flag = self.overlay_initializing.clone();
+ let bounds_generation = self.overlay_bounds_generation.clone();
window.on_window_event(move |event| match event {
WindowEvent::CloseRequested { api, .. } => {
@@ -1314,15 +1394,23 @@ impl AppState {
*overlay_visible.write() = false;
} else {
api.prevent_close();
- if let Err(err) = overlay_window.hide() {
- log::error!("failed to hide overlay window on close: {err}");
+ if let Err(err) =
+ flush_deferred_overlay_bounds(&store, &bounds_generation)
+ {
+ log::warn!("failed to flush overlay bounds on close: {err}");
+ return;
}
- *overlay_visible.write() = false;
if let Err(err) = store.update(|state| {
state.overlay_visible = false;
}) {
log::warn!("failed to persist overlay visibility on close: {err}");
+ return;
+ }
+ if let Err(err) = overlay_window.hide() {
+ log::error!("failed to hide overlay window on close: {err}");
+ return;
}
+ *overlay_visible.write() = false;
if let Err(err) =
app_handle.emit("overlay:visibility", &json!({ "visible": false }))
{
@@ -1345,8 +1433,12 @@ impl AppState {
WindowEvent::Moved(_) | WindowEvent::Resized(_)
// 윈도우 초기화 중에는 OS가 보고하는 좌표로 저장된 bounds를 덮어쓰지 않음
if !initializing_flag.load(Ordering::SeqCst) => {
- if let Err(err) = persist_overlay_bounds(&overlay_window, &store) {
- log::warn!("failed to persist overlay bounds: {err}");
+ if let Err(err) = defer_overlay_bounds_from_window(
+ &overlay_window,
+ &store,
+ &bounds_generation,
+ ) {
+ log::warn!("failed to defer overlay bounds: {err}");
}
}
_ => {}
@@ -1458,7 +1550,7 @@ impl AppState {
if let Some(enabled) = diff.changed.tray_enabled {
if !enabled {
- let _ = app.remove_tray_by_id(TRAY_ICON_ID);
+ dispatch_remove_tray_icon(app)?;
if let Err(err) = self.set_main_window_hidden(false) {
log::warn!(
"failed to clear main_window_hidden when disabling tray mode: {err}"
@@ -1495,14 +1587,23 @@ impl AppState {
self.key_counters.read().clone()
}
- pub fn reset_key_counters(&self) -> KeyCounters {
- let mut counters = self.key_counters.write();
- for mode_entry in counters.values_mut() {
- for value in mode_entry.values_mut() {
- *value = 0;
+ fn update_key_counters(&self, updater: impl FnOnce(&mut KeyCounters)) -> Result {
+ let mut guard = self.key_counters.write();
+ let mut scratch = guard.clone();
+ updater(&mut scratch);
+ let persisted = self.store.set_key_counters(scratch)?;
+ *guard = persisted.clone();
+ Ok(persisted)
+ }
+
+ pub fn reset_key_counters(&self) -> Result {
+ self.update_key_counters(|counters| {
+ for mode_entry in counters.values_mut() {
+ for value in mode_entry.values_mut() {
+ *value = 0;
+ }
}
- }
- counters.clone()
+ })
}
pub fn replace_key_counters(
@@ -1510,58 +1611,38 @@ impl AppState {
counters: KeyCounters,
keys: &KeyMappings,
) -> Result {
- {
- let mut guard = self.key_counters.write();
- *guard = counters;
- }
- self.sync_counters_with_keys(keys);
- self.persist_key_counters()
+ self.update_key_counters(|scratch| {
+ *scratch = counters;
+ Self::sync_counters_with_keys_impl(scratch, keys);
+ })
}
- pub fn reset_mode_counters(&self, mode: &str) {
- let mut counters = self.key_counters.write();
- if let Some(entry) = counters.get_mut(mode) {
- for value in entry.values_mut() {
- *value = 0;
+ pub fn reset_mode_counters(&self, mode: &str) -> Result {
+ self.update_key_counters(|counters| {
+ if let Some(entry) = counters.get_mut(mode) {
+ for value in entry.values_mut() {
+ *value = 0;
+ }
}
- }
+ })
}
- pub fn reset_single_key_counter(&self, mode: &str, key: &str) {
- let mut counters = self.key_counters.write();
- if let Some(entry) = counters.get_mut(mode) {
- if let Some(value) = entry.get_mut(key) {
- *value = 0;
+ pub fn reset_single_key_counter(&self, mode: &str, key: &str) -> Result {
+ self.update_key_counters(|counters| {
+ if let Some(entry) = counters.get_mut(mode) {
+ if let Some(value) = entry.get_mut(key) {
+ *value = 0;
+ }
}
- }
- }
-
- pub fn register_key_down(&self, mode: &str, key: &str) -> bool {
- let mut guard = self.active_keys.write();
- guard.insert(Self::compose_active_key(mode, key))
+ })
}
- pub fn register_key_up(&self, mode: &str, key: &str) -> bool {
- let mut guard = self.active_keys.write();
- guard.remove(&Self::compose_active_key(mode, key))
+ pub fn clear_active_keys(&self) {
+ self.keyboard.clear_active_keys();
}
- pub fn clear_active_keys(&self) {
- self.active_keys.write().clear();
- }
-
- /// 모드 전환 시 active_keys의 prefix를 새 모드로 교체
- pub fn transfer_active_keys(&self, new_mode: &str) {
- let mut guard = self.active_keys.write();
- let transferred: HashSet = guard
- .drain()
- .filter_map(|entry| {
- entry
- .split_once("::")
- .map(|(_, key)| Self::compose_active_key(new_mode, key))
- })
- .collect();
- *guard = transferred;
+ pub(crate) fn commit_key_counters_mirror(&self, counters: KeyCounters) {
+ *self.key_counters.write() = counters;
}
pub fn persist_key_counters(&self) -> Result {
@@ -1571,14 +1652,14 @@ impl AppState {
}
pub fn sync_counters_with_keys(&self, keys: &KeyMappings) {
- Self::sync_counters_with_keys_impl(&self.key_counters, keys);
+ let mut guard = self.key_counters.write();
+ Self::sync_counters_with_keys_impl(&mut guard, keys);
}
- fn sync_counters_with_keys_impl(target: &Arc>, keys: &KeyMappings) {
- let mut guard = target.write();
- guard.retain(|mode, _| keys.contains_key(mode));
+ fn sync_counters_with_keys_impl(target: &mut KeyCounters, keys: &KeyMappings) {
+ target.retain(|mode, _| keys.contains_key(mode));
for (mode, key_list) in keys.iter() {
- let entry = guard.entry(mode.clone()).or_default();
+ let entry = target.entry(mode.clone()).or_default();
entry.retain(|key, _| key_list.contains(key));
for key in key_list.iter() {
entry.entry(key.clone()).or_insert(0);
@@ -1586,10 +1667,6 @@ impl AppState {
}
}
- fn compose_active_key(mode: &str, key: &str) -> String {
- format!("{}::{}", mode, key)
- }
-
/// Subscribe to raw input stream (increment subscriber count)
pub fn subscribe_raw_input(&self) -> u32 {
self.raw_input_subscribers.fetch_add(1, Ordering::SeqCst) + 1
@@ -1635,15 +1712,21 @@ impl AppState {
pub fn key_sound_set_output_backend(
&self,
backend: KeySoundOutputBackend,
- ) -> KeySoundOutputState {
- let output_state = self.key_sound.set_output_backend(backend);
- let requested = output_state.requested.clone();
- if let Err(err) = self.store.update(|state| {
- state.key_sound_output_backend = Some(output_backend_to_persist(requested.clone()));
- }) {
- warn!("[KeySound] failed to persist output backend: {err}");
- }
- output_state
+ ) -> Result {
+ let requested = match &backend {
+ KeySoundOutputBackend::DefaultDevice => KeySoundOutputBackend::DefaultDevice,
+ KeySoundOutputBackend::Asio {
+ driver_name,
+ buffer_size,
+ } => KeySoundOutputBackend::Asio {
+ driver_name: driver_name.trim().to_string(),
+ buffer_size: buffer_size.filter(|size| *size > 0),
+ },
+ };
+ self.store.update(|state| {
+ state.key_sound_output_backend = Some(output_backend_to_persist(requested));
+ })?;
+ Ok(self.key_sound.set_output_backend(backend))
}
pub fn key_sound_get_output_state(&self) -> KeySoundOutputState {
@@ -1845,19 +1928,13 @@ fn tray_menu_labels(_language: &str) -> (&'static str, &'static str) {
("Settings", "Quit")
}
-fn show_main_window(app_handle: &AppHandle) -> Result<()> {
- if let Some(main) = app_handle.get_webview_window("main") {
- let _ = main.unminimize();
- main.show()?;
- let _ = main.set_focus();
- }
-
- if app_handle.tray_by_id(TRAY_ICON_ID).is_some() {
- let _ = app_handle.remove_tray_by_id(TRAY_ICON_ID);
- }
+fn remove_tray_icon(app: &AppHandle) {
+ let _ = app.remove_tray_by_id(TRAY_ICON_ID);
+}
- let state = app_handle.state::();
- state.set_main_window_hidden(false)?;
+fn dispatch_remove_tray_icon(app: &AppHandle) -> Result<()> {
+ let app_handle = app.clone();
+ app.run_on_main_thread(move || remove_tray_icon(&app_handle))?;
Ok(())
}
@@ -1881,15 +1958,20 @@ fn shutdown_application(app_handle: AppHandle, overlay_force_close: Arc Result<()> {
@@ -2220,35 +2302,75 @@ impl MonitorData {
}
}
-fn persist_overlay_bounds(window: &WebviewWindow, store: &Arc) -> Result<()> {
+fn defer_overlay_bounds_from_window(
+ window: &WebviewWindow,
+ store: &Arc,
+ generation: &Arc,
+) -> Result<()> {
let scale_factor = window.scale_factor().unwrap_or(1.0);
let position = window.outer_position()?.to_logical::(scale_factor);
let size = window.outer_size()?.to_logical::(scale_factor);
- let bounds = OverlayBounds {
- x: position.x,
- y: position.y,
- width: size.width,
- height: size.height,
- };
+ defer_overlay_bounds(
+ store,
+ generation,
+ OverlayBounds {
+ x: position.x,
+ y: position.y,
+ width: size.width,
+ height: size.height,
+ },
+ None,
+ )
+}
- let _ = store.update(|state| {
- state.overlay_bounds = Some(bounds.clone());
+fn defer_overlay_bounds(
+ store: &Arc,
+ generation: &Arc,
+ bounds: OverlayBounds,
+ content_top_offset: Option,
+) -> Result<()> {
+ store.update_deferred(move |state| {
+ state.overlay_bounds = Some(bounds);
state.overlay_bounds_are_logical = true;
+ if let Some(offset) = content_top_offset {
+ state.overlay_last_content_top_offset = Some(offset);
+ }
})?;
+ let scheduled_generation = generation.fetch_add(1, Ordering::SeqCst).wrapping_add(1);
+
+ let store = Arc::clone(store);
+ let generation = Arc::clone(generation);
+ tauri::async_runtime::spawn(async move {
+ tokio::time::sleep(Duration::from_millis(OVERLAY_BOUNDS_DEBOUNCE_MS)).await;
+ if generation.load(Ordering::SeqCst) != scheduled_generation {
+ return;
+ }
+ if let Err(err) = store.flush() {
+ log::warn!("failed to flush debounced overlay bounds: {err}");
+ }
+ });
+
Ok(())
}
+fn flush_deferred_overlay_bounds(store: &Arc, generation: &Arc) -> Result<()> {
+ generation.fetch_add(1, Ordering::SeqCst);
+ store.flush()
+}
+
struct KeyboardDaemonTask {
running: Arc,
reader_handle: Option>,
stderr_handle: Option>,
+ parent_stdin: Option,
child: Option,
}
impl Drop for KeyboardDaemonTask {
fn drop(&mut self) {
self.running.store(false, Ordering::SeqCst);
+ self.parent_stdin.take();
if let Some(child) = self.child.as_mut() {
if let Err(err) = child.kill() {
@@ -2274,3 +2396,30 @@ struct OverlayPosition {
x: f64,
y: f64,
}
+
+#[cfg(test)]
+mod tests {
+ use std::collections::HashMap;
+
+ use super::{bootstrap_active_keys, should_create_overlay_on_startup};
+ use crate::keyboard::KeyboardManager;
+
+ #[test]
+ fn startup_overlay_creation_covers_all_visibility_and_obs_combinations() {
+ assert!(!should_create_overlay_on_startup(false, false));
+ assert!(should_create_overlay_on_startup(false, true));
+ assert!(!should_create_overlay_on_startup(true, false));
+ assert!(!should_create_overlay_on_startup(true, true));
+ }
+
+ #[test]
+ fn bootstrap_active_keys_include_registered_event_key_names() {
+ let manager = KeyboardManager::new(
+ HashMap::from([("4key".to_string(), vec!["KeyD".to_string()])]),
+ "4key",
+ );
+
+ assert!(manager.register_key_down("4key", "KeyD"));
+ assert_eq!(bootstrap_active_keys(&manager), vec!["KeyD"]);
+ }
+}
diff --git a/src-tauri/src/state/atomic_file.rs b/src-tauri/src/state/atomic_file.rs
new file mode 100644
index 00000000..ceac637d
--- /dev/null
+++ b/src-tauri/src/state/atomic_file.rs
@@ -0,0 +1,136 @@
+use std::{
+ fs::{self, OpenOptions},
+ io::Write,
+ path::{Path, PathBuf},
+};
+
+use anyhow::{Context, Result};
+use uuid::Uuid;
+
+pub(crate) struct PreparedAtomicReplace {
+ target_path: PathBuf,
+ temp_path: PathBuf,
+ committed: bool,
+}
+
+impl PreparedAtomicReplace {
+ pub(crate) fn commit(mut self) -> Result<()> {
+ fs::rename(&self.temp_path, &self.target_path)
+ .with_context(|| format!("failed to replace file at {}", self.target_path.display()))?;
+ self.committed = true;
+ Ok(())
+ }
+}
+
+impl Drop for PreparedAtomicReplace {
+ fn drop(&mut self) {
+ if !self.committed {
+ let _ = fs::remove_file(&self.temp_path);
+ }
+ }
+}
+
+pub(crate) fn prepare_atomic_replace(
+ path: &Path,
+ content: &[u8],
+ label: &str,
+) -> Result {
+ let parent = path
+ .parent()
+ .context("failed to resolve file parent directory")?;
+ let file_name = path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .context("failed to resolve file name")?;
+ let temp_path = parent.join(format!(".{file_name}.{label}-{}.tmp", Uuid::new_v4()));
+
+ let result = (|| {
+ let mut temp = OpenOptions::new()
+ .write(true)
+ .create_new(true)
+ .open(&temp_path)
+ .with_context(|| format!("failed to create temp file at {}", temp_path.display()))?;
+ temp.write_all(content)
+ .with_context(|| format!("failed to write temp file at {}", temp_path.display()))?;
+ temp.sync_all()
+ .with_context(|| format!("failed to sync temp file at {}", temp_path.display()))?;
+ drop(temp);
+
+ Ok(PreparedAtomicReplace {
+ target_path: path.to_path_buf(),
+ temp_path: temp_path.clone(),
+ committed: false,
+ })
+ })();
+
+ if result.is_err() {
+ let _ = fs::remove_file(&temp_path);
+ }
+ result
+}
+
+pub(crate) fn atomic_replace(path: &Path, content: &[u8], label: &str) -> Result<()> {
+ prepare_atomic_replace(path, content, label)?.commit()
+}
+
+#[cfg(all(test, unix))]
+pub(crate) mod test_support {
+ use std::os::raw::c_int;
+
+ const RLIMIT_FSIZE: c_int = 1;
+ const SIGXFSZ: c_int = 25;
+ const SIG_IGN: usize = 1;
+
+ #[repr(C)]
+ #[derive(Clone, Copy)]
+ struct Rlimit {
+ current: u64,
+ maximum: u64,
+ }
+
+ unsafe extern "C" {
+ fn getrlimit(resource: c_int, limit: *mut Rlimit) -> c_int;
+ fn setrlimit(resource: c_int, limit: *const Rlimit) -> c_int;
+ fn signal(signal: c_int, handler: usize) -> usize;
+ }
+
+ pub(crate) struct FileSizeLimit {
+ previous_limit: Rlimit,
+ previous_handler: usize,
+ }
+
+ impl FileSizeLimit {
+ pub(crate) fn set(bytes: u64) -> Self {
+ let mut previous_limit = Rlimit {
+ current: 0,
+ maximum: 0,
+ };
+ let get_result = unsafe { getrlimit(RLIMIT_FSIZE, &mut previous_limit) };
+ assert_eq!(get_result, 0, "getrlimit(RLIMIT_FSIZE) failed");
+ assert!(
+ bytes <= previous_limit.maximum,
+ "requested file limit exceeds hard limit"
+ );
+
+ let previous_handler = unsafe { signal(SIGXFSZ, SIG_IGN) };
+ let limited = Rlimit {
+ current: bytes,
+ maximum: previous_limit.maximum,
+ };
+ let set_result = unsafe { setrlimit(RLIMIT_FSIZE, &limited) };
+ assert_eq!(set_result, 0, "setrlimit(RLIMIT_FSIZE) failed");
+
+ Self {
+ previous_limit,
+ previous_handler,
+ }
+ }
+ }
+
+ impl Drop for FileSizeLimit {
+ fn drop(&mut self) {
+ let _ = unsafe { setrlimit(RLIMIT_FSIZE, &self.previous_limit) };
+ let _ = unsafe { signal(SIGXFSZ, self.previous_handler) };
+ }
+ }
+}
diff --git a/src-tauri/src/state/local_asset_path.rs b/src-tauri/src/state/local_asset_path.rs
new file mode 100644
index 00000000..3ba4d39c
--- /dev/null
+++ b/src-tauri/src/state/local_asset_path.rs
@@ -0,0 +1,119 @@
+use std::path::PathBuf;
+
+use url::Url;
+
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) enum FileUrlPath {
+ NotFileUrl,
+ Path(PathBuf),
+ Invalid,
+}
+
+pub(crate) fn file_url_to_path(value: &str) -> FileUrlPath {
+ let trimmed = value.trim();
+ let Some((scheme, _)) = trimmed.split_once(':') else {
+ return FileUrlPath::NotFileUrl;
+ };
+ if !scheme.eq_ignore_ascii_case("file") {
+ return FileUrlPath::NotFileUrl;
+ }
+ if !has_valid_percent_encoding(trimmed) {
+ return FileUrlPath::Invalid;
+ }
+
+ let Ok(url) = Url::parse(trimmed) else {
+ return FileUrlPath::Invalid;
+ };
+ match url.to_file_path() {
+ Ok(path) if path.is_absolute() => FileUrlPath::Path(path),
+ _ => FileUrlPath::Invalid,
+ }
+}
+
+fn has_valid_percent_encoding(value: &str) -> bool {
+ let bytes = value.as_bytes();
+ let mut index = 0;
+ while index < bytes.len() {
+ if bytes[index] != b'%' {
+ index += 1;
+ continue;
+ }
+ let Some(high) = bytes.get(index + 1).and_then(|byte| hex_value(*byte)) else {
+ return false;
+ };
+ let Some(low) = bytes.get(index + 2).and_then(|byte| hex_value(*byte)) else {
+ return false;
+ };
+ if high == 0 && low == 0 {
+ return false;
+ }
+ index += 3;
+ }
+ true
+}
+
+fn hex_value(byte: u8) -> Option {
+ match byte {
+ b'0'..=b'9' => Some(byte - b'0'),
+ b'a'..=b'f' => Some(byte - b'a' + 10),
+ b'A'..=b'F' => Some(byte - b'A' + 10),
+ _ => None,
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{file_url_to_path, FileUrlPath};
+ use std::path::PathBuf;
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn decodes_file_url_without_treating_plus_as_space() {
+ assert_eq!(
+ file_url_to_path("file:///tmp/Application%20Support/%ED%95%9C%EA%B8%80%25+a.png"),
+ FileUrlPath::Path(PathBuf::from("/tmp/Application Support/한글%+a.png"))
+ );
+ }
+
+ #[cfg(not(target_os = "windows"))]
+ #[test]
+ fn accepts_localhost_file_url() {
+ assert_eq!(
+ file_url_to_path("FILE://localhost/tmp/dmnote.wav"),
+ FileUrlPath::Path(PathBuf::from("/tmp/dmnote.wav"))
+ );
+ }
+
+ #[test]
+ fn distinguishes_non_file_and_invalid_file_urls() {
+ assert_eq!(
+ file_url_to_path("https://example.com/a.png"),
+ FileUrlPath::NotFileUrl
+ );
+ assert_eq!(
+ file_url_to_path("file://[invalid/path.png"),
+ FileUrlPath::Invalid
+ );
+ assert_eq!(
+ file_url_to_path("file:///tmp/broken%ZZ.png"),
+ FileUrlPath::Invalid
+ );
+ assert_eq!(
+ file_url_to_path("file:///tmp/nul%00.png"),
+ FileUrlPath::Invalid
+ );
+ }
+
+ #[cfg(target_os = "windows")]
+ #[test]
+ fn decodes_windows_drive_and_unc_file_urls() {
+ assert_eq!(
+ file_url_to_path("file:///C:/Program%20Files/DM%20NOTE/a.wav"),
+ FileUrlPath::Path(PathBuf::from(r"C:\Program Files\DM NOTE\a.wav"))
+ );
+ assert_eq!(
+ file_url_to_path("file://server/share/a%20b.wav"),
+ FileUrlPath::Path(PathBuf::from(r"\\server\share\a b.wav"))
+ );
+ }
+}
diff --git a/src-tauri/src/state/migration.rs b/src-tauri/src/state/migration.rs
index a3161697..056e2a59 100644
--- a/src-tauri/src/state/migration.rs
+++ b/src-tauri/src/state/migration.rs
@@ -1,4 +1,5 @@
use std::{
+ collections::{HashMap, HashSet},
fs,
path::{Path, PathBuf},
};
@@ -6,29 +7,39 @@ use std::{
use anyhow::{Context, Result};
use base64::{engine::general_purpose::STANDARD as BASE64_STANDARD, Engine as _};
use dirs_next::config_dir;
-use serde::Deserialize;
-use serde_json::Value;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_json::{Map, Value};
use uuid::Uuid;
use crate::{
defaults::{default_keys, default_positions},
models::{
- AppStoreData, FontType, GraphPositions, KeyCounters, KeyMappings, KeyPositions,
- NoteSettings, OverlayBounds, StatPositions,
+ AppStoreData, CounterAnimationPreset, CustomCss, CustomFont, CustomJs, CustomTab, FontType,
+ GraphPosition, GraphPositions, GraphStatType, GraphType, GridSettings, JsPlugin,
+ KeyCounters, KeyMappings, KeyPosition, KeyPositions, KnobPosition, KnobPositions,
+ LayerGroupDef, LayerGroups, NoteSettings, OverlayBounds, ShortcutsState, SoundLibraryEntry,
+ StatPosition, StatPositions, StatType, TabCss, TabNoteSettings,
},
};
const LEGACY_OVERLAY_WIDTH: f64 = 860.0;
const LEGACY_OVERLAY_HEIGHT: f64 = 320.0;
+pub(crate) struct LoadedStore {
+ pub(crate) data: AppStoreData,
+ pub(crate) needs_persist: bool,
+ pub(crate) repaired: bool,
+}
+
/// store 파일 로드 및 마이그레이션 적용
-pub(crate) fn load_store_from_path(path: &Path) -> Result<(AppStoreData, bool)> {
- let content = fs::read_to_string(path)
+pub(crate) fn load_store_from_path(path: &Path) -> Result {
+ // 바이트로 읽어 잘못된 UTF-8도 IO 에러 대신 JSON 파싱 실패로 흘려 복구 분기에 합류
+ let content = fs::read(path)
.with_context(|| format!("failed to read store file at {}", path.display()))?;
- let (state, needs_persist) = match serde_json::from_str::(&content) {
+ let (state, needs_persist, repaired) = match serde_json::from_slice::(&content) {
Ok(mut value) => {
let sound_library_migrated = migrate_sound_library_enabled(&mut value);
- match serde_json::from_value::(value) {
+ match serde_json::from_value::(value.clone()) {
Ok(mut data) => {
let mut needs_persist = sound_library_migrated
|| data.font_settings.custom_fonts.iter().any(|font| {
@@ -46,22 +57,56 @@ pub(crate) fn load_store_from_path(path: &Path) -> Result<(AppStoreData, bool)>
if migrate_legacy_knob_sensitivity(&mut data) {
needs_persist = true;
}
- (normalize_state(data), needs_persist)
+ let semantic_repaired = repair_semantic_identities(&mut data);
+ needs_persist |= semantic_repaired;
+ let layout_repaired = repair_custom_tab_key_layout_pairs(
+ &mut data,
+ value.get("keys"),
+ value.get("keyPositions"),
+ );
+ needs_persist |= layout_repaired;
+ needs_persist |= !has_valid_selected_key_type(&data);
+ (
+ normalize_state(data),
+ needs_persist,
+ layout_repaired || semantic_repaired,
+ )
+ }
+ Err(err) => {
+ log::warn!(
+ "[Store] Falling back to field-level recovery for {}: {err}",
+ path.display()
+ );
+ (repair_legacy_state(value), true, true)
}
- // 레거시/비정상 store 파일 복구 후 정규화 상태 저장
- Err(_) => (repair_legacy_state(&content), true),
}
}
- // 레거시/비정상 store 파일 복구 후 정규화 상태 저장
- Err(_) => (repair_legacy_state(&content), true),
+ Err(err) => {
+ log::warn!(
+ "[Store] Falling back to default recovery for invalid JSON at {}: {err}",
+ path.display()
+ );
+ (repair_legacy_state(Value::Null), true, true)
+ }
};
+ // 로드 시점은 정의와 참조가 함께 확정되는 경계 — dangling groupId 정리
+ // 정리가 발생하면 마이그레이션과 같은 경로로 디스크에도 영속
+ let mut state = state;
+ let mut needs_persist = needs_persist;
+ if clear_dangling_group_ids(&mut state) {
+ needs_persist = true;
+ }
if needs_persist {
log::info!(
"[Store] Persisting migrated store file at {}",
path.display()
);
}
- Ok((state, needs_persist))
+ Ok(LoadedStore {
+ data: state,
+ needs_persist,
+ repaired,
+ })
}
fn migrate_sound_library_enabled(value: &mut Value) -> bool {
@@ -101,6 +146,49 @@ fn migrate_legacy_knob_sensitivity(data: &mut AppStoreData) -> bool {
changed
}
+/// 타입은 맞지만 실제 식별자로 쓸 수 없는 항목을 로드 경계에서만 정리
+fn repair_semantic_identities(data: &mut AppStoreData) -> bool {
+ let mut changed = false;
+
+ for positions in data.knob_positions.values_mut() {
+ let original_len = positions.len();
+ positions.retain(|knob| !knob.axis_id.trim().is_empty());
+ changed |= positions.len() != original_len;
+ }
+
+ let original_font_len = data.font_settings.custom_fonts.len();
+ data.font_settings
+ .custom_fonts
+ .retain(|font| !font.id.trim().is_empty() && !font.name.trim().is_empty());
+ changed |= data.font_settings.custom_fonts.len() != original_font_len;
+
+ for font in data.font_settings.custom_fonts.iter_mut() {
+ if font.font_type != FontType::Local {
+ continue;
+ }
+
+ let invalid_path = font
+ .local_path
+ .as_ref()
+ .is_some_and(|path| path.trim().is_empty() || !Path::new(path.trim()).is_absolute());
+ if invalid_path {
+ font.local_path = None;
+ changed = true;
+ }
+
+ let has_embedded_source = font
+ .css_content
+ .as_deref()
+ .is_some_and(|content| !content.trim().is_empty());
+ if font.local_path.is_none() && !has_embedded_source && font.enabled {
+ font.enabled = false;
+ changed = true;
+ }
+ }
+
+ changed
+}
+
/// 레거시 store 파일 경로 탐색
pub(crate) fn find_legacy_store_file() -> Option {
// 고정된 레거시 경로: %APPDATA%/dm-note/config.json
@@ -148,9 +236,10 @@ pub(crate) fn migrate_local_fonts_to_app_data(
_ => "",
};
- if !local_path.is_empty() {
- let source = PathBuf::from(local_path);
+ let source = (!local_path.is_empty()).then(|| PathBuf::from(local_path));
+ let source_exists = source.as_ref().is_some_and(|path| path.exists());
+ if let Some(source) = source.as_ref() {
// 이미 앱 데이터 fonts 디렉터리 내부에 있으면 cssContent만 제거
if source.starts_with(&fonts_dir) && source.exists() {
if font.css_content.is_some() {
@@ -160,14 +249,14 @@ pub(crate) fn migrate_local_fonts_to_app_data(
continue;
}
- if source.exists() {
+ if source_exists {
let ext = source
.extension()
.and_then(|e| e.to_str())
.unwrap_or("ttf")
.to_lowercase();
let dest = fonts_dir.join(format!("{}.{}", Uuid::new_v4(), ext));
- match fs::copy(&source, &dest) {
+ match fs::copy(source, &dest) {
Ok(_) => {
font.local_path = Some(dest.to_string_lossy().to_string());
font.css_content = None;
@@ -184,15 +273,43 @@ pub(crate) fn migrate_local_fonts_to_app_data(
}
}
- // 폰트 파일 임포트 실패 시 비활성화하고 cssContent 제거 (store 비대화 방지)
+ let fallback_extension = source
+ .as_ref()
+ .and_then(|path| path.extension())
+ .and_then(|extension| extension.to_str());
+ if let Some((bytes, extension)) = font
+ .css_content
+ .as_deref()
+ .and_then(|css| decode_font_data_url(css, fallback_extension))
+ {
+ let dest = fonts_dir.join(format!("{}.{}", Uuid::new_v4(), extension));
+ match fs::write(&dest, bytes) {
+ Ok(_) => {
+ font.local_path = Some(dest.to_string_lossy().to_string());
+ font.css_content = None;
+ changed = true;
+ continue;
+ }
+ Err(err) => {
+ log::warn!(
+ "[Fonts] Failed to restore embedded local font into {}: {err}",
+ dest.display()
+ );
+ continue;
+ }
+ }
+ }
+
+ if source_exists {
+ continue;
+ }
+
+ // 복구 가능한 원본과 data URI가 모두 없을 때 비활성화만 수행
+ // css_content는 보존 — 미지 mime 등 디코더 개선 시 재복구 여지 유지
if font.enabled {
font.enabled = false;
changed = true;
}
- if font.css_content.is_some() {
- font.css_content = None;
- changed = true;
- }
}
changed
@@ -217,6 +334,11 @@ pub(crate) fn migrate_key_images_to_app_data(app_data_dir: &Path, data: &mut App
option_has_non_empty_text(&graph_position.position.active_image)
|| option_has_non_empty_text(&graph_position.position.inactive_image)
})
+ }) || data.knob_positions.values().any(|positions| {
+ positions.iter().any(|knob_position| {
+ option_has_non_empty_text(&knob_position.position.active_image)
+ || option_has_non_empty_text(&knob_position.position.inactive_image)
+ })
});
if !has_any_images {
@@ -266,6 +388,19 @@ pub(crate) fn migrate_key_images_to_app_data(app_data_dir: &Path, data: &mut App
}
}
+ for positions in data.knob_positions.values_mut() {
+ for knob_position in positions.iter_mut() {
+ changed |= migrate_image_reference_to_app_data(
+ &images_dir,
+ &mut knob_position.position.active_image,
+ );
+ changed |= migrate_image_reference_to_app_data(
+ &images_dir,
+ &mut knob_position.position.inactive_image,
+ );
+ }
+ }
+
changed
}
@@ -428,7 +563,7 @@ pub(crate) fn normalize_state(mut data: AppStoreData) -> AppStoreData {
}
}
- if !data.keys.contains_key(&data.selected_key_type) {
+ if !has_valid_selected_key_type(&data) {
data.selected_key_type = "4key".to_string();
}
@@ -437,6 +572,92 @@ pub(crate) fn normalize_state(mut data: AppStoreData) -> AppStoreData {
data
}
+fn has_valid_selected_key_type(data: &AppStoreData) -> bool {
+ default_keys().contains_key(&data.selected_key_type)
+ || (data.keys.contains_key(&data.selected_key_type)
+ && data
+ .custom_tabs
+ .iter()
+ .any(|tab| tab.id == data.selected_key_type))
+}
+
+/// 그룹 정의가 사라진 요소의 groupId를 해제 — dangling 참조는 UI에서 해석 불가
+/// 정리 발생 여부를 반환 (로드 경로에서 needs_persist 판단에 사용)
+///
+/// 파일 로드·프리셋 임포트처럼 정의와 참조가 함께 확정되는 경계에서만 호출할 것.
+/// 프론트는 positions(groupId 포함)를 먼저 저장하고 layerGroups를 나중에 저장하므로,
+/// normalize_state 같은 부분 저장 경로에서 돌리면 새 그룹 생성이 파괴된다.
+pub(crate) fn clear_dangling_group_ids(data: &mut AppStoreData) -> bool {
+ clear_dangling_group_ids_in(
+ &mut data.key_positions,
+ &mut data.stat_positions,
+ &mut data.graph_positions,
+ &mut data.knob_positions,
+ &data.layer_groups,
+ )
+}
+
+pub(crate) fn clear_dangling_group_ids_in(
+ key_positions: &mut KeyPositions,
+ stat_positions: &mut StatPositions,
+ graph_positions: &mut GraphPositions,
+ knob_positions: &mut KnobPositions,
+ layer_groups: &LayerGroups,
+) -> bool {
+ let valid_ids: HashMap<&str, HashSet<&str>> = layer_groups
+ .iter()
+ .map(|(tab, groups)| {
+ (
+ tab.as_str(),
+ groups.iter().map(|group| group.id.as_str()).collect(),
+ )
+ })
+ .collect();
+
+ let is_dangling = |tab: &str, group_id: &Option| {
+ group_id.as_ref().is_some_and(|id| {
+ !valid_ids
+ .get(tab)
+ .is_some_and(|ids| ids.contains(id.as_str()))
+ })
+ };
+
+ let mut changed = false;
+ for (tab, positions) in key_positions.iter_mut() {
+ for position in positions.iter_mut() {
+ if is_dangling(tab, &position.group_id) {
+ position.group_id = None;
+ changed = true;
+ }
+ }
+ }
+ for (tab, positions) in stat_positions.iter_mut() {
+ for stat in positions.iter_mut() {
+ if is_dangling(tab, &stat.position.group_id) {
+ stat.position.group_id = None;
+ changed = true;
+ }
+ }
+ }
+ for (tab, positions) in graph_positions.iter_mut() {
+ for graph in positions.iter_mut() {
+ if is_dangling(tab, &graph.position.group_id) {
+ graph.position.group_id = None;
+ changed = true;
+ }
+ }
+ }
+ for (tab, positions) in knob_positions.iter_mut() {
+ for knob in positions.iter_mut() {
+ if is_dangling(tab, &knob.position.group_id) {
+ knob.position.group_id = None;
+ changed = true;
+ }
+ }
+ }
+ changed
+}
+
/// 누락된 모드만 기본값으로 채움
fn merge_default_modes(target: &mut KeyMappings, defaults: &KeyMappings) {
for (mode, value) in defaults.iter() {
@@ -467,345 +688,2053 @@ fn merge_default_counters(target: &mut KeyCounters, keys: &KeyMappings) {
target.retain(|mode, _| available_modes.contains(mode));
}
-/// 레거시/비정상 store 파일 수동 복구
-fn repair_legacy_state(raw: &str) -> AppStoreData {
- let value: Value = serde_json::from_str(raw).unwrap_or(Value::Null);
- let mut data = AppStoreData::default();
- if let Value::Object(obj) = value {
- if let Some(v) = obj.get("hardwareAcceleration").and_then(Value::as_bool) {
- data.hardware_acceleration = v;
- }
- if let Some(v) = obj.get("alwaysOnTop").and_then(Value::as_bool) {
- data.always_on_top = v;
- }
- if let Some(v) = obj.get("overlayLocked").and_then(Value::as_bool) {
- data.overlay_locked = v;
- }
- if let Some(v) = obj.get("noteEffect").and_then(Value::as_bool) {
- data.note_effect = v;
- }
- if let Some(v) = obj
- .get("noteSettings")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.note_settings = v;
- }
- if let Some(v) = obj.get("selectedKeyType").and_then(Value::as_str) {
- data.selected_key_type = v.to_string();
- }
- if let Some(v) = obj
- .get("customTabs")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.custom_tabs = v;
- }
- if let Some(v) = obj
- .get("counterAnimationPresets")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.counter_animation_presets = v;
- }
- if let Some(v) = obj.get("angleMode").and_then(Value::as_str) {
- data.angle_mode = v.to_string();
- }
- if let Some(v) = obj.get("language").and_then(Value::as_str) {
- data.language = v.to_string();
- }
- if let Some(v) = obj.get("laboratoryEnabled").and_then(Value::as_bool) {
- data.laboratory_enabled = v;
- }
- if let Some(v) = obj.get("developerModeEnabled").and_then(Value::as_bool) {
- data.developer_mode_enabled = v;
- }
- if let Some(v) = obj.get("trayEnabled").and_then(Value::as_bool) {
- data.tray_enabled = v;
- }
- if let Some(v) = obj.get("autoUpdateEnabled").and_then(Value::as_bool) {
- data.auto_update_enabled = v;
- }
- if let Some(v) = obj.get("mainWindowHidden").and_then(Value::as_bool) {
- data.main_window_hidden = v;
- }
- if let Some(v) = obj
- .get("keys")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.keys = v;
- }
- if let Some(v) = obj
- .get("keyPositions")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.key_positions = v;
- }
- if let Some(v) = obj
- .get("statPositions")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.stat_positions = v;
- }
- if let Some(v) = obj
- .get("graphPositions")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.graph_positions = v;
- }
- if let Some(v) = obj
- .get("keyCounters")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.key_counters = v;
- }
- if let Some(v) = obj.get("backgroundColor").and_then(Value::as_str) {
- data.background_color = v.to_string();
- }
- if let Some(v) = obj.get("useCustomCSS").and_then(Value::as_bool) {
- data.use_custom_css = v;
- } else if let Some(v) = obj.get("useCustomCss").and_then(Value::as_bool) {
- data.use_custom_css = v;
- }
- if let Some(v) = obj
- .get("customCSS")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.custom_css = v;
- } else if let Some(v) = obj
- .get("customCss")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.custom_css = v;
- }
- if let Some(v) = obj.get("useCustomJS").and_then(Value::as_bool) {
- data.use_custom_js = v;
- } else if let Some(v) = obj.get("useCustomJs").and_then(Value::as_bool) {
- data.use_custom_js = v;
- }
- if let Some(v) = obj
- .get("customJS")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.custom_js = v;
- } else if let Some(v) = obj
- .get("customJs")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.custom_js = v;
- }
- if let Some(v) = obj
- .get("overlayResizeAnchor")
- .and_then(|v| serde_json::from_value(v.clone()).ok())
- {
- data.overlay_resize_anchor = v;
- }
- if let Some(v) = obj
- .get("overlayWindowBounds")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.overlay_bounds = Some(OverlayBounds {
- x: v.x,
- y: v.y,
- width: v.width,
- height: v.height,
- });
- }
- if data.overlay_bounds.is_none() {
- if let Some(v) = obj
- .get("overlayWindowPosition")
- .and_then(|v| serde_json::from_value::(v.clone()).ok())
- {
- data.overlay_bounds = Some(OverlayBounds {
- x: v.x,
- y: v.y,
- width: LEGACY_OVERLAY_WIDTH,
- height: LEGACY_OVERLAY_HEIGHT,
- });
- }
- }
- if let Some(v) = obj
- .get("overlayLastContentTopOffset")
- .and_then(Value::as_f64)
- {
- data.overlay_last_content_top_offset = Some(v);
- }
- if let Some(v) = obj.get("keyCounterEnabled").and_then(Value::as_bool) {
- data.key_counter_enabled = v;
+/// 레거시/비정상 store 파일 필드별 복구
+fn repair_legacy_state(value: Value) -> AppStoreData {
+ let Value::Object(mut source) = value else {
+ return normalize_state(AppStoreData::default());
+ };
+ migrate_legacy_repair_fields(&mut source);
+ let source_keys = source.get("keys").cloned();
+ let source_key_positions = source.get("keyPositions").cloned();
+
+ let Value::Object(mut recovered) =
+ serde_json::to_value(AppStoreData::default()).unwrap_or_else(|_| Value::Object(Map::new()))
+ else {
+ return normalize_state(AppStoreData::default());
+ };
+
+ for (field, value) in source {
+ let previous = recovered.insert(field.clone(), value.clone());
+ if serde_json::from_value::(Value::Object(recovered.clone())).is_err() {
+ if let Some(partial) = recover_collection_field(&field, &value) {
+ recovered.insert(field.clone(), partial);
+ if serde_json::from_value::(Value::Object(recovered.clone())).is_ok()
+ {
+ continue;
+ }
+ }
+
+ log::warn!("[Store] Resetting invalid field to default: {field}");
+ match previous {
+ Some(value) => {
+ recovered.insert(field, value);
+ }
+ None => {
+ recovered.remove(&field);
+ }
+ }
}
}
- let _ = data.custom_js.normalize();
+
+ let mut data =
+ serde_json::from_value::(Value::Object(recovered)).unwrap_or_default();
+ migrate_legacy_knob_sensitivity(&mut data);
+ repair_semantic_identities(&mut data);
+ repair_custom_tab_key_layout_pairs(
+ &mut data,
+ source_keys.as_ref(),
+ source_key_positions.as_ref(),
+ );
normalize_state(data)
}
-fn option_has_non_empty_text(value: &Option) -> bool {
- value
- .as_ref()
- .map(|text| !text.trim().is_empty())
- .unwrap_or(false)
-}
+fn repair_custom_tab_key_layout_pairs(
+ data: &mut AppStoreData,
+ source_keys: Option<&Value>,
+ source_key_positions: Option<&Value>,
+) -> bool {
+ let tab_ids = data
+ .custom_tabs
+ .iter()
+ .map(|tab| tab.id.clone())
+ .collect::>();
+ let mut repaired = false;
-fn decode_image_data_url(value: &str) -> Option<(Vec, String)> {
- let (header, payload) = value.split_once(',')?;
- let header_lower = header.to_ascii_lowercase();
- if !header_lower.starts_with("data:image/") || !header_lower.contains(";base64") {
- return None;
+ for mode in tab_ids {
+ let source_keys = source_mode_array(source_keys, &mode);
+ let source_positions = source_mode_array(source_key_positions, &mode);
+
+ match (source_keys, source_positions) {
+ (Some(_), Some(_)) => {}
+ (None, Some(positions)) => {
+ log::warn!(
+ "[Store] Rebuilding invalid keys mode '{mode}' with {} unassigned entries during recovery",
+ positions.len()
+ );
+ data.keys.insert(mode, vec![String::new(); positions.len()]);
+ repaired = true;
+ }
+ (Some(keys), None) => {
+ log::warn!(
+ "[Store] Rebuilding invalid keyPositions mode '{mode}' with {} default entries during recovery",
+ keys.len()
+ );
+ data.key_positions
+ .insert(mode, vec![KeyPosition::default(); keys.len()]);
+ repaired = true;
+ }
+ (None, None) => {
+ log::warn!(
+ "[Store] Initializing missing keys and keyPositions modes '{mode}' during recovery"
+ );
+ data.keys.insert(mode.clone(), Vec::new());
+ data.key_positions.insert(mode, Vec::new());
+ repaired = true;
+ }
+ }
}
- let mime = header
- .split(';')
- .next()
- .and_then(|part| part.strip_prefix("data:"))
- .unwrap_or("image/png");
- let extension = extension_from_image_mime(mime);
- let bytes = BASE64_STANDARD.decode(payload.as_bytes()).ok()?;
- Some((bytes, extension))
+ repaired
}
-fn extension_from_image_mime(mime: &str) -> String {
- match mime.trim().to_ascii_lowercase().as_str() {
- "image/jpeg" | "image/jpg" => "jpg".to_string(),
- "image/png" => "png".to_string(),
- "image/webp" => "webp".to_string(),
- "image/gif" => "gif".to_string(),
- "image/bmp" => "bmp".to_string(),
- "image/svg+xml" => "svg".to_string(),
- "image/x-icon" | "image/vnd.microsoft.icon" => "ico".to_string(),
- "image/avif" => "avif".to_string(),
- _ => "png".to_string(),
+fn source_mode_array<'a>(collection: Option<&'a Value>, mode: &str) -> Option<&'a [Value]> {
+ collection?
+ .as_object()?
+ .get(mode)?
+ .as_array()
+ .map(Vec::as_slice)
+}
+
+fn recover_collection_field(field: &str, value: &Value) -> Option {
+ match field {
+ "noteSettings" => recover_object_fields::(field, value),
+ "customTabs" => recover_array_entries::(field, value),
+ "keys" => recover_key_mapping_entries(value),
+ "soundLibrary" => recover_sound_library_entries(value),
+ "keyPositions" => recover_key_position_entries(field, value),
+ "statPositions" => recover_key_position_backed_entries::(
+ field,
+ value,
+ has_valid_stat_identity,
+ ),
+ "graphPositions" => recover_key_position_backed_entries::(
+ field,
+ value,
+ has_valid_graph_identity,
+ ),
+ "knobPositions" => recover_key_position_backed_entries::(
+ field,
+ value,
+ has_valid_knob_identity,
+ ),
+ "layerGroups" => recover_position_entries::(field, value),
+ "keyCounters" => recover_key_counter_entries(value),
+ "customCss" => recover_object_fields::(field, value),
+ "fontSettings" => recover_font_settings(value),
+ "counterAnimationPresets" => recover_array_entries::(field, value),
+ "tabCssOverrides" => recover_map_object_entries::(field, value),
+ "tabNoteOverrides" => recover_map_object_entries::(field, value),
+ "customJs" => recover_custom_js(value),
+ "gridSettings" => recover_object_fields::(field, value),
+ "shortcuts" => recover_object_fields::(field, value),
+ _ => None,
}
}
-fn normalize_image_extension(extension: Option<&str>) -> String {
- match extension
- .unwrap_or_default()
- .trim()
- .to_ascii_lowercase()
- .as_str()
- {
- "jpg" | "jpeg" => "jpg".to_string(),
- "png" => "png".to_string(),
- "webp" => "webp".to_string(),
- "gif" => "gif".to_string(),
- "bmp" => "bmp".to_string(),
- "svg" => "svg".to_string(),
- "ico" => "ico".to_string(),
- "avif" => "avif".to_string(),
- _ => "png".to_string(),
+fn recover_object_fields(field: &str, value: &Value) -> Option
+where
+ T: Default + DeserializeOwned + Serialize,
+{
+ let Value::Object(source) = value else {
+ return None;
+ };
+ let Value::Object(mut recovered) = serde_json::to_value(T::default()).ok()? else {
+ return None;
+ };
+
+ for (name, entry) in source {
+ let previous = recovered.insert(name.clone(), entry.clone());
+ if serde_json::from_value::(Value::Object(recovered.clone())).is_err() {
+ log::warn!(
+ "[Store] Resetting invalid {field} child '{name}' to its default during recovery"
+ );
+ match previous {
+ Some(value) => {
+ recovered.insert(name.clone(), value);
+ }
+ None => {
+ recovered.remove(name);
+ }
+ }
+ }
}
+ Some(Value::Object(recovered))
}
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct LegacyOverlayBounds {
- x: f64,
- y: f64,
- width: f64,
- height: f64,
+fn recover_array_entries(field: &str, value: &Value) -> Option
+where
+ T: DeserializeOwned,
+{
+ let Value::Array(entries) = value else {
+ return None;
+ };
+
+ let mut recovered = Vec::with_capacity(entries.len());
+ for (index, entry) in entries.iter().enumerate() {
+ match serde_json::from_value::(entry.clone()) {
+ Ok(_) => recovered.push(entry.clone()),
+ Err(err) => {
+ log::warn!(
+ "[Store] Removing invalid {field} entry '[{index}]' during recovery: {err}"
+ );
+ }
+ }
+ }
+ Some(Value::Array(recovered))
}
-#[derive(Deserialize)]
-struct LegacyOverlayPosition {
- x: f64,
- y: f64,
+fn recover_key_mapping_entries(value: &Value) -> Option {
+ let Value::Object(modes) = value else {
+ return None;
+ };
+
+ let defaults = default_keys();
+ let mut recovered_modes = Map::new();
+ for (mode, entries) in modes {
+ let recovered_entries = match entries {
+ Value::Array(entries) => entries
+ .iter()
+ .enumerate()
+ .map(|(index, entry)| match entry.as_str() {
+ Some(key) => Value::String(key.to_string()),
+ None => {
+ log::warn!(
+ "[Store] Replacing invalid keys entry '{mode}[{index}]' with an unassigned key during recovery"
+ );
+ Value::String(String::new())
+ }
+ })
+ .collect(),
+ _ => {
+ log::warn!(
+ "[Store] Replacing invalid keys mode '{mode}' during recovery: expected an array"
+ );
+ defaults
+ .get(mode)
+ .map(|keys| keys.iter().cloned().map(Value::String).collect())
+ .unwrap_or_default()
+ }
+ };
+ recovered_modes.insert(mode.clone(), Value::Array(recovered_entries));
+ }
+ Some(Value::Object(recovered_modes))
}
-#[cfg(test)]
-mod tests {
- use super::{load_store_from_path, migrate_sound_library_enabled, rgba_to_hex};
- use crate::models::AppStoreData;
- use serde_json::{json, Value};
+fn recover_key_counter_entries(value: &Value) -> Option {
+ let Value::Object(modes) = value else {
+ return None;
+ };
- const TEST_SOUND_PATH: &str = "/tmp/test-sound.wav";
+ let mut recovered_modes = Map::new();
+ for (mode, counters) in modes {
+ let Value::Object(counters) = counters else {
+ log::warn!(
+ "[Store] Replacing invalid keyCounters mode '{mode}' with an empty map during recovery"
+ );
+ recovered_modes.insert(mode.clone(), Value::Object(Map::new()));
+ continue;
+ };
- fn load_store_with_sound_entry(entry: Value) -> (AppStoreData, bool) {
- let path = std::env::temp_dir().join(format!(
- "dmnote-sound-migration-test-{}.json",
+ let mut recovered_counters = Map::new();
+ for (key, count) in counters {
+ if serde_json::from_value::(count.clone()).is_ok() {
+ recovered_counters.insert(key.clone(), count.clone());
+ } else {
+ log::warn!(
+ "[Store] Removing invalid keyCounters entry '{mode}.{key}' during recovery"
+ );
+ }
+ }
+ recovered_modes.insert(mode.clone(), Value::Object(recovered_counters));
+ }
+ Some(Value::Object(recovered_modes))
+}
+
+fn recover_custom_js(value: &Value) -> Option {
+ let Value::Object(settings) = value else {
+ return None;
+ };
+ let mut candidate = settings.clone();
+ if let Some(plugins) = settings.get("plugins") {
+ let recovered_plugins = recover_array_entries::("customJs.plugins", plugins)
+ .unwrap_or_else(|| Value::Array(Vec::new()));
+ candidate.insert("plugins".to_string(), recovered_plugins);
+ }
+ recover_object_fields::("customJs", &Value::Object(candidate))
+}
+
+fn recover_sound_library_entries(value: &Value) -> Option {
+ let Value::Object(entries) = value else {
+ return None;
+ };
+ let default_entry = serde_json::to_value(SoundLibraryEntry::default()).ok()?;
+ let mut recovered = Map::new();
+
+ for (key, entry) in entries {
+ if serde_json::from_value::(entry.clone()).is_ok() {
+ recovered.insert(key.clone(), entry.clone());
+ continue;
+ }
+
+ let entry_name = format!("soundLibrary.{key}");
+ if let Some(partial) = recover_object_fields::(&entry_name, entry) {
+ if serde_json::from_value::(partial.clone()).is_ok() {
+ recovered.insert(key.clone(), partial);
+ continue;
+ }
+ }
+
+ if Path::new(key).is_absolute() {
+ log::warn!(
+ "[Store] Rebuilding invalid soundLibrary entry '{key}' from its absolute path during recovery"
+ );
+ recovered.insert(key.clone(), default_entry.clone());
+ } else {
+ log::warn!(
+ "[Store] Removing invalid soundLibrary entry '{key}' with a non-absolute path during recovery"
+ );
+ }
+ }
+
+ Some(Value::Object(recovered))
+}
+
+fn recover_map_object_entries