diff --git a/.cheese/references.cs b/.cheese/references.cs
index 3f7e747c..b66f3160 100644
--- a/.cheese/references.cs
+++ b/.cheese/references.cs
@@ -55,4 +55,13 @@
Type = ReferenceType.GitRepo,
InSubmodule = true,
},
+ new ReferenceItem
+ {
+ Name = "NodifyM.Avalonia",
+ Location = "Reference/NodifyM.Avalonia",
+ Url = "git@github.com:Crequency/NodifyM.Avalonia.git",
+ Branch = "ava11",
+ RemoteBranch = "origin/ava11",
+ Type = ReferenceType.GitRepo,
+ },
};
diff --git a/.gitignore b/.gitignore
index 007d66b5..04b46613 100644
--- a/.gitignore
+++ b/.gitignore
@@ -362,3 +362,31 @@ MigrationBackup/
# Ionide (cross platform F# VS Code tools) working folder
.ionide/
+
+# Claude Code
+.claude/
+Claude.md
+
+# Package folder
+Package/*
+
+# ── GSD baseline (auto-generated) ──
+.gsd
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*.code-workspace
+.env
+.env.*
+!.env.example
+.next/
+dist/
+build/
+.venv/
+venv/
+target/
+vendor/
+coverage/
+.cache/
+tmp/
diff --git a/Config/AnnouncementConfig.json b/Config/AnnouncementConfig.json
new file mode 100644
index 00000000..09d933d2
--- /dev/null
+++ b/Config/AnnouncementConfig.json
@@ -0,0 +1,7 @@
+{
+ "$type": "AnnouncementConfig",
+ "Accepted": [],
+ "ConfigFileLocation": "G:\\Dev\\KitX\\Config\\AnnouncementConfig.json",
+ "ConfigFileWatcherName": null,
+ "ConfigGeneratedTime": "2024-09-15T15:03:50.5253031+03:00"
+}
\ No newline at end of file
diff --git a/Config/AppConfig.json b/Config/AppConfig.json
new file mode 100644
index 00000000..056cf7bb
--- /dev/null
+++ b/Config/AppConfig.json
@@ -0,0 +1,139 @@
+{
+ "App": {
+ "IconFileName": "KitX-Icon-1920x-margin-2x.png",
+ "CoverIconFileName": "KitX-Icon-Background.png",
+ "AppLanguage": "zh-cn",
+ "Theme": "Follow",
+ "ThemeColor": "#FF3873D9",
+ "SurpportLanguages": {
+ "zh-cn": "\u4E2D\u6587 (\u7B80\u4F53)",
+ "zh-tw": "\u4E2D\u6587 (\u7E41\u9AD4)",
+ "ru-ru": "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+ "en-us": "English (US)",
+ "fr-fr": "Fran\u00E7ais",
+ "ja-jp": "\u65E5\u672C\u8A9E",
+ "ko-kr": "\uD55C\uAD6D\uC5B4"
+ },
+ "LocalPluginsFileFolder": "./Plugins/",
+ "LocalPluginsDataFolder": "./PluginsDatas/",
+ "DeveloperSetting": false,
+ "ShowAnnouncementWhenStart": true,
+ "RanTime": 0,
+ "LastBreakAfterExit": 2000
+ },
+ "Windows": {
+ "MainWindow": {
+ "Size": {
+ "Width": 1280,
+ "Height": 720,
+ "FramePerSecond": null,
+ "Area": 921600,
+ "AspectRatio": 1.7777777777777777,
+ "Description": null
+ },
+ "Location": {
+ "Left": -1,
+ "Right": 0,
+ "Top": -1,
+ "Bottom": 0,
+ "Over": 0,
+ "Under": 0
+ },
+ "WindowState": 0,
+ "IsHidden": false,
+ "Tags": {
+ "SelectedPage": "Page_Home"
+ },
+ "EnabledMica": true,
+ "GreetingTextCount_Morning": 5,
+ "GreetingTextCount_Noon": 3,
+ "GreetingTextCount_AfterNoon": 3,
+ "GreetingTextCount_Evening": 2,
+ "GreetingTextCount_Night": 4,
+ "GreetingUpdateInterval": 10
+ },
+ "AnnouncementWindow": {
+ "Size": {
+ "Width": 1280,
+ "Height": 720,
+ "FramePerSecond": null,
+ "Area": 921600,
+ "AspectRatio": 1.7777777777777777,
+ "Description": null
+ },
+ "Location": {
+ "Left": -1,
+ "Right": 0,
+ "Top": -1,
+ "Bottom": 0,
+ "Over": 0,
+ "Under": 0
+ }
+ }
+ },
+ "Pages": {
+ "Home": {
+ "NavigationViewPaneDisplayMode": 0,
+ "SelectedViewName": "View_Recent",
+ "IsNavigationViewPaneOpened": true,
+ "UseAreaExpanded": true
+ },
+ "Device": {},
+ "Market": {},
+ "Settings": {
+ "NavigationViewPaneDisplayMode": 0,
+ "SelectedViewName": "View_General",
+ "PaletteAreaExpanded": false,
+ "WebRelatedAreaExpanded": true,
+ "WebRelatedAreaOfNetworkInterfacesExpanded": false,
+ "LogRelatedAreaExpanded": true,
+ "UpdateRelatedAreaExpanded": true,
+ "AboutAreaExpanded": false,
+ "AuthorsAreaExpanded": false,
+ "LinksAreaExpanded": false,
+ "ThirdPartyLicensesAreaExpanded": false,
+ "IsNavigationViewPaneOpened": true
+ }
+ },
+ "Web": {
+ "DelayStartSeconds": 0.5,
+ "ApiServer": "api.catrol.cn",
+ "ApiPath": "/apps/kitx/",
+ "DevicesViewRefreshDelay": 1000,
+ "AcceptedNetworkInterfaces": null,
+ "UserSpecifiedDevicesServerPort": null,
+ "UserSpecifiedPluginsServerPort": null,
+ "UdpPortSend": 23404,
+ "UdpPortReceive": 24040,
+ "UdpSendFrequency": 1000,
+ "UdpBroadcastAddress": "224.0.0.0",
+ "IPFilter": "192.168",
+ "SocketBufferSize": 102400,
+ "DeviceInfoTTLSeconds": 7,
+ "DisableRemovingOfflineDeviceCard": false,
+ "UpdateServer": "api.catrol.cn",
+ "UpdatePath": "/apps/kitx/%platform%/",
+ "UpdateDownloadPath": "/apps/kitx/update/%platform%/",
+ "UpdateChannel": "stable",
+ "UpdateSource": "latest-components.json",
+ "DebugServicesServerPort": 7777
+ },
+ "Log": {
+ "LogFileSingleMaxSize": 10485760,
+ "LogFilePath": "./Log/",
+ "LogTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] {Message:lj}{NewLine}{Exception}",
+ "LogFileMaxCount": 50,
+ "LogFileFlushInterval": 30,
+ "LogLevel": 2
+ },
+ "IO": {
+ "UpdatingCheckPerThreadFilesCount": 20,
+ "OperatingSystemVersionUpdateInterval": 60
+ },
+ "Activity": {
+ "TotalRecorded": 0
+ },
+ "Loaders": {
+ "InstallPath": "./Loaders/"
+ }
+}
\ No newline at end of file
diff --git a/Config/MarketConfig.json b/Config/MarketConfig.json
new file mode 100644
index 00000000..dd55f6c4
--- /dev/null
+++ b/Config/MarketConfig.json
@@ -0,0 +1,9 @@
+{
+ "$type": "MarketConfig",
+ "Sources": {
+ "KitX Official Market Source": "https://cget.catrol.cn/KitX/v1/index.json"
+ },
+ "ConfigFileLocation": "G:\\Dev\\KitX\\Config\\MarketConfig.json",
+ "ConfigFileWatcherName": null,
+ "ConfigGeneratedTime": "2024-09-15T15:03:50.5230006+03:00"
+}
\ No newline at end of file
diff --git a/Config/PluginsConfig.json b/Config/PluginsConfig.json
new file mode 100644
index 00000000..dcffe4d4
--- /dev/null
+++ b/Config/PluginsConfig.json
@@ -0,0 +1,3 @@
+{
+ "Plugins": []
+}
\ No newline at end of file
diff --git a/Config/SecurityConfig.json b/Config/SecurityConfig.json
new file mode 100644
index 00000000..6fd074a6
--- /dev/null
+++ b/Config/SecurityConfig.json
@@ -0,0 +1,3 @@
+{
+ "DeviceKeys": []
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core.DI.Tests/KitX.Core.DI.Tests.csproj b/KitX Clients/KitX Core/KitX.Core.DI.Tests/KitX.Core.DI.Tests.csproj
new file mode 100644
index 00000000..162fba40
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.DI.Tests/KitX.Core.DI.Tests.csproj
@@ -0,0 +1,23 @@
+
+
+
+ Exe
+ net10.0
+ enable
+ enable
+ KitX.Core.DI.Tests
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core.DI.Tests/Program.cs b/KitX Clients/KitX Core/KitX.Core.DI.Tests/Program.cs
new file mode 100644
index 00000000..6b6d8861
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.DI.Tests/Program.cs
@@ -0,0 +1,234 @@
+using Microsoft.Extensions.DependencyInjection;
+using KitX.Core.DI;
+using KitX.Core.Contract.Configuration;
+using KitX.WorkflowV6.Hosting;
+
+namespace KitX.Core.DI.Tests;
+
+///
+/// Complete test suite for DI container verification.
+///
+/// This console app mirrors the Dashboard's App.axaml.cs DI registration sequence
+/// (AddCoreServices + AddKitXWorkflowV6 + Dashboard-specific registrations) and then
+/// tries to resolve every service the workflow UI depends on. The original 13-service
+/// Core suite is preserved as Test 1; Test 3 walks the full host graph to localize
+/// the "workflow page does not show" failure.
+///
+public class Program
+{
+ public static void Main(string[] args)
+ {
+ Console.WriteLine("╔════════════════════════════════════════════════════════╗");
+ Console.WriteLine("║ KitX Core DI Container - Complete Test Suite ║");
+ Console.WriteLine("╚════════════════════════════════════════════════════════╝\n");
+
+ try
+ {
+ TestServiceResolution();
+ TestSingletonLifecycle();
+ TestFullHostGraph_WorkflowResolution();
+
+ Console.WriteLine("\n" + new string('═', 54));
+ Console.WriteLine("║ 🎉 All Tests Passed Successfully! ║");
+ Console.WriteLine(new string('═', 54));
+ Console.WriteLine("\n📋 Final Verification Results:");
+ Console.WriteLine(" ✅ DI container initialization");
+ Console.WriteLine(" ✅ All 10 services registered correctly");
+ Console.WriteLine(" ✅ All services can be resolved");
+ Console.WriteLine(" ✅ Singleton lifecycle working correctly");
+ Console.WriteLine(" ✅ Backward compatibility with static Instance");
+ Console.WriteLine(" ✅ Full host workflow graph resolves");
+ Console.WriteLine("\n🚀 Phase 3 is complete and fully verified!");
+ Console.WriteLine("═════════════════════════════════════════════════════════\n");
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"\n❌ Test suite failed: {ex.Message}");
+ Console.WriteLine($"Stack trace: {ex.StackTrace}");
+ Environment.Exit(1);
+ }
+ }
+
+ private static void TestServiceResolution()
+ {
+ Console.WriteLine("┌─────────────────────────────────────────────────────────┐");
+ Console.WriteLine("│ Test 1: Service Resolution │");
+ Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
+
+ var services = new ServiceCollection();
+ services.AddCoreServices();
+ var serviceProvider = services.BuildServiceProvider();
+
+ Console.WriteLine("✅ DI Container built successfully\n");
+ Console.WriteLine("Testing service resolution:\n");
+
+ TestService(serviceProvider, "IConfigService");
+ TestService(serviceProvider, "IDeviceKeyService");
+ TestService(serviceProvider, "IEncryptionService");
+
+ // C-2: IDeviceKeyService and IEncryptionService must resolve to the SAME
+ // SecurityManager instance — a state split (device keys / RSA keypair) between
+ // two instances would break DevicesServer's key exchange flow.
+ var keyService = serviceProvider.GetRequiredService();
+ var encryptionService = serviceProvider.GetRequiredService();
+ bool sameSecurityInstance = ReferenceEquals(keyService, encryptionService);
+ Console.WriteLine($"\nSecurity Services Instance Test:");
+ Console.WriteLine($" • IDeviceKeyService hash: {keyService.GetHashCode()}");
+ Console.WriteLine($" • IEncryptionService hash: {encryptionService.GetHashCode()}");
+ Console.WriteLine($" • Same instance? {(sameSecurityInstance ? "✅ Yes" : "❌ No")}");
+
+ if (!sameSecurityInstance)
+ {
+ throw new InvalidOperationException(
+ "IDeviceKeyService and IEncryptionService resolved to different instances — " +
+ "SecurityManager state would be split.");
+ }
+
+ TestService(serviceProvider, "IPluginService");
+ TestService(serviceProvider, "IActivityService");
+ TestService(serviceProvider, "IStatisticsService");
+ TestService(serviceProvider, "ITasksService");
+ TestService(serviceProvider, "IFileWatcherService");
+ TestService(serviceProvider, "IKeyHookService");
+ TestService(serviceProvider, "IEventService");
+
+ Console.WriteLine("\n✅ Test 1 Passed: All Core services resolved successfully\n");
+ }
+
+ private static void TestSingletonLifecycle()
+ {
+ Console.WriteLine("┌─────────────────────────────────────────────────────────┐");
+ Console.WriteLine("│ Test 2: Singleton Lifecycle │");
+ Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
+
+ var services = new ServiceCollection();
+ services.AddCoreServices();
+ var serviceProvider = services.BuildServiceProvider();
+
+ // Resolve service twice
+ var service1 = serviceProvider.GetRequiredService();
+ var service2 = serviceProvider.GetRequiredService();
+
+ // Check if they are the same instance
+ bool isSameInstance = ReferenceEquals(service1, service2);
+
+ Console.WriteLine($"Resolution Test:");
+ Console.WriteLine($" • First call hash code: {service1.GetHashCode()}");
+ Console.WriteLine($" • Second call hash code: {service2.GetHashCode()}");
+ Console.WriteLine($" • Same instance? {(isSameInstance ? "✅ Yes" : "❌ No")}");
+
+ if (!isSameInstance)
+ {
+ throw new InvalidOperationException("Singleton lifecycle not working correctly");
+ }
+
+ // Verify it's the same as ConfigManager.Instance
+ bool isSameAsStatic = ReferenceEquals(service1, KitX.Core.Configuration.ConfigManager.Instance);
+ Console.WriteLine($"\nBackward Compatibility Test:");
+ Console.WriteLine($" • Same as static Instance? {(isSameAsStatic ? "✅ Yes" : "❌ No")}");
+
+ if (!isSameAsStatic)
+ {
+ Console.WriteLine("\n⚠️ Warning: DI instance differs from static Instance");
+ Console.WriteLine(" This may indicate a configuration issue.");
+ }
+
+ Console.WriteLine("\n✅ Test 2 Passed: Singleton lifecycle verified\n");
+ }
+
+ ///
+ /// Test 3 — walks the full host DI graph exactly as App.axaml.cs builds it,
+ /// then tries to resolve every service / VM the workflow UI touches. This
+ /// localizes the "workflow page does not show" failure to a specific
+ /// missing registration.
+ ///
+ private static void TestFullHostGraph_WorkflowResolution()
+ {
+ Console.WriteLine("┌─────────────────────────────────────────────────────────┐");
+ Console.WriteLine("│ Test 3: Full Host Graph — Workflow Resolution │");
+ Console.WriteLine("└─────────────────────────────────────────────────────────┘\n");
+
+ // --- Mirror App.axaml.cs InitializeServiceProvider() ---
+ // The Kscript plugin bridge (IPluginServiceProvider + IPluginManager + IPluginHost)
+ // is now registered inside AddCoreServices() (migrated from App.axaml.cs to
+ // KitX.Core/DI/CoreServiceCollectionExtensions.cs).
+ var services = new ServiceCollection();
+ services.AddCoreServices();
+ services.AddKitXWorkflowV6();
+
+ // Dashboard-specific services
+ services.AddSingleton();
+ // The legacy standalone-workflow storage service (S2 WorkflowStorageService /
+ // IWorkflowStorageService) was retired in the D2 cleanup — workflows are now
+ // created/edited only through the ToolKit workbench. The former
+ // WorkflowSessionManager run-by-id orchestrator was retired in the B5+B6+B7
+ // cleanup and is no longer registered.
+
+ var sp = services.BuildServiceProvider();
+ Console.WriteLine("✅ Full host DI container built (AddCoreServices + AddKitXWorkflowV6 + Dashboard)\n");
+ Console.WriteLine("Testing workflow-related resolution:\n");
+
+ // --- Services the workflow UI's constructor bodies call via App.GetService ---
+ TestResolve(sp, "IEventService", typeof(KitX.Core.Contract.Event.IEventService));
+
+ Console.WriteLine();
+ // WorkflowEditorWindowV6 + WorkflowEditorViewModelV6 need these (v6 concrete types):
+ TestResolve(sp, "KsTextLens", typeof(KitX.WorkflowV6.Lens.KsTextLens.KsTextLens));
+ TestResolve(sp, "BpGraphLens", typeof(KitX.WorkflowV6.Lens.BpGraphLens.BpGraphLens));
+ TestResolve(sp, "IScopeAnalyzer", typeof(KitX.WorkflowV6.Lens.BpGraphLens.IScopeAnalyzer));
+ TestResolve(sp, "StructuredRoslynBackend", typeof(KitX.WorkflowV6.Backend.RoslynBackend.StructuredRoslynBackend));
+ TestResolve(sp, "IPluginHost (v6)", typeof(KitX.WorkflowV6.Backend.Runtime.IPluginHost));
+ // C4: the network stack is orchestrated by the Core-level INetworkService.
+ TestResolve(sp, "INetworkService", typeof(KitX.Core.Contract.Device.INetworkService));
+ // C2: the shared execution path used by the editor and run-by-id services.
+ TestResolve(sp, "WorkflowRunner", typeof(KitX.WorkflowV6.Services.WorkflowRunner));
+
+ Console.WriteLine("\n✅ Test 3 Passed: Full host workflow graph resolved\n");
+ }
+
+ private static void TestService(IServiceProvider serviceProvider, string serviceName) where T : notnull
+ {
+ try
+ {
+ var service = serviceProvider.GetRequiredService();
+ if (service == null)
+ throw new InvalidOperationException($"{serviceName} resolved to null");
+
+ var actualType = service.GetType().FullName;
+ var shortName = actualType?.Split('.').Last();
+ Console.WriteLine($" ✅ {serviceName,-25} → {shortName}");
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($" ❌ {serviceName}: {ex.Message}");
+ throw;
+ }
+ }
+
+ ///
+ /// Resolves a type from the full host container, treating failure as informational
+ /// (prints ❌ + the reason) rather than fatal — so one missing registration does
+ /// not hide subsequent ones.
+ ///
+ private static void TestResolve(IServiceProvider sp, string label, Type serviceType)
+ {
+ try
+ {
+ var svc = sp.GetService(serviceType);
+ if (svc == null)
+ {
+ Console.WriteLine($" ❌ {label,-40} → NOT REGISTERED (null)");
+ return;
+ }
+ var shortName = svc.GetType().FullName?.Split('.').Last();
+ Console.WriteLine($" ✅ {label,-40} → {shortName}");
+ }
+ catch (Exception ex)
+ {
+ // Unwrap to the root cause for clarity.
+ var root = ex;
+ while (root.InnerException != null) root = root.InnerException;
+ Console.WriteLine($" ❌ {label,-40} → {root.GetType().Name}: {root.Message}");
+ }
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/ActivityManagerTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/ActivityManagerTests.cs
new file mode 100644
index 00000000..9be3bc0e
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/ActivityManagerTests.cs
@@ -0,0 +1,150 @@
+using System.IO;
+using System.Linq;
+using CActivity = Common.Activity.Activity;
+using KitX.Core;
+using KitX.Core.Activity;
+using LiteDB;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// G6 回归：ActivityManager 读取分页化 + 写入保留策略。
+/// 覆盖：倒序分页（Limit/Skip 组合）、limit<=0 全量、CountActivities、
+/// 超出上限裁剪最旧、清库后读取为空。
+/// 使用内存 LiteDB（:memory:），经 internal 测试构造注入，不触碰真实数据目录。
+/// 注意：LiteDB 对 int 主键 0 视为"未设置"并自动分配（从 1 起），
+/// 因此 Seed 的 Id 一律从 1 开始；Retention 用高位 Id 段避开
+/// NextActivityId 静态计数器生成的低位 Id。
+///
+public class ActivityManagerTests : IDisposable
+{
+ private const int SeedIdBase = 1_000_000;
+
+ private readonly LiteDatabase _db;
+
+ private readonly ActivityManager _manager;
+
+ public ActivityManagerTests()
+ {
+ _db = new LiteDatabase(":memory:");
+ _manager = new ActivityManager(_db);
+ }
+
+ public void Dispose()
+ {
+ // _manager owns _db (via the internal test ctor), so disposing the manager also
+ // releases the underlying :memory: LiteDB store.
+ _manager.Dispose();
+ }
+
+ private void Seed(int count, int idBase = 1)
+ {
+ var col = _db.GetCollection(ActivityManager.CollectionName);
+ for (var i = 0; i < count; i++)
+ col.Insert(new CActivity { Id = idBase + i, Name = $"A{i}", Author = "x", Title = "t", Category = "c" });
+ }
+
+ private ILiteCollection Collection => _db.GetCollection(ActivityManager.CollectionName);
+
+ [Fact]
+ public void ReadActivities_Pages_Newest_First()
+ {
+ Seed(10);
+
+ var page0 = _manager.ReadActivities(3, 0);
+ Assert.Equal(new[] { 10, 9, 8 }, page0.Select(a => a.Id));
+
+ var page1 = _manager.ReadActivities(3, 3);
+ Assert.Equal(new[] { 7, 6, 5 }, page1.Select(a => a.Id));
+
+ var last = _manager.ReadActivities(2, 8);
+ Assert.Equal(new[] { 2, 1 }, last.Select(a => a.Id));
+ }
+
+ [Fact]
+ public void ReadActivities_LimitZero_Returns_All_Newest_First()
+ {
+ Seed(5);
+
+ var all = _manager.ReadActivities();
+ Assert.Equal(5, all.Count);
+ Assert.Equal(new[] { 5, 4, 3, 2, 1 }, all.Select(a => a.Id));
+ }
+
+ [Fact]
+ public void CountActivities_Reflects_Store()
+ {
+ Seed(7);
+ Assert.Equal(7, _manager.CountActivities());
+ }
+
+ [Fact]
+ public void Retention_Policy_Trims_Oldest()
+ {
+ // 5,000 high-Id rows at the cap plus 1,000 older low-Id rows (over-cap excess).
+ // TrimToCap must delete exactly the oldest excess (smallest Ids) and settle the
+ // store at the cap. Deterministic by construction — no fire-and-forget write path.
+ Seed(1000, 1);
+ Seed(5000, SeedIdBase);
+ Assert.Equal(6000, Collection.LongCount());
+
+ _manager.TrimToCap();
+
+ Assert.Equal(5000, Collection.LongCount());
+ Assert.Equal(5000, _manager.CountActivities());
+
+ // The 1,000 oldest rows (Ids below SeedIdBase) were removed.
+ Assert.Equal(SeedIdBase, Collection.Query().OrderBy(a => a.Id).FirstOrDefault()!.Id);
+ Assert.Null(Collection.FindOne(a => a.Id < SeedIdBase));
+ }
+
+ [Fact]
+ public void TrimToCap_OnBoundedStore_IsNoOp()
+ {
+ Seed(100);
+ _manager.TrimToCap();
+ Assert.Equal(100, Collection.LongCount());
+ }
+
+ [Fact]
+ public void Clearing_The_Store_Reads_Empty()
+ {
+ Seed(5);
+ Assert.Equal(5, _manager.CountActivities());
+
+ Collection.DeleteAll();
+
+ Assert.Empty(_manager.ReadActivities());
+ Assert.Equal(0, _manager.CountActivities());
+ }
+
+ [Fact]
+ public void Constructor_CreatesDataDirectory_AndOpensDatabaseFile()
+ {
+ var dataDir = Path.GetFullPath(ConstantTable.DataPath);
+
+ // 清理上次运行可能残留的 Data 目录，保证初始断言成立。
+ if (Directory.Exists(dataDir))
+ Directory.Delete(dataDir, recursive: true);
+
+ try
+ {
+ var manager = new ActivityManager();
+
+ try
+ {
+ Assert.True(Directory.Exists(dataDir));
+ Assert.True(File.Exists(ConstantTable.ActivitiesDataBaseFilePath));
+ }
+ finally
+ {
+ manager.Dispose();
+ }
+ }
+ finally
+ {
+ if (Directory.Exists(dataDir))
+ Directory.Delete(dataDir, recursive: true);
+ }
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/AesSecurityTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/AesSecurityTests.cs
new file mode 100644
index 00000000..c3c96f5d
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/AesSecurityTests.cs
@@ -0,0 +1,68 @@
+using System.Security.Cryptography;
+using KitX.Core.Security;
+using KitX.Core.Test.Xunit.Fakes;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// SecurityManager.AesEncrypt / AesDecrypt 的测试。
+/// 覆盖：往返一致性、每次加密随机性（salt/IV）、错误密钥拒绝、短密文拒绝、空内容往返。
+///
+public class AesSecurityTests : IClassFixture
+{
+ private readonly SecurityManager _manager;
+
+ public AesSecurityTests(Fixture fixture) => _manager = fixture.Manager;
+
+ [Fact]
+ public void EncryptThenDecrypt_RestoresOriginal()
+ {
+ const string content = "KitX AES round trip 中文内容 #123";
+
+ var encrypted = _manager.AesEncrypt(content, "test-key");
+
+ Assert.NotEmpty(encrypted);
+ Assert.Equal(content, _manager.AesDecrypt(encrypted, "test-key"));
+ }
+
+ [Fact]
+ public void Encrypt_SameInputProducesDifferentCiphertext()
+ {
+ var first = _manager.AesEncrypt("same input", "same-key");
+ var second = _manager.AesEncrypt("same input", "same-key");
+
+ Assert.NotEqual(first, second);
+ }
+
+ [Fact]
+ public void Decrypt_WithWrongKey_ThrowsCryptographicException()
+ {
+ var encrypted = _manager.AesEncrypt("secret content", "correct-key");
+
+ Assert.ThrowsAny(() => _manager.AesDecrypt(encrypted, "wrong-key"));
+ }
+
+ [Fact]
+ public void Decrypt_TooShortCiphertext_ThrowsCryptographicException()
+ {
+ // 合法 Base64，但解码后仅 16 字节（< 32 字节的 salt + IV 下限）
+ var shortCiphertext = Convert.ToBase64String(new byte[16]);
+
+ Assert.ThrowsAny(() => _manager.AesDecrypt(shortCiphertext, "any-key"));
+ }
+
+ [Fact]
+ public void EncryptThenDecrypt_EmptyContent_RoundTrips()
+ {
+ var encrypted = _manager.AesEncrypt("", "test-key");
+
+ Assert.Equal("", _manager.AesDecrypt(encrypted, "test-key"));
+ }
+
+ public sealed class Fixture : IDisposable
+ {
+ public SecurityManager Manager { get; } = new(new FakeConfigService(), new FakeDeviceDiscoveryService());
+
+ public void Dispose() => Manager.Dispose();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DeviceConnectionClientTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DeviceConnectionClientTests.cs
new file mode 100644
index 00000000..cae67d19
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DeviceConnectionClientTests.cs
@@ -0,0 +1,234 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Security.Cryptography;
+using KitX.Core.Configuration;
+using KitX.Core.Contract.Plugin;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Device;
+using KitX.Core.Security;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Device;
+using KitX.Shared.CSharp.Plugin;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// 设备加密认证连接（DeviceConnectionClient ↔ DevicesServer）端到端测试。
+/// 覆盖：密钥交换→连接签发 token 全链路、错误密码重输环、未交换即连接被拒、签名往返。
+///
+public class DeviceConnectionClientTests : IDisposable
+{
+ private readonly SecurityManager _deviceB;
+ private readonly DeviceLocator _locatorB;
+ private readonly DevicesServer _serverB;
+ private readonly FakeEventService _eventServiceB;
+
+ private readonly SecurityManager _deviceA;
+ private readonly DeviceLocator _locatorA;
+ private readonly DeviceConnectionClient _clientA;
+ private readonly int _port;
+
+ public DeviceConnectionClientTests()
+ {
+ _port = GetFreePort();
+
+ // Device B (receiver): distinct identity + its own SecurityManager + running DevicesServer.
+ _deviceB = BuildDevice("DeviceB", "AA-BB-CC-DD-00-02", out _locatorB);
+ _eventServiceB = new FakeEventService();
+ _serverB = new DevicesServer(
+ _deviceB,
+ _deviceB,
+ _eventServiceB,
+ new FakePluginServer(),
+ new FakeDeviceDiscoveryService { DefaultDeviceInfo = new DeviceInfo { Device = _locatorB } });
+ _serverB.ConfigurePort(_port);
+ _serverB.Run();
+
+ // Device A (initiator): distinct identity + its own SecurityManager + outbound client.
+ _deviceA = BuildDevice("DeviceA", "AA-BB-CC-DD-00-01", out _locatorA);
+ _clientA = new DeviceConnectionClient(_deviceA, _deviceA);
+ }
+
+ private DeviceInfo TargetInfo() => new()
+ {
+ Device = _locatorB,
+ DevicesServerPort = _port
+ };
+
+ [Fact]
+ public async Task ExchangeThenConnect_IssuesSessionToken()
+ {
+ const string password = "12345678";
+
+ // Initiator A blocks until receiver B's user accepts the exchange.
+ var exchangeTask = _clientA.ExchangeKeyAsync(TargetInfo(), password);
+
+ await AcceptExchangeWithRetryAsync(password);
+
+ var result = await exchangeTask.WaitAsync(TimeSpan.FromSeconds(10));
+ Assert.True(result.Success, $"Exchange failed: {result.Error}");
+ Assert.NotNull(result.RemoteDeviceKey);
+
+ // A has now stored B's public key and can connect.
+ var token = await _clientA.ConnectAsync(TargetInfo());
+ Assert.False(string.IsNullOrEmpty(token), "ConnectAsync returned null");
+
+ // B considers A signed in and holds a token for A.
+ Assert.True(_serverB.IsDeviceSignedIn(_locatorA));
+ Assert.Equal(token, _serverB.GetDeviceToken(_locatorA));
+ }
+
+ [Fact]
+ public async Task Exchange_WrongPasswordThenCorrect_RepromptsAndSucceeds()
+ {
+ const string correct = "87654321";
+ const string wrong = "11111111";
+
+ var exchangeTask = _clientA.ExchangeKeyAsync(TargetInfo(), correct);
+
+ // First acceptance with a wrong password → decrypt fails → server re-prompts.
+ await AcceptExchangeWithRetryAsync(wrong);
+
+ // The receiver-side event must have been published again for re-entry.
+ Assert.True(_eventServiceB.WasPublished(KitX.Core.Contract.Event.EventNames.OnReceiveExchangeDeviceKey));
+
+ await AcceptExchangeWithRetryAsync(correct);
+
+ var result = await exchangeTask.WaitAsync(TimeSpan.FromSeconds(10));
+ Assert.True(result.Success, $"Exchange failed: {result.Error}");
+ }
+
+ [Fact]
+ public async Task ConnectWithoutExchange_ReturnsNull()
+ {
+ // A has not exchanged keys with B yet, so it has no public key for B.
+ var token = await _clientA.ConnectAsync(TargetInfo());
+ Assert.Null(token);
+ }
+
+ [Fact]
+ public void SignThenVerify_RoundTrips_AndWrongKeyRejected()
+ {
+ var signer = _deviceA.LocalDeviceKey!;
+ var signature = _deviceA.RsaSignString(signer, signer.Device.DeviceName);
+
+ Assert.False(string.IsNullOrEmpty(signature));
+
+ // Verify against the matching public key.
+ var publicOnly = new DeviceKey
+ {
+ Device = signer.Device,
+ RsaPublicKeyPem = signer.RsaPublicKeyPem
+ };
+ Assert.True(_deviceA.RsaVerifySignature(publicOnly, signer.Device.DeviceName, signature!));
+
+ // Verify against a different device's public key must fail.
+ var other = _deviceB.LocalDeviceKey!;
+ var otherPublicOnly = new DeviceKey
+ {
+ Device = other.Device,
+ RsaPublicKeyPem = other.RsaPublicKeyPem
+ };
+ Assert.False(_deviceA.RsaVerifySignature(otherPublicOnly, signer.Device.DeviceName, signature!));
+ }
+
+ [Fact]
+ public void IsSameDevice_IsCaseInsensitiveOnName()
+ {
+ // Regression: the WSL hostname ("StarInk") and Environment.MachineName ("STARINK")
+ // differ only in case. Device identity must not be case-sensitive, otherwise the
+ // local key lookup misses and the exchange fails with "Failed to get local key".
+ var a = new DeviceLocator { DeviceName = "STARINK", MacAddress = "505A654FBFDD" };
+ var b = new DeviceLocator { DeviceName = "StarInk", MacAddress = "50:5A:65:4F:BF:DD" };
+
+ Assert.True(a.IsSameDevice(b));
+ Assert.True(b.IsSameDevice(a));
+ }
+
+ ///
+ /// Builds a SecurityManager pre-seeded with a distinct device identity, so two
+ /// managers in one test process do not collide on the same machine locator.
+ ///
+ private static SecurityManager BuildDevice(string name, string mac, out DeviceLocator locator)
+ {
+ using var rsa = RSA.Create(2048);
+
+ locator = new DeviceLocator { DeviceName = name, MacAddress = mac, IPv4 = "127.0.0.1", IPv6 = "" };
+
+ var config = new SecurityConfig();
+ config.DeviceKeys.Add(new DeviceKeyImpl
+ {
+ Device = locator,
+ RsaPublicKeyPem = rsa.ExportRSAPublicKeyPem(),
+ RsaPrivateKeyPem = rsa.ExportRSAPrivateKeyPem(),
+ AddedAt = DateTime.Now
+ });
+
+ var discovery = new FakeDeviceDiscoveryService
+ {
+ DefaultDeviceInfo = new DeviceInfo { Device = locator }
+ };
+
+ return new SecurityManager(new FakeConfigService(securityConfig: config), discovery);
+ }
+
+ ///
+ /// Simulates receiver B's user entering the password, retrying until the server
+ /// has a pending exchange to accept (handles the accept/decrypt re-prompt race).
+ ///
+ private async Task AcceptExchangeWithRetryAsync(string password)
+ {
+ for (var i = 0; i < 200; i++)
+ {
+ if (_serverB.AcceptExchangeKey(password))
+ return;
+ await Task.Delay(25);
+ }
+
+ Assert.Fail("Timed out waiting to accept the key exchange.");
+ }
+
+ private static int GetFreePort()
+ {
+ var listener = new TcpListener(IPAddress.Loopback, 0);
+ listener.Start();
+ var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+ listener.Stop();
+ return port;
+ }
+
+ public void Dispose()
+ {
+ _serverB.Stop();
+ _deviceA.Dispose();
+ _deviceB.Dispose();
+ }
+
+ private sealed class FakePluginServer : IPluginServer
+ {
+ public int? Port => null;
+
+ public IReadOnlyList Connections => Array.Empty();
+
+ public IPluginServer Run() => this;
+
+ public void Stop() { }
+
+ public IPluginConnector? FindConnector(PluginInfo pluginInfo) => null;
+
+ public IPluginConnection? FindConnection(string connectionId) => null;
+
+ public event EventHandler? PortChanged;
+
+
+ public event EventHandler? PluginDisconnected;
+
+ public event EventHandler? PluginMessageReceived;
+
+ public event EventHandler? PluginRegistered;
+
+ public event EventHandler? PluginUnregistered;
+
+ public event EventHandler? PluginResponse;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesOrganizerTrustTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesOrganizerTrustTests.cs
new file mode 100644
index 00000000..1d92e6d4
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesOrganizerTrustTests.cs
@@ -0,0 +1,95 @@
+using KitX.Core;
+using KitX.Core.Configuration;
+using KitX.Core.Device;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Device;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// 设备信任收紧的测试（DevicesOrganizer 主设备让位逻辑）。
+/// 覆盖：未授权设备的伪造 IsMainDevice 广播不生效；已授权设备的主设备声明才触发让位。
+///
+public class DevicesOrganizerTrustTests : IDisposable
+{
+ private readonly bool _originalIsMainMachine;
+ private readonly DateTime _originalServerBuildTime;
+ private readonly string? _originalMainMachineAddress;
+ private readonly int _originalMainMachinePort;
+
+ public DevicesOrganizerTrustTests()
+ {
+ _originalIsMainMachine = ConstantTable.IsMainMachine;
+ _originalServerBuildTime = ConstantTable.ServerBuildTime;
+ _originalMainMachineAddress = ConstantTable.MainMachineAddress;
+ _originalMainMachinePort = ConstantTable.MainMachinePort;
+ }
+
+ public void Dispose()
+ {
+ ConstantTable.IsMainMachine = _originalIsMainMachine;
+ ConstantTable.ServerBuildTime = _originalServerBuildTime;
+ ConstantTable.MainMachineAddress = _originalMainMachineAddress;
+ ConstantTable.MainMachinePort = _originalMainMachinePort;
+ }
+
+ [Fact]
+ public void ForgedMainDeviceClaim_FromUnauthorizedDevice_DoesNotYield()
+ {
+ ConstantTable.ServerBuildTime = DateTime.UtcNow;
+ ConstantTable.IsMainMachine = true;
+ ConstantTable.MainMachineAddress = null;
+ ConstantTable.MainMachinePort = -1;
+
+ var (organizer, discovery, keys) = CreateOrganizer(authorized: false);
+ _ = organizer;
+ _ = keys;
+
+ discovery.RaiseDeviceDiscovered(ForgedMainDeviceInfo());
+
+ Assert.True(ConstantTable.IsMainMachine);
+ Assert.Null(ConstantTable.MainMachineAddress);
+ Assert.Equal(-1, ConstantTable.MainMachinePort);
+ }
+
+ [Fact]
+ public void MainDeviceClaim_FromAuthorizedDevice_Yields()
+ {
+ ConstantTable.ServerBuildTime = DateTime.UtcNow;
+ ConstantTable.IsMainMachine = true;
+
+ var (organizer, discovery, keys) = CreateOrganizer(authorized: true);
+ _ = organizer;
+ _ = keys;
+
+ discovery.RaiseDeviceDiscovered(ForgedMainDeviceInfo());
+
+ Assert.False(ConstantTable.IsMainMachine);
+ }
+
+ private static (DevicesOrganizer Organizer, FakeDeviceDiscoveryService Discovery, FakeDeviceKeyService Keys)
+ CreateOrganizer(bool authorized)
+ {
+ var config = new FakeConfigService();
+ ((AppConfig)config.AppConfig).Web.DevicesViewRefreshDelay = 3_600_000;
+
+ var discovery = new FakeDeviceDiscoveryService();
+ var keys = new FakeDeviceKeyService { Authorized = authorized };
+ var organizer = new DevicesOrganizer(config, new FakeEventService(), discovery, keys);
+ return (organizer, discovery, keys);
+ }
+
+ private static DeviceInfo ForgedMainDeviceInfo() => new()
+ {
+ Device = new DeviceLocator
+ {
+ DeviceName = "forged-device",
+ IPv4 = "192.168.1.100",
+ MacAddress = "AA-BB-CC-DD-EE-FF"
+ },
+ IsMainDevice = true,
+ DevicesServerBuildTime = DateTime.UtcNow.AddHours(-1),
+ DevicesServerPort = 8888,
+ SendTime = DateTime.UtcNow
+ };
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesServerTokenConcurrencyTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesServerTokenConcurrencyTests.cs
new file mode 100644
index 00000000..9452e44c
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/DevicesServerTokenConcurrencyTests.cs
@@ -0,0 +1,112 @@
+using KitX.Core.Contract.Plugin;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Device;
+using KitX.Core.Security;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Device;
+using KitX.Shared.CSharp.Plugin;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// DevicesServer 签入 token 字典的并发测试（C-3 回归）。
+/// 覆盖：并发签入/查询不抛异常且索引一致、同一设备并发签入返回同一 token。
+///
+public class DevicesServerTokenConcurrencyTests : IDisposable
+{
+ private readonly SecurityManager _securityManager;
+ private readonly DevicesServer _server;
+
+ public DevicesServerTokenConcurrencyTests()
+ {
+ // C-2 场景：同一 SecurityManager 实例同时充当两个接口
+ _securityManager = new SecurityManager(new FakeConfigService(), new FakeDeviceDiscoveryService());
+ _server = new DevicesServer(
+ _securityManager,
+ _securityManager,
+ new FakeEventService(),
+ new FakePluginServer(),
+ new FakeDeviceDiscoveryService());
+ }
+
+ [Fact]
+ public async Task ConcurrentSignInAndLookup_IsConsistent()
+ {
+ const int deviceCount = 64;
+ var locators = Enumerable.Range(0, deviceCount)
+ .Select(i => new DeviceLocator { DeviceName = $"Dev-{i}", MacAddress = $"AA-BB-CC-DD-{i:0000}" })
+ .ToArray();
+
+ // 并发签入
+ await Parallel.ForEachAsync(locators, async (locator, ct) =>
+ {
+ await Task.Yield();
+ var token = _server.SignInDevice(locator);
+ Assert.False(string.IsNullOrEmpty(token));
+ });
+
+ Assert.Equal(deviceCount, _server.GetSignedInDevices().Count);
+
+ // 并发按 token 反向查找 + 存在性检查，索引必须一致
+ await Parallel.ForEachAsync(locators, async (locator, ct) =>
+ {
+ await Task.Yield();
+ var token = _server.GetDeviceToken(locator);
+ Assert.NotNull(token);
+ Assert.True(_server.IsDeviceTokenExist(token));
+ Assert.True(locator.Equals(_server.SearchDeviceByToken(token)));
+ });
+ }
+
+ [Fact]
+ public async Task ConcurrentSignInSameDevice_ReturnsSameToken()
+ {
+ var locator = new DeviceLocator { DeviceName = "Same", MacAddress = "AA-BB-CC-DD-EE-99" };
+
+ var tokens = new string[32];
+ await Parallel.ForEachAsync(Enumerable.Range(0, tokens.Length), async (i, ct) =>
+ {
+ await Task.Yield();
+ tokens[i] = _server.SignInDevice(locator);
+ });
+
+ // 同一设备只保留一个 token，且能正常反向查找
+ Assert.All(tokens, t => Assert.Equal(tokens[0], t));
+ Assert.Single(_server.GetSignedInDevices());
+ Assert.True(locator.Equals(_server.SearchDeviceByToken(tokens[0])));
+ }
+
+ public void Dispose() => _securityManager.Dispose();
+
+ ///
+ /// 最小 IPluginServer 实现 —— 并发测试只使用 DevicesServer 的 token 索引 API，
+ /// 不触发任何插件连接逻辑。
+ ///
+ private sealed class FakePluginServer : IPluginServer
+ {
+ public int? Port => null;
+
+ public IReadOnlyList Connections => Array.Empty();
+
+ public IPluginServer Run() => this;
+
+ public void Stop() { }
+
+ public IPluginConnector? FindConnector(PluginInfo pluginInfo) => null;
+
+ public IPluginConnection? FindConnection(string connectionId) => null;
+
+ public event EventHandler? PortChanged;
+
+
+ public event EventHandler? PluginDisconnected;
+
+ public event EventHandler? PluginMessageReceived;
+
+ public event EventHandler? PluginRegistered;
+
+ public event EventHandler? PluginUnregistered;
+
+ public event EventHandler? PluginResponse;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EncryptStringAsyncSecurityTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EncryptStringAsyncSecurityTests.cs
new file mode 100644
index 00000000..2ca45a73
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EncryptStringAsyncSecurityTests.cs
@@ -0,0 +1,158 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using KitX.Core.Security;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Device;
+using KitX.Shared.CSharp.Security;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// SecurityManager.EncryptStringAsync 的测试（C-1 回归）。
+/// 覆盖：RSA-only 分支必须使用目标设备公钥（而非本机公钥）、长度判定基于
+/// UTF-8 字节数（中文多字节内容不越界）、混用分支仍可解密。
+///
+public class EncryptStringAsyncSecurityTests : IClassFixture
+{
+ private readonly SecurityManager _manager;
+ private readonly Fixture _fixture;
+
+ public EncryptStringAsyncSecurityTests(Fixture fixture)
+ {
+ _manager = fixture.Manager;
+ _fixture = fixture;
+ }
+
+ [Fact]
+ public async Task ShortContent_IsEncryptedWithTargetPublicKey()
+ {
+ const string content = "hello kitx";
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ // RSA-only 分支：flag 0
+ Assert.Equal(0, Convert.FromBase64String(encrypted)[0]);
+
+ // 目标私钥必须能解密 —— 这是 C-1 的核心回归（修复前用本机公钥，目标私钥解不开）
+ var decrypted = Decrypt(encrypted, _fixture.TargetPrivateKeyPem);
+ Assert.Equal(content, decrypted);
+ }
+
+ [Fact]
+ public async Task ShortAsciiAtBoundary_89Chars_IsRsaOnly()
+ {
+ // 89 个 ASCII 字节 < 90 → RSA-only
+ var content = new string('a', 89);
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ Assert.Equal(0, Convert.FromBase64String(encrypted)[0]);
+ Assert.Equal(content, Decrypt(encrypted, _fixture.TargetPrivateKeyPem));
+ }
+
+ [Fact]
+ public async Task ShortAsciiAtBoundary_90Chars_IsHybrid()
+ {
+ // 90 个 ASCII 字节 >= 90 → 混用分支
+ var content = new string('b', 90);
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ Assert.Equal(1, Convert.FromBase64String(encrypted)[0]);
+ Assert.Equal(content, Decrypt(encrypted, _fixture.TargetPrivateKeyPem));
+ }
+
+ [Fact]
+ public async Task ChineseShortContent_ByteBasedBranchSelection_IsRsaOnly()
+ {
+ // 29 个中文字符 = 87 UTF-8 字节 < 90 → RSA-only（按字符数 29 远小于 90，
+ // 但按旧判定两种方式都会走 RSA-only；关键是不能因字节数超 OAEP 上限而抛异常）
+ var content = new string('中', 29);
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ Assert.Equal(0, Convert.FromBase64String(encrypted)[0]);
+ Assert.Equal(content, Decrypt(encrypted, _fixture.TargetPrivateKeyPem));
+ }
+
+ [Fact]
+ public async Task ChineseBoundary_30Chars_90Bytes_IsHybrid()
+ {
+ // 30 个中文字符 = 90 字节 >= 90 → 混用分支
+ var content = new string('国', 30);
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ Assert.Equal(1, Convert.FromBase64String(encrypted)[0]);
+ Assert.Equal(content, Decrypt(encrypted, _fixture.TargetPrivateKeyPem));
+ }
+
+ [Fact]
+ public async Task ChineseLongContent_DoesNotOverflowRsaKey()
+ {
+ // 89 个中文字符 ≈ 267 字节，远超 2048-bit RSA-OAEP-SHA256 的 190 字节上限。
+ // 旧实现按字符数判定会误入 RSA-only 分支并抛 CryptographicException。
+ var content = new string('测', 89);
+
+ var encrypted = await _manager.EncryptStringAsync(content, Fixture.TargetMacAddress);
+
+ Assert.Equal(1, Convert.FromBase64String(encrypted)[0]);
+ Assert.Equal(content, Decrypt(encrypted, _fixture.TargetPrivateKeyPem));
+ }
+
+ [Fact]
+ public async Task UnknownTargetMac_Throws()
+ {
+ await Assert.ThrowsAsync(() =>
+ _manager.EncryptStringAsync("hello", "00:00:00:00:00:99"));
+ }
+
+ ///
+ /// 按输出 flag 分派解密：0=RSA-only（目标私钥直接解密），1=Hybrid（RSA+AES）。
+ ///
+ private string Decrypt(string encrypted, string targetPrivateKeyPem)
+ {
+ var bytes = Convert.FromBase64String(encrypted);
+ Assert.True(bytes.Length > 1);
+ var flag = bytes[0];
+ var payload = bytes[1..];
+
+ if (flag == 0)
+ {
+ using var rsa = RSA.Create(2048);
+ rsa.ImportFromPem(targetPrivateKeyPem);
+ return Encoding.UTF8.GetString(rsa.Decrypt(payload, RSAEncryptionPadding.OaepSHA256));
+ }
+
+ var json = Encoding.UTF8.GetString(payload);
+ var encryptedContent = JsonSerializer.Deserialize(json)
+ ?? throw new InvalidOperationException("Failed to deserialize encrypted content");
+ var key = new DeviceKey { RsaPrivateKeyPem = targetPrivateKeyPem };
+ return _manager.RsaDecryptContent(key, encryptedContent);
+ }
+
+ public sealed class Fixture : IDisposable
+ {
+ public const string TargetMacAddress = "AA-BB-CC-DD-EE-01";
+
+ public SecurityManager Manager { get; }
+
+ public string TargetPrivateKeyPem { get; }
+
+ public Fixture()
+ {
+ Manager = new SecurityManager(new FakeConfigService(), new FakeDeviceDiscoveryService());
+
+ // 生成"目标设备"的 RSA 密钥对，把公钥注册进 SecurityConfig
+ using var rsa = RSA.Create(2048);
+ TargetPrivateKeyPem = rsa.ExportRSAPrivateKeyPem();
+ var publicKeyPem = rsa.ExportRSAPublicKeyPem();
+
+ var added = Manager.AddDeviceKey(TargetMacAddress, "TestTarget", publicKeyPem);
+ Assert.True(added);
+ }
+
+ public void Dispose() => Manager.Dispose();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceMarshallingTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceMarshallingTests.cs
new file mode 100644
index 00000000..45fdfb0b
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceMarshallingTests.cs
@@ -0,0 +1,128 @@
+using KitX.Core.Contract.Event;
+using KitX.Core.Event;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// EventService 阶段0 加固回归：SynchronizationContext 自动编组 + 类型不匹配不再静默丢弃。
+///
+public class EventServiceMarshallingTests
+{
+ /// Records Post calls and executes the callback synchronously so assertions are deterministic.
+ private sealed class RecordingContext : SynchronizationContext
+ {
+ public int PostCount;
+ public override void Post(SendOrPostCallback d, object? state)
+ {
+ Interlocked.Increment(ref PostCount);
+ d(state);
+ }
+ }
+
+ private static IDisposable SetContext(SynchronizationContext? ctx)
+ {
+ var previous = SynchronizationContext.Current;
+ SynchronizationContext.SetSynchronizationContext(ctx);
+ return new RestoreContext(previous);
+ }
+
+ private sealed class RestoreContext(SynchronizationContext? previous) : IDisposable
+ {
+ public void Dispose() => SynchronizationContext.SetSynchronizationContext(previous);
+ }
+
+ [Fact]
+ public void Publish_OnDifferentContext_DispatchesViaCapturedContext()
+ {
+ var service = new EventService();
+ var ui = new RecordingContext();
+ var delivered = 0;
+
+ using (SetContext(ui))
+ service.Subscribe("test.marshal", (s, e) => delivered++);
+
+ // Publish from a different context (simulating a background thread).
+ using (SetContext(new SynchronizationContext()))
+ service.Publish("test.marshal", EventArgs.Empty);
+
+ Assert.Equal(1, delivered);
+ Assert.Equal(1, ui.PostCount);
+ }
+
+ [Fact]
+ public void Publish_OnSameContext_ExecutesSynchronously()
+ {
+ var service = new EventService();
+ var ui = new RecordingContext();
+ var delivered = 0;
+
+ using (SetContext(ui))
+ {
+ service.Subscribe("test.sync", (s, e) => delivered++);
+ service.Publish("test.sync", EventArgs.Empty);
+ }
+
+ Assert.Equal(1, delivered);
+ Assert.Equal(0, ui.PostCount); // same context → no marshalling
+ }
+
+ [Fact]
+ public void Publish_BackgroundSubscriber_ExecutesSynchronously()
+ {
+ var service = new EventService();
+ var delivered = 0;
+
+ // No SynchronizationContext on the subscribing thread → captured context is null.
+ using (SetContext(null))
+ service.Subscribe("test.bg", (s, e) => delivered++);
+
+ using (SetContext(new SynchronizationContext()))
+ service.Publish("test.bg", EventArgs.Empty);
+
+ Assert.Equal(1, delivered);
+ }
+
+ [Fact]
+ public void TypedSubscribe_TypeMismatch_LogsAndDrops_DoesNotThrow()
+ {
+ var service = new EventService();
+ var delivered = 0;
+
+ EventHandler handler = (s, e) => delivered++;
+ service.Subscribe("test.mismatch", handler);
+
+ // Publish EventArgs.Empty while the handler expects PortChangedEventArgs.
+ service.Publish("test.mismatch", EventArgs.Empty);
+
+ Assert.Equal(0, delivered); // dropped, but no exception
+ }
+
+ [Fact]
+ public void TypedSubscribe_TypeMismatch_ThrowOnTypeMismatch_Throws()
+ {
+ var service = new EventService { ThrowOnTypeMismatch = true };
+ var delivered = 0;
+
+ EventHandler handler = (s, e) => delivered++;
+ service.Subscribe("test.mismatch2", handler);
+
+ Assert.Throws(() =>
+ service.Publish("test.mismatch2", EventArgs.Empty));
+
+ Assert.Equal(0, delivered);
+ }
+
+ [Fact]
+ public void TypedSubscribe_TypeMatch_StillDelivers()
+ {
+ var service = new EventService();
+ var delivered = 0;
+
+ EventHandler handler = (s, e) => delivered++;
+ service.Subscribe("test.match", handler);
+
+ service.Publish("test.match", new PortChangedEventArgs { Port = 1 });
+
+ Assert.Equal(1, delivered);
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceRobustnessTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceRobustnessTests.cs
new file mode 100644
index 00000000..d1c55a3b
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceRobustnessTests.cs
@@ -0,0 +1,59 @@
+using KitX.Core.Contract.Event;
+using KitX.Core.Event;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// EventService 发布健壮性测试（C-14 回归）。
+/// 覆盖：单个处理器抛异常不中断后续处理器、重复订阅同一 (eventName, handler)
+/// 不会导致处理器被重复调用。
+///
+public class EventServiceRobustnessTests
+{
+ [Fact]
+ public void Publish_HandlerThrows_DoesNotBreakSubsequentHandlers()
+ {
+ var service = new EventService();
+ var delivered = new List();
+
+ service.Subscribe("test.event", (s, e) => throw new InvalidOperationException("boom"));
+ service.Subscribe("test.event", (s, e) => delivered.Add("second"));
+ service.Subscribe("test.event", (s, e) => delivered.Add("third"));
+
+ // 不应抛出异常
+ service.Publish("test.event", EventArgs.Empty);
+
+ Assert.Equal(new[] { "second", "third" }, delivered);
+ }
+
+ [Fact]
+ public void Subscribe_Twice_SameHandler_IsInvokedOnce()
+ {
+ var service = new EventService();
+ var callCount = 0;
+
+ EventHandler handler = (s, e) => callCount++;
+ service.Subscribe("test.typed", handler);
+ service.Subscribe("test.typed", handler);
+
+ service.Publish("test.typed", new PortChangedEventArgs { Port = 1 });
+
+ Assert.Equal(1, callCount);
+ }
+
+ [Fact]
+ public void Unsubscribe_Typed_RemovesHandler()
+ {
+ var service = new EventService();
+ var callCount = 0;
+
+ EventHandler handler = (s, e) => callCount++;
+ service.Subscribe("test.typed", handler);
+ service.Publish("test.typed", new PortChangedEventArgs { Port = 1 });
+
+ service.Unsubscribe("test.typed", handler);
+ service.Publish("test.typed", new PortChangedEventArgs { Port = 2 });
+
+ Assert.Equal(1, callCount);
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceTypedTopicTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceTypedTopicTests.cs
new file mode 100644
index 00000000..8cabc951
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/EventServiceTypedTopicTests.cs
@@ -0,0 +1,131 @@
+using KitX.Core.Contract.Event;
+using KitX.Core.Event;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// EventService 阶段1 回归：强类型话题 API（.NET 类型作 key，编译期类型安全）。
+///
+public class EventServiceTypedTopicTests
+{
+ private sealed record SamplePayload(int Value);
+
+ private sealed class RecordingContext : SynchronizationContext
+ {
+ public int PostCount;
+ public override void Post(SendOrPostCallback d, object? state)
+ {
+ Interlocked.Increment(ref PostCount);
+ d(state);
+ }
+ }
+
+ private static IDisposable SetContext(SynchronizationContext? ctx)
+ {
+ var previous = SynchronizationContext.Current;
+ SynchronizationContext.SetSynchronizationContext(ctx);
+ return new RestoreContext(previous);
+ }
+
+ private sealed class RestoreContext(SynchronizationContext? previous) : IDisposable
+ {
+ public void Dispose() => SynchronizationContext.SetSynchronizationContext(previous);
+ }
+
+ [Fact]
+ public void Publish_DeliversToSubscribers()
+ {
+ var service = new EventService();
+ var received = new List();
+
+ service.Subscribe(p => received.Add(p.Value));
+ service.Subscribe(p => received.Add(p.Value * 10));
+
+ service.Publish(new SamplePayload(7));
+
+ Assert.Equal(new[] { 7, 70 }, received);
+ }
+
+ [Fact]
+ public void Unsubscribe_RemovesHandler()
+ {
+ var service = new EventService();
+ var received = new List();
+
+ Action handler = p => received.Add(p.Value);
+ service.Subscribe(handler);
+ service.Publish(new SamplePayload(1));
+
+ service.Unsubscribe(handler);
+ service.Publish(new SamplePayload(2));
+
+ Assert.Equal(new[] { 1 }, received);
+ }
+
+ [Fact]
+ public void Subscribe_SameHandlerTwice_InvokedOnce()
+ {
+ var service = new EventService();
+ var count = 0;
+
+ Action handler = _ => count++;
+ service.Subscribe(handler);
+ service.Subscribe(handler);
+
+ service.Publish(new SamplePayload(0));
+
+ Assert.Equal(1, count);
+ }
+
+ [Fact]
+ public void Publish_OnDifferentContext_DispatchesViaCapturedContext()
+ {
+ var service = new EventService();
+ var ui = new RecordingContext();
+ var received = 0;
+
+ using (SetContext(ui))
+ service.Subscribe(_ => received++);
+
+ using (SetContext(new SynchronizationContext()))
+ service.Publish(new SamplePayload(0));
+
+ Assert.Equal(1, received);
+ Assert.Equal(1, ui.PostCount);
+ }
+
+ [Fact]
+ public void Publish_OnSameContext_ExecutesSynchronously()
+ {
+ var service = new EventService();
+ var ui = new RecordingContext();
+ var received = 0;
+
+ using (SetContext(ui))
+ {
+ service.Subscribe(_ => received++);
+ service.Publish(new SamplePayload(0));
+ }
+
+ Assert.Equal(1, received);
+ Assert.Equal(0, ui.PostCount);
+ }
+
+ [Fact]
+ public void TypedAndStringTopics_AreIsolated()
+ {
+ var service = new EventService();
+ var typedReceived = 0;
+ var stringReceived = 0;
+
+ // Same underlying type name used as both a string topic and a typed topic.
+ service.Subscribe(_ => typedReceived++);
+ service.Subscribe(typeof(SamplePayload).FullName!, (s, e) => stringReceived++);
+
+ service.Publish(new SamplePayload(0));
+ service.Publish(typeof(SamplePayload).FullName!, EventArgs.Empty);
+
+ Assert.Equal(1, typedReceived);
+ Assert.Equal(1, stringReceived);
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeConfigService.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeConfigService.cs
new file mode 100644
index 00000000..c708b479
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeConfigService.cs
@@ -0,0 +1,34 @@
+using KitX.Core.Configuration;
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Test.Xunit.Fakes;
+
+///
+/// 最小 IConfigService 实现：内存中的配置对象，SaveAll/Load/Reload 均为空操作，
+/// 不会触碰真实配置文件。
+///
+public class FakeConfigService : IConfigService
+{
+ public FakeConfigService(AppConfig? appConfig = null, SecurityConfig? securityConfig = null, PluginsConfig? pluginsConfig = null)
+ {
+ AppConfig = appConfig ?? new AppConfig();
+ SecurityConfig = securityConfig ?? new SecurityConfig();
+ PluginsConfig = pluginsConfig ?? new PluginsConfig();
+ }
+
+ public IAppConfig AppConfig { get; }
+
+ public IPluginsConf PluginsConfig { get; }
+
+ public ISecurityConf SecurityConfig { get; }
+
+ public void Load() { }
+
+ public void SaveAll() { }
+
+ public void Reload() { }
+
+#pragma warning disable CS0067
+ public event EventHandler? ConfigChanged;
+#pragma warning restore CS0067
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceDiscoveryService.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceDiscoveryService.cs
new file mode 100644
index 00000000..5ca4942e
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceDiscoveryService.cs
@@ -0,0 +1,35 @@
+using KitX.Core.Contract.Device;
+using KitX.Shared.CSharp.Device;
+
+namespace KitX.Core.Test.Xunit.Fakes;
+
+///
+/// 最小 IDeviceDiscoveryService 实现：可手动触发 DeviceDiscovered 事件，
+/// Run/Stop 为空操作。
+///
+public class FakeDeviceDiscoveryService : IDeviceDiscoveryService
+{
+ public DeviceInfo DefaultDeviceInfo { get; set; } = new()
+ {
+ Device = new DeviceLocator
+ {
+ DeviceName = "test-machine",
+ MacAddress = "00-11-22-33-44-55"
+ }
+ };
+
+ public int? Port { get; set; }
+
+ public event EventHandler? DeviceDiscovered;
+
+#pragma warning disable CS0067
+ public event EventHandler? DeviceOffline;
+#pragma warning restore CS0067
+
+ public IDeviceDiscoveryService Run() => this;
+
+ public void Stop() { }
+
+ public void RaiseDeviceDiscovered(DeviceInfo info) =>
+ DeviceDiscovered?.Invoke(this, new DeviceDiscoveredEventArgs { DeviceInfo = info });
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceKeyService.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceKeyService.cs
new file mode 100644
index 00000000..e368cc50
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeDeviceKeyService.cs
@@ -0,0 +1,28 @@
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Security;
+using KitX.Shared.CSharp.Device;
+
+namespace KitX.Core.Test.Xunit.Fakes;
+
+///
+/// 最小 IDeviceKeyService 实现：IsDeviceAuthorized 结果可通过 Authorized 字段配置，
+/// 其余成员返回默认值。
+///
+public class FakeDeviceKeyService : IDeviceKeyService
+{
+ public volatile bool Authorized;
+
+ public IReadOnlyList GetDeviceKeys() => Array.Empty();
+
+ public bool AddDeviceKey(string macAddress, string deviceName, string publicKey) => false;
+
+ public bool RemoveDeviceKey(string macAddress) => false;
+
+ public DeviceKey? SearchDeviceKey(DeviceLocator locator) => null;
+
+ public bool IsDeviceKeyCorrect(DeviceLocator locator, DeviceKey key) => false;
+
+ public bool IsDeviceAuthorized(DeviceLocator device) => Authorized;
+
+ public DeviceKey? GetPrivateDeviceKey() => null;
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeEventService.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeEventService.cs
new file mode 100644
index 00000000..ba89698a
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeEventService.cs
@@ -0,0 +1,35 @@
+using System.Collections.Concurrent;
+using KitX.Core.Contract.Event;
+
+namespace KitX.Core.Test.Xunit.Fakes;
+
+///
+/// 最小 IEventService 实现：订阅/发布均为空操作，并记录所有已发布的事件名。
+///
+public class FakeEventService : IEventService
+{
+ public ConcurrentBag PublishedEvents { get; } = new();
+
+ public void Subscribe(string eventName, EventHandler handler) { }
+
+ public void Unsubscribe(string eventName, EventHandler handler) { }
+
+ public void Publish(string eventName, EventArgs args) => PublishedEvents.Add(eventName);
+
+ public void Subscribe(string eventName, EventHandler handler)
+ where TEventArgs : EventArgs { }
+
+ public void Unsubscribe(string eventName, EventHandler handler)
+ where TEventArgs : EventArgs { }
+
+ public void Publish(string eventName, TEventArgs args)
+ where TEventArgs : EventArgs => PublishedEvents.Add(eventName);
+
+ public void Subscribe(Action handler) { }
+
+ public void Unsubscribe(Action handler) { }
+
+ public void Publish(TEvent payload) { }
+
+ public bool WasPublished(string eventName) => PublishedEvents.Contains(eventName);
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeWebSocketConnection.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeWebSocketConnection.cs
new file mode 100644
index 00000000..38d44800
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Fakes/FakeWebSocketConnection.cs
@@ -0,0 +1,48 @@
+using Fleck;
+
+namespace KitX.Core.Test.Xunit.Fakes;
+
+///
+/// In-memory used to drive a real
+/// without any network socket. The
+/// delegate is invoked directly by tests to feed message text through
+/// the real PluginConnection.OnMessage parsing path.
+///
+public sealed class FakeWebSocketConnection : IWebSocketConnection
+{
+ public Action? OnOpen { get; set; }
+ public Action? OnClose { get; set; }
+ public Action? OnMessage { get; set; }
+ public Action? OnBinary { get; set; }
+ public Action? OnPing { get; set; }
+ public Action? OnPong { get; set; }
+ public Action? OnError { get; set; }
+
+ public IWebSocketConnectionInfo ConnectionInfo { get; } = new FakeConnectionInfo();
+
+ public bool IsAvailable => true;
+
+ public Task Send(string message) => Task.CompletedTask;
+ public Task Send(byte[] message) => Task.CompletedTask;
+ public Task SendPing(byte[] message) => Task.CompletedTask;
+ public Task SendPong(byte[] message) => Task.CompletedTask;
+ public void Close() { }
+ public void Close(int code) { }
+
+ /// Feeds one message through the real OnMessage handler.
+ public void Deliver(string message) => OnMessage?.Invoke(message);
+
+ private sealed class FakeConnectionInfo : IWebSocketConnectionInfo
+ {
+ public string SubProtocol => string.Empty;
+ public string Origin => string.Empty;
+ public string Host => string.Empty;
+ public string Path => string.Empty;
+ public string ClientIpAddress => "127.0.0.1";
+ public int ClientPort => 0;
+ public IDictionary Cookies { get; } = new Dictionary();
+ public IDictionary Headers { get; } = new Dictionary();
+ public Guid Id => Guid.NewGuid();
+ public string NegotiatedSubProtocol => string.Empty;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KitX.Core.Test.Xunit.csproj b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KitX.Core.Test.Xunit.csproj
new file mode 100644
index 00000000..9bdb895d
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KitX.Core.Test.Xunit.csproj
@@ -0,0 +1,23 @@
+
+
+
+ net10.0
+ enable
+ enable
+ false
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KxpDecoderSecurityTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KxpDecoderSecurityTests.cs
new file mode 100644
index 00000000..59458210
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/KxpDecoderSecurityTests.cs
@@ -0,0 +1,144 @@
+using System.Security.Cryptography;
+using System.Text;
+using ExtensionsPackageDecoder = KitX.FileFormats.CSharp.ExtensionsPackage.Decoder;
+using ExtensionsPackageEncoder = KitX.FileFormats.CSharp.ExtensionsPackage.Encoder;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// KXP 解包路径穿越安全修复的测试（Decoder.Decode 路径校验）。
+/// 覆盖：相对路径穿越（../）、绝对路径文件名（Windows / POSIX 风格）被拒绝且不产出文件，
+/// 合法包正常解包。
+///
+public class KxpDecoderSecurityTests
+{
+ private const string KxpHeader = "It is a KXP file";
+
+ [Theory]
+ [InlineData("../evil.txt")]
+ [InlineData("..\\evil.txt")]
+ [InlineData("sub/../../evil.txt")]
+ public void Decode_TraversalFileName_ThrowsAndWritesNothing(string fileName)
+ {
+ var root = CreateTempDir();
+ try
+ {
+ var packagePath = Path.Combine(root, "malicious.kxp");
+ File.WriteAllBytes(packagePath, BuildPackage([(fileName, Encoding.UTF8.GetBytes("pwned"))]));
+
+ var releaseFolder = Path.Combine(root, "release");
+ Directory.CreateDirectory(releaseFolder);
+
+ var ex = Assert.Throws(() => new ExtensionsPackageDecoder(packagePath).Decode(releaseFolder));
+
+ Assert.Contains("Invalid file path", ex.Message);
+ Assert.Empty(Directory.GetFiles(releaseFolder, "*", SearchOption.AllDirectories));
+ Assert.False(File.Exists(Path.Combine(root, "evil.txt")));
+ Assert.False(File.Exists(Path.Combine(Path.GetDirectoryName(root)!, "evil.txt")));
+ }
+ finally
+ {
+ Directory.Delete(root, true);
+ }
+ }
+
+ [Theory]
+ [InlineData("C:\\Windows\\evil.txt")]
+ [InlineData("C:/evil.txt")]
+ [InlineData("/etc/evil")]
+ public void Decode_AbsoluteFileName_ThrowsAndWritesNothing(string fileName)
+ {
+ var root = CreateTempDir();
+ try
+ {
+ var packagePath = Path.Combine(root, "malicious.kxp");
+ File.WriteAllBytes(packagePath, BuildPackage([(fileName, Encoding.UTF8.GetBytes("pwned"))]));
+
+ var releaseFolder = Path.Combine(root, "release");
+ Directory.CreateDirectory(releaseFolder);
+
+ var ex = Assert.Throws(() => new ExtensionsPackageDecoder(packagePath).Decode(releaseFolder));
+
+ Assert.Contains("Invalid file path", ex.Message);
+ Assert.Empty(Directory.GetFiles(releaseFolder, "*", SearchOption.AllDirectories));
+ }
+ finally
+ {
+ Directory.Delete(root, true);
+ }
+ }
+
+ [Fact]
+ public void Decode_ValidPackage_ExtractsFiles()
+ {
+ var root = CreateTempDir();
+ try
+ {
+ var sourceFile = Path.Combine(root, "data.txt");
+ File.WriteAllText(sourceFile, "hello kxp");
+
+ var encoder = new ExtensionsPackageEncoder([sourceFile], "loader-struct", "plugin-struct");
+ encoder.Encode(root + Path.DirectorySeparatorChar, root, "good");
+
+ var packagePath = Path.Combine(root, "good.kxp");
+ var releaseFolder = Path.Combine(root, "release");
+
+ var (loader, plugin) = new ExtensionsPackageDecoder(packagePath).Decode(releaseFolder);
+
+ Assert.Equal("loader-struct", loader);
+ Assert.Equal("plugin-struct", plugin);
+ Assert.Equal("hello kxp", File.ReadAllText(Path.Combine(releaseFolder, "data.txt")));
+ }
+ finally
+ {
+ Directory.Delete(root, true);
+ }
+ }
+
+ private static string CreateTempDir()
+ {
+ var dir = Path.Combine(Path.GetTempPath(), $"kitx-kxp-test-{Guid.NewGuid():N}");
+ Directory.CreateDirectory(dir);
+ return dir;
+ }
+
+ ///
+ /// 手写构造 kxp 包：16B 头 + 16B MD5（32 字节之后全部内容）+ 结构段 + 文件表 + 文件体。
+ /// 文件名可以任意指定（包括恶意路径），MD5 按 Decoder 的校验方式正确计算。
+ ///
+ private static byte[] BuildPackage(
+ IEnumerable<(string FileName, byte[] Body)> files,
+ string loader = "loader",
+ string plugin = "plugin")
+ {
+ var loaderBytes = Encoding.UTF8.GetBytes(loader);
+ var pluginBytes = Encoding.UTF8.GetBytes(plugin);
+ var fileMap = files.Select(f => (NameBytes: Encoding.UTF8.GetBytes(f.FileName), f.Body)).ToList();
+
+ var body = new List();
+ body.AddRange(BitConverter.GetBytes((long)loaderBytes.Length));
+ body.AddRange(loaderBytes);
+ body.AddRange(BitConverter.GetBytes((long)pluginBytes.Length));
+ body.AddRange(pluginBytes);
+ body.AddRange(BitConverter.GetBytes((long)fileMap.Count));
+ foreach (var item in fileMap)
+ {
+ body.AddRange(BitConverter.GetBytes((long)item.NameBytes.Length));
+ body.AddRange(BitConverter.GetBytes((long)item.Body.Length));
+ }
+ foreach (var item in fileMap)
+ {
+ body.AddRange(item.NameBytes);
+ body.AddRange(item.Body);
+ }
+
+ var bodyArray = body.ToArray();
+ var hash = MD5.HashData(bodyArray);
+
+ var result = new byte[32 + bodyArray.Length];
+ Encoding.ASCII.GetBytes(KxpHeader).CopyTo(result, 0);
+ hash.CopyTo(result, 16);
+ bodyArray.CopyTo(result, 32);
+ return result;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginConnectionMessageSharingTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginConnectionMessageSharingTests.cs
new file mode 100644
index 00000000..8ccfd123
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginConnectionMessageSharingTests.cs
@@ -0,0 +1,112 @@
+using System.Text;
+using System.Text.Json;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Device;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Plugin;
+using KitX.Shared.CSharp.WebCommand;
+using KitX.Shared.CSharp.WebCommand.Infos;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// Verifies that parses each incoming message once and shares the
+/// parsed / with downstream handlers through
+/// (G1 parse-once), while responses continue to
+/// flow exclusively through the channel.
+///
+public class PluginConnectionMessageSharingTests
+{
+ private static string CommandMessage(string request, Dictionary? tags = null,
+ byte[]? body = null, int bodyLength = 0)
+ {
+ var command = new Command
+ {
+ Request = request,
+ Tags = tags ?? new Dictionary(),
+ Body = body ?? Array.Empty(),
+ BodyLength = bodyLength,
+ };
+ return JsonSerializer.Serialize(new Request { Content = JsonSerializer.Serialize(command) });
+ }
+
+ private static string RegisterPluginMessage(string pluginName)
+ {
+ var pluginInfo = JsonSerializer.Serialize(new PluginInfo { Name = pluginName });
+ var body = Encoding.UTF8.GetBytes(pluginInfo);
+ return CommandMessage(CommandRequestInfo.RegisterPlugin, null, body, body.Length);
+ }
+
+ private static (FakeWebSocketConnection Sock, PluginConnection Connection) CreateConnection()
+ {
+ var sock = new FakeWebSocketConnection();
+ var connection = new PluginConnection(sock, Guid.NewGuid().ToString());
+ connection.Initialize();
+ return (sock, connection);
+ }
+
+ [Fact]
+ public void NormalCommand_ForwardsMessageReceived_WithParsedRequestAndCommand()
+ {
+ var (sock, connection) = CreateConnection();
+ PluginMessageReceivedEventArgs? received = null;
+ connection.MessageReceived += (_, e) => received = e;
+
+ sock.Deliver(CommandMessage("SayHello", new() { ["msg"] = "hi" }));
+
+ Assert.NotNull(received);
+ Assert.Equal(connection.ConnectionId, received!.ConnectionId);
+ Assert.NotNull(received.Request);
+ Assert.NotNull(received.Command);
+ Assert.False(received.IsResponse);
+ Assert.Equal("SayHello", received.Command!.Value.Request);
+ Assert.Equal("hi", received.Command.Value.Tags["msg"]);
+ }
+
+ [Fact]
+ public void RegisterPlugin_ForwardsMessageReceived_WithParsedRegisterCommand()
+ {
+ var (sock, connection) = CreateConnection();
+ PluginMessageReceivedEventArgs? received = null;
+ connection.MessageReceived += (_, e) => received = e;
+
+ sock.Deliver(RegisterPluginMessage("MyPlugin"));
+
+ Assert.NotNull(received);
+ Assert.NotNull(received!.Command);
+ Assert.Equal(CommandRequestInfo.RegisterPlugin, received.Command.Value.Request);
+ // The plugin-info body is preserved so PluginsServer can register without re-parsing.
+ Assert.True(received.Command.Value.BodyLength > 0);
+ }
+
+ [Fact]
+ public void TriggerFired_ForwardsMessageReceived_WithParsedCommand()
+ {
+ var (sock, connection) = CreateConnection();
+ PluginMessageReceivedEventArgs? received = null;
+ connection.MessageReceived += (_, e) => received = e;
+
+ sock.Deliver(CommandMessage(CommandRequestInfo.TriggerFired, new() { ["TriggerName"] = "t1" }));
+
+ Assert.NotNull(received);
+ Assert.NotNull(received!.Command);
+ Assert.Equal(CommandRequestInfo.TriggerFired, received.Command.Value.Request);
+ Assert.Equal("t1", received.Command.Value.Tags["TriggerName"]);
+ }
+
+ [Fact]
+ public void ResponseWithRequestId_RaisesPluginResponse_AndNotMessageReceived()
+ {
+ var (sock, connection) = CreateConnection();
+ PluginResponseEventArgs? response = null;
+ var messageReceivedRaised = false;
+ connection.PluginResponse += (_, e) => response = e;
+ connection.MessageReceived += (_, _) => messageReceivedRaised = true;
+
+ sock.Deliver(CommandMessage("AnyCommand", new() { ["RequestId"] = "r-123" }));
+
+ Assert.NotNull(response);
+ Assert.Equal("r-123", response!.RequestId);
+ Assert.False(messageReceivedRaised, "A response must not be forwarded as a plugin message.");
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginLifecycleConcurrencyTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginLifecycleConcurrencyTests.cs
new file mode 100644
index 00000000..e654153c
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginLifecycleConcurrencyTests.cs
@@ -0,0 +1,331 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text.Json;
+using Kscript.CSharp.Parser.Core;
+using Kscript.CSharp.Parser.Models;
+using KitX.Core.Contract.Plugin;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Device;
+using KitX.Core.Plugin;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Plugin;
+using ServerStatus = KitX.Core.Contract.Device.ServerStatus;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// C-7/C-8: PluginsManager 并发安全（ConcurrentDictionary 快照）与 loader 进程
+/// Exited 清理。C-9: PluginsServer 按 Name 查找连接。C-11: PluginHostAdapter
+/// 9 个函数的真实桥接（fake 服务注入）。
+///
+public class PluginLifecycleConcurrencyTests
+{
+ // ── C-7: 并发访问不抛 InvalidOperationException ──
+
+ [Fact]
+ public async Task ConcurrentAccess_NoInvalidOperationException()
+ {
+ var manager = new PluginsManager();
+ var pluginsField = GetField(manager, "_plugins");
+ var byNameField = GetField(manager, "_pluginsByName");
+ var plugins = (ConcurrentDictionary)pluginsField.GetValue(manager)!;
+ var byName = (ConcurrentDictionary)byNameField.GetValue(manager)!;
+
+ var seeded = new List();
+ for (var i = 0; i < 4; i++)
+ {
+ var info = new PluginInfo
+ {
+ Name = $"demo{i}",
+ Version = "1.0.0",
+ PublisherName = "pub",
+ AuthorName = "author"
+ };
+ var installation = new PluginInstallation
+ {
+ Id = PluginsManager.GeneratePluginId(info),
+ InstallPath = null,
+ PluginInfo = info,
+ LoaderInfo = new KitX.Shared.CSharp.Loader.LoaderInfo()
+ };
+ plugins[installation.Id] = installation;
+ byName[info.Name] = installation;
+ seeded.Add(installation);
+ }
+
+ var errors = new ConcurrentBag();
+
+ var tasks = Enumerable.Range(0, 8).Select(worker =>
+ Task.Run(() =>
+ {
+ var random = new Random(worker);
+ for (var i = 0; i < 300; i++)
+ {
+ try
+ {
+ switch (i % 5)
+ {
+ case 0:
+ manager.OnPluginStatusChanged($"demo{random.Next(seeded.Count)}",
+ PluginStatus.Running);
+ break;
+ case 1:
+ _ = manager.GetInstalledPlugins();
+ break;
+ case 2:
+ _ = manager.Plugins;
+ break;
+ case 3:
+ _ = manager.GetPlugin(seeded[random.Next(seeded.Count)].Id);
+ break;
+ case 4:
+ manager.OnPluginStatusChanged($"demo{random.Next(seeded.Count)}",
+ PluginStatus.Stopped);
+ break;
+ }
+ }
+ catch (Exception ex)
+ {
+ errors.Add(ex);
+ }
+ }
+ })).ToArray();
+
+ await Task.WhenAll(tasks);
+
+ Assert.Empty(errors);
+
+ // Status changes must be visible through the snapshot API afterwards.
+ manager.OnPluginStatusChanged("demo0", PluginStatus.Running);
+ var running = manager.GetInstalledPlugins().FirstOrDefault(p => p.PluginInfo?.Name == "demo0");
+ Assert.NotNull(running);
+ Assert.True(((PluginInstallation)running!).IsRunning);
+ }
+
+ // ── C-8: 进程退出后条目清理 + 状态复位 ──
+
+ [Fact]
+ public void LoaderProcessExit_CleansUpAndResetsState()
+ {
+ var manager = new PluginsManager();
+ var pluginsField = GetField(manager, "_plugins");
+ var processesField = GetField(manager, "_pluginProcesses");
+ var handlerMethod = typeof(PluginsManager).GetMethod("HandleLoaderProcessExit",
+ BindingFlags.NonPublic | BindingFlags.Instance)!;
+ var plugins = (ConcurrentDictionary)pluginsField.GetValue(manager)!;
+ var processes = (ConcurrentDictionary)processesField.GetValue(manager)!;
+
+ var info = new PluginInfo { Name = "crashy", Version = "1.0.0" };
+ var installation = new PluginInstallation
+ {
+ Id = PluginsManager.GeneratePluginId(info),
+ PluginInfo = info,
+ InstallPath = null,
+ LoaderInfo = new KitX.Shared.CSharp.Loader.LoaderInfo()
+ };
+ plugins[installation.Id] = installation;
+ installation.IsRunning = true;
+
+ var statusEvents = new List();
+ manager.PluginStatusChanged += (_, e) => statusEvents.Add(e);
+
+ // A real process that exits quickly — simulates a crashed loader.
+ using var exitedProcess = new Process
+ {
+ StartInfo = new ProcessStartInfo("cmd.exe", "/c exit 0")
+ {
+ UseShellExecute = false,
+ CreateNoWindow = true
+ }
+ };
+ exitedProcess.EnableRaisingEvents = true;
+ Assert.True(exitedProcess.Start());
+ exitedProcess.WaitForExit();
+
+ processes[installation.Id] = exitedProcess;
+
+ handlerMethod.Invoke(manager, new object[] { installation.Id, "crashy" });
+
+ Assert.False(installation.IsRunning);
+ Assert.False(processes.ContainsKey(installation.Id), "进程条目应在 Exited 处理后被清除");
+ Assert.Single(statusEvents);
+ Assert.Equal(PluginStatus.Running, statusEvents[0].OldStatus);
+ Assert.Equal(PluginStatus.Stopped, statusEvents[0].NewStatus);
+
+ // 去重：再次触发（例如 WebSocket 关闭通知）不应重复发布状态变更。
+ handlerMethod.Invoke(manager, new object[] { installation.Id, "crashy" });
+ Assert.Single(statusEvents);
+ }
+
+ // ── C-9: FindConnection(PluginInfo) 按 Name 匹配 ──
+
+ [Fact]
+ public void FindConnectionByPluginInfo_MatchesByName_NotByReference()
+ {
+ var server = new PluginsServer(new FakeEventService());
+ var connectionsField = typeof(PluginsServer).GetField("_connections",
+ BindingFlags.NonPublic | BindingFlags.Instance)!;
+ var connections = (ConcurrentDictionary)connectionsField.GetValue(server)!;
+
+ var registered = new PluginInfo
+ {
+ Name = "alpha",
+ Version = "1.0.0",
+ Tags = new Dictionary
+ {
+ ["ConnectionId"] = Guid.NewGuid().ToString(),
+ ["JoinTime"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss(FF)")
+ }
+ };
+ var conn = new FakePluginConnection("conn-1", registered);
+ connections["conn-1"] = conn;
+
+ // 不同实例、不同 Tags —— 旧引用比较恒返回 null。
+ var query = new PluginInfo { Name = "alpha", Version = "9.9.9" };
+
+ var found = server.FindConnection(query);
+ Assert.Same(conn, found);
+ Assert.Same(conn, server.FindConnector(query));
+ }
+
+ // ── C-11: PluginHostAdapter 9 函数桥接 ──
+
+ [Fact]
+ public void PluginHostAdapter_PluginFunctions_BridgeToPluginService()
+ {
+ var pluginService = new FakePluginService();
+ var alpha = pluginService.Add("alpha", "1.0.0");
+ var beta = pluginService.Add("beta", "2.0.0");
+
+ var adapter = new PluginHostAdapter(
+ new FakePluginManager(),
+ pluginService);
+
+ // StartPlugin / StopPlugin
+ Assert.True(adapter.StartPlugin("alpha"));
+ Assert.Equal(alpha.Id, pluginService.LastStartedId);
+ Assert.True(adapter.StopPlugin("alpha"));
+ Assert.Equal(alpha.Id, pluginService.LastStoppedId);
+ Assert.False(adapter.StartPlugin("missing"));
+
+ // InstallPlugin
+ Assert.True(adapter.InstallPlugin(@"C:\tmp\demo.kxp"));
+ Assert.Equal(@"C:\tmp\demo.kxp", pluginService.LastImportPath);
+ pluginService.ImportResult = false;
+ Assert.False(adapter.InstallPlugin(@"C:\tmp\bad.kxp"));
+
+ // GetPluginInfoByName — JSON 序列化的 PluginInfo
+ var json = adapter.GetPluginInfoByName("beta");
+ Assert.Contains("\"beta\"", json);
+ Assert.Contains("2.0.0", json);
+ Assert.Equal(string.Empty, adapter.GetPluginInfoByName("missing"));
+
+ // ListPluginNames — JSON 数组
+ var names = JsonSerializer.Deserialize>(adapter.ListPluginNames());
+ Assert.NotNull(names);
+ Assert.Equal(new[] { "alpha", "beta" }, names.OrderBy(n => n));
+
+ // 未注入 pluginService 时安全降级
+ var bare = new PluginHostAdapter(new FakePluginManager());
+ Assert.False(bare.StartPlugin("alpha"));
+ Assert.False(bare.InstallPlugin("x.kxp"));
+ Assert.Equal("[]", bare.ListPluginNames());
+ Assert.Equal(string.Empty, bare.GetPluginInfoByName("alpha"));
+ }
+
+ // ── Fakes ──
+
+ private static FieldInfo GetField(object instance, string name) =>
+ instance.GetType().GetField(name, BindingFlags.NonPublic | BindingFlags.Instance)!;
+
+ private sealed class FakePluginManager : IPluginManager
+ {
+ public T Call(PluginCallInfo callInfo) => default!;
+ public void Call(PluginCallInfo callInfo) { }
+ public bool IsPluginExists(string pluginName) => false;
+ public bool IsMethodExists(string pluginName, string methodName) => false;
+ }
+
+ private sealed class FakePluginService : IPluginService
+ {
+ private readonly List _installed = new();
+
+ public Guid? LastStartedId { get; private set; }
+ public Guid? LastStoppedId { get; private set; }
+ public string? LastImportPath { get; private set; }
+ public bool ImportResult { get; set; } = true;
+
+ public event EventHandler? PluginStatusChanged;
+
+ public PluginInstallation Add(string name, string version)
+ {
+ var info = new PluginInfo { Name = name, Version = version, PublisherName = "p", AuthorName = "a" };
+ var installation = new PluginInstallation
+ {
+ Id = PluginsManager.GeneratePluginId(info),
+ PluginInfo = info,
+ InstallPath = null,
+ LoaderInfo = new KitX.Shared.CSharp.Loader.LoaderInfo()
+ };
+ _installed.Add(installation);
+ return installation;
+ }
+
+ public IReadOnlyList GetInstalledPlugins() => _installed.ToList();
+
+ public IPluginInstallation? GetPlugin(Guid pluginId) =>
+ _installed.FirstOrDefault(p => p.Id == pluginId);
+
+ public Task ImportPluginAsync(string kxpFilePath)
+ {
+ LastImportPath = kxpFilePath;
+ return Task.FromResult(ImportResult);
+ }
+
+ public Task RemovePluginAsync(Guid pluginId)
+ {
+ _installed.RemoveAll(p => p.Id == pluginId);
+ return Task.FromResult(true);
+ }
+
+ public Task StartPluginAsync(Guid pluginId)
+ {
+ LastStartedId = pluginId;
+ return Task.FromResult(_installed.Any(p => p.Id == pluginId));
+ }
+
+ public Task StopPluginAsync(Guid pluginId)
+ {
+ LastStoppedId = pluginId;
+ return Task.FromResult(true);
+ }
+
+ public Task CallPluginFunctionAsync(Guid pluginId, string functionName,
+ Dictionary? parameters = null) => Task.FromResult(null);
+ }
+
+ private sealed class FakePluginConnection : IPluginConnection
+ {
+ public FakePluginConnection(string connectionId, PluginInfo pluginInfo)
+ {
+ ConnectionId = connectionId;
+ PluginInfo = pluginInfo;
+ }
+
+ public string? ConnectionId { get; }
+ public PluginInfo? PluginInfo { get; set; }
+ public ServerStatus Status => ServerStatus.Running;
+
+ public event EventHandler? MessageReceived;
+ public event EventHandler? Closed;
+ public event EventHandler? PluginResponse;
+ public event EventHandler? StatusReport;
+
+ public void Initialize() { }
+ public void Send(string message) { }
+ public void Request(object request) { }
+ public Task CloseAsync() => Task.CompletedTask;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerParseOnceTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerParseOnceTests.cs
new file mode 100644
index 00000000..dacc4152
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerParseOnceTests.cs
@@ -0,0 +1,198 @@
+using System.Collections.Concurrent;
+using System.Net;
+using System.Net.Sockets;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using KitX.Core.Contract.Event;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Device;
+using KitX.Core.Test.Xunit.Fakes;
+using KitX.Shared.CSharp.Plugin;
+using KitX.Shared.CSharp.WebCommand;
+using KitX.Shared.CSharp.WebCommand.Infos;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// End-to-end tests over a real WebSocket verifying the G1 parse-once chain: a message is parsed
+/// by and the parsed /
+/// are shared down to the event, while behavior
+/// (registration, response routing) stays equivalent to the pre-refactor chain.
+///
+public class PluginsServerParseOnceTests
+{
+ private static string CommandMessage(string request, Dictionary? tags = null,
+ byte[]? body = null, int bodyLength = 0)
+ {
+ var command = new Command
+ {
+ Request = request,
+ Tags = tags ?? new Dictionary(),
+ Body = body ?? Array.Empty(),
+ BodyLength = bodyLength,
+ };
+ return JsonSerializer.Serialize(new Request { Content = JsonSerializer.Serialize(command) });
+ }
+
+ private static string RegisterPluginMessage(string pluginName)
+ {
+ var pluginInfo = JsonSerializer.Serialize(new PluginInfo { Name = pluginName });
+ var body = Encoding.UTF8.GetBytes(pluginInfo);
+ return CommandMessage(CommandRequestInfo.RegisterPlugin, null, body, body.Length);
+ }
+
+ private static async Task ConnectAsync(int port, string connectionId, CancellationToken ct)
+ {
+ var client = new ClientWebSocket();
+ await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/{connectionId}"), ct);
+ return client;
+ }
+
+ private static Task SendAsync(ClientWebSocket client, string message, CancellationToken ct)
+ => client.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, ct);
+
+ [Fact]
+ public async Task RegisterPlugin_RegistersPlugin_AndPluginMessageReceivedCarriesParsedResults()
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ var received = new ConcurrentQueue();
+ server.PluginMessageReceived += (_, e) => received.Enqueue(e);
+
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+ Assert.NotNull(server.Port);
+
+ var connectionId = Guid.NewGuid().ToString();
+ using var client = await ConnectAsync(server.Port!.Value, connectionId, CancellationToken.None);
+
+ var pluginName = "ParseOncePlugin";
+ var message = RegisterPluginMessage(pluginName);
+ await SendAsync(client, message, CancellationToken.None);
+
+ var registered = await WaitUntilAsync(
+ () => eventService.WasPublished(EventNames.PluginRegistered),
+ TimeSpan.FromSeconds(5));
+ Assert.True(registered, "RegisterPlugin message did not produce a PluginRegistered event.");
+
+ var connection = server.FindConnection(connectionId);
+ Assert.NotNull(connection);
+ Assert.Equal(pluginName, connection!.PluginInfo?.Name);
+
+ // PluginMessageReceived must carry the already-parsed result consistent with the raw message.
+ var args = received.SingleOrDefault(e => e.Message == message);
+ Assert.NotNull(args);
+ Assert.Equal(connectionId, args!.ConnectionId);
+ Assert.NotNull(args.Request);
+ Assert.NotNull(args.Command);
+ Assert.False(args.IsResponse);
+ Assert.Equal(CommandRequestInfo.RegisterPlugin, args.Command!.Value.Request);
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ [Fact]
+ public async Task NormalCommand_PluginMessageReceivedCarriesParsedResults()
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ var received = new ConcurrentQueue();
+ server.PluginMessageReceived += (_, e) => received.Enqueue(e);
+
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+ Assert.NotNull(server.Port);
+
+ var connectionId = Guid.NewGuid().ToString();
+ using var client = await ConnectAsync(server.Port!.Value, connectionId, CancellationToken.None);
+
+ var message = CommandMessage("SayHello", new() { ["msg"] = "hi" });
+ await SendAsync(client, message, CancellationToken.None);
+
+ var got = await WaitUntilAsync(
+ () => received.Any(e => e.Message == message),
+ TimeSpan.FromSeconds(5));
+ Assert.True(got, "Normal command did not reach PluginMessageReceived.");
+
+ var args = received.Single(e => e.Message == message);
+ Assert.NotNull(args.Command);
+ Assert.False(args.IsResponse);
+ Assert.Equal("SayHello", args.Command!.Value.Request);
+ Assert.Equal("hi", args.Command.Value.Tags["msg"]);
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ [Fact]
+ public async Task ResponseMessage_RoutesToPluginResponse_NotToPluginMessageReceived()
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ var received = new ConcurrentQueue();
+ server.PluginMessageReceived += (_, e) => received.Enqueue(e);
+
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+ Assert.NotNull(server.Port);
+
+ var connectionId = Guid.NewGuid().ToString();
+ using var client = await ConnectAsync(server.Port!.Value, connectionId, CancellationToken.None);
+
+ var message = CommandMessage("AnyCommand", new() { ["RequestId"] = "r-123" });
+ await SendAsync(client, message, CancellationToken.None);
+
+ var responded = await WaitUntilAsync(
+ () => eventService.WasPublished(EventNames.PluginResponse),
+ TimeSpan.FromSeconds(5));
+ Assert.True(responded, "Response message did not produce a PluginResponse event.");
+
+ // Give any (incorrect) forwarding a chance to arrive, then assert none did.
+ await Task.Delay(300);
+ Assert.DoesNotContain(received, e => e.Message == message);
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ private static int GetFreePort()
+ {
+ var listener = new TcpListener(IPAddress.Loopback, 0);
+ listener.Start();
+ var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+ listener.Stop();
+ return port;
+ }
+
+ private static async Task WaitUntilAsync(Func condition, TimeSpan timeout)
+ {
+ var deadline = DateTime.UtcNow + timeout;
+ while (DateTime.UtcNow < deadline)
+ {
+ if (condition())
+ return true;
+ await Task.Delay(50);
+ }
+ return condition();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerSecurityTests.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerSecurityTests.cs
new file mode 100644
index 00000000..addae819
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/PluginsServerSecurityTests.cs
@@ -0,0 +1,182 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Net.WebSockets;
+using System.Text;
+using KitX.Core;
+using KitX.Core.Device;
+using KitX.Core.Contract.Event;
+using KitX.Core.Test.Xunit.Fakes;
+using ServerStatus = KitX.Core.Contract.Device.ServerStatus;
+
+namespace KitX.Core.Test.Xunit;
+
+///
+/// PluginsServer 安全修复测试。
+/// 覆盖：回环绑定（仅监听 127.0.0.1，局域网 IP 不可达）、连接 ID 必须为 GUID 格式。
+///
+public class PluginsServerSecurityTests
+{
+ [Fact]
+ public async Task Run_BindsLoopbackOnly()
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+
+ Assert.Equal(ServerStatus.Running, server.Status);
+ Assert.NotNull(server.Port);
+ Assert.True(server.Port > 0);
+
+ using (var tcp = new TcpClient())
+ {
+ await tcp.ConnectAsync(IPAddress.Loopback, server.Port.Value, CancellationToken.None);
+ Assert.True(tcp.Connected);
+ }
+
+ var lanIp = GetNonLoopbackIPv4();
+ if (lanIp is not null)
+ {
+ using var lanTcp = new TcpClient();
+ bool connected;
+ try
+ {
+ var connectTask = lanTcp.ConnectAsync(lanIp, server.Port.Value, CancellationToken.None).AsTask();
+ await Task.WhenAny(connectTask, Task.Delay(1500));
+ connected = connectTask.IsCompletedSuccessfully;
+ }
+ catch
+ {
+ connected = false;
+ }
+
+ Assert.False(connected);
+ }
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ [Theory]
+ [InlineData("/not-a-guid")]
+ [InlineData("/")]
+ [InlineData("/123456789")]
+ public async Task Connect_InvalidConnectionId_IsRejected(string path)
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+ Assert.NotNull(server.Port);
+
+ using var client = new ClientWebSocket();
+ bool rejected;
+ try
+ {
+ await client.ConnectAsync(new Uri($"ws://127.0.0.1:{server.Port}{path}"), CancellationToken.None);
+ rejected = false;
+ }
+ catch (WebSocketException)
+ {
+ // Fleck 1.2.0 在握手响应发送前执行 Start 回调：拒绝逻辑（Send + Close）会
+ // 打断握手响应，客户端表现为握手失败 —— 连接同样被拒绝，属预期结果。
+ rejected = true;
+ }
+
+ if (!rejected)
+ {
+ try
+ {
+ var buffer = new byte[512];
+ using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+
+ var rejectedMessage = await client.ReceiveAsync(buffer, cts.Token);
+ if (rejectedMessage.MessageType == WebSocketMessageType.Text)
+ Assert.Equal("Connection rejected.", Encoding.UTF8.GetString(buffer, 0, rejectedMessage.Count));
+
+ var close = await client.ReceiveAsync(buffer, cts.Token);
+ Assert.Equal(WebSocketMessageType.Close, close.MessageType);
+ }
+ catch (WebSocketException)
+ {
+ rejected = true;
+ }
+ }
+
+ Assert.True(rejected, "无效连接 ID 应被拒绝（握手中断或收到拒绝消息）");
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ [Fact]
+ public async Task Connect_ValidGuid_IsAccepted()
+ {
+ var eventService = new FakeEventService();
+ var server = new PluginsServer(eventService);
+ var originalPluginsServerPort = ConstantTable.PluginsServerPort;
+ var connectionId = Guid.NewGuid().ToString();
+ try
+ {
+ server.ConfigurePort(GetFreePort());
+ server.Run();
+ Assert.NotNull(server.Port);
+
+ using var client = new ClientWebSocket();
+ await client.ConnectAsync(new Uri($"ws://127.0.0.1:{server.Port}/{connectionId}"), CancellationToken.None);
+
+ var registered = await WaitUntilAsync(
+ () => server.FindConnection(connectionId) is not null,
+ TimeSpan.FromSeconds(5));
+
+ Assert.True(registered, "合法 GUID 连接未在超时内注册到 PluginsServer");
+
+ await client.CloseAsync(WebSocketCloseStatus.NormalClosure, "done", CancellationToken.None);
+ }
+ finally
+ {
+ ConstantTable.PluginsServerPort = originalPluginsServerPort;
+ await server.Close();
+ }
+ }
+
+ private static int GetFreePort()
+ {
+ var listener = new TcpListener(IPAddress.Loopback, 0);
+ listener.Start();
+ var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+ listener.Stop();
+ return port;
+ }
+
+ private static string? GetNonLoopbackIPv4() =>
+ Dns.GetHostEntry(Dns.GetHostName()).AddressList
+ .FirstOrDefault(ip =>
+ ip.AddressFamily == AddressFamily.InterNetwork &&
+ !ip.Equals(IPAddress.Loopback))
+ ?.ToString();
+
+ private static async Task WaitUntilAsync(Func condition, TimeSpan timeout)
+ {
+ var deadline = DateTime.UtcNow + timeout;
+ while (DateTime.UtcNow < deadline)
+ {
+ if (condition())
+ return true;
+ await Task.Delay(50);
+ }
+ return condition();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Usings.cs b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Usings.cs
new file mode 100644
index 00000000..c802f448
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core.Test.Xunit/Usings.cs
@@ -0,0 +1 @@
+global using Xunit;
diff --git a/KitX Clients/KitX Core/KitX.Core/.gitignore b/KitX Clients/KitX Core/KitX.Core/.gitignore
new file mode 100644
index 00000000..15478bdd
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/.gitignore
@@ -0,0 +1,77 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NuGet Packages
+*.nupkg
+**/packages/*
+!**/packages/build/
+*.nuget.props
+*.nuget.targets
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# ReSharper
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Mac crap
+.DS_Store
+
+# Windows Store app package
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+
+# Visual Studio cache files
+project.lock.json
+project.fragment.lock.json
+artifacts/
diff --git a/KitX Clients/KitX Core/KitX.Core/Activity/ActivityManager.cs b/KitX Clients/KitX Core/KitX.Core/Activity/ActivityManager.cs
new file mode 100644
index 00000000..2f4af931
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Activity/ActivityManager.cs
@@ -0,0 +1,487 @@
+using System.Linq.Expressions;
+using CActivity = Common.Activity.Activity;
+using Common.BasicHelper.Utils.Extensions;
+using KitX.Core.Contract.Activity;
+using LiteDB;
+using KitX.Core.Tasks;
+
+namespace KitX.Core.Activity;
+
+///
+/// Activity manager for recording application activities
+/// Uses Common.Activity library for activity management and LiteDB for persistence
+///
+public class ActivityManager : IActivityService, IDisposable
+{
+ private static readonly object _activityRecordLock = new();
+
+ // C-13.3, D1: the activities store is now an instance field owned by this manager. The
+ // public constructor opens the LiteDB file (creating the Data directory if missing); the
+ // internal constructor accepts an injected LiteDatabase (tests pass :memory:). The
+ // Dashboard no longer assigns an external static ActivitiesDatabase.
+ private LiteDatabase? _activitiesDatabase;
+
+ // C-13.2: in-process registry of the exact recorded time per activity Id. The Id is an
+ // int (LiteDB row key) and cannot carry a timestamp; this registry lets the adapter
+ // read the real timestamp instead of reverse-engineering it from a lossy hash.
+ private static readonly System.Collections.Concurrent.ConcurrentDictionary _activityTimestamps = new();
+
+ // C-13.2: monotonic counter mixed into the Id so two records in one process never
+ // collide (LiteDB throws on duplicate _id), while the clock component keeps Ids
+ // distinct across restarts within the month collection.
+ private static int _activityIdCounter;
+
+ // G6: retention policy. The activity log only ever grows; to bound the store, trim the
+ // oldest rows once the current-month collection exceeds the cap. The check runs at most
+ // once every writes (never per-row), so a burst of records
+ // is not slowed by a count/delete on every insert. Cap and frequency are hard-coded here —
+ // they are not configuration items for this batch (per G6 scope).
+ private const long MaxActivitiesPerCollection = 5000;
+ private const int TrimEveryNWrites = 1000;
+ private int _writesSinceTrim;
+
+ ///
+ /// Gets the collection name for current month
+ ///
+ public static string CollectionName => DateTime.UtcNow.ToString("yyyy_MM").Num2UpperChar();
+
+ private CActivity? _appActivity;
+
+ ///
+ /// Event raised when activities are updated
+ ///
+ public event EventHandler? ActivitiesUpdated;
+
+ ///
+ /// Creates a new activity manager, opening the on-disk activities database and creating
+ /// the Data directory first if it does not exist.
+ ///
+ public ActivityManager()
+ {
+ var dir = ConstantTable.DataPath.GetFullPath();
+
+ if (!Directory.Exists(dir))
+ Directory.CreateDirectory(dir);
+
+ _activitiesDatabase = new LiteDatabase(ConstantTable.ActivitiesDataBaseFilePath);
+ }
+
+ ///
+ /// Test constructor: takes an existing (e.g. an in-memory
+ /// :memory: store) instead of opening the on-disk activities file.
+ ///
+ internal ActivityManager(LiteDatabase database)
+ {
+ _activitiesDatabase = database;
+ }
+
+ ///
+ /// Releases the owned LiteDB instance. The production singleton lives for the whole
+ /// process (the DI provider is never disposed), so this is effectively only exercised by
+ /// tests; disposing earlier would not break the app lifetime.
+ ///
+ public void Dispose()
+ {
+ _activitiesDatabase?.Dispose();
+ _activitiesDatabase = null;
+ }
+
+ ///
+ /// Reads activities from the database, newest-first (by descending row Id).
+ /// Pass <= 0 to return every row; otherwise the call is a
+ /// reverse-chronological page of rows starting at
+ /// . Replaces the old full-table FindAll().ToList() scan
+ /// (measured ~130x slower than a bounded reverse-index read on the Home page).
+ ///
+ /// Maximum rows to return; <= 0 means all.
+ /// Rows to skip (used for paging after the first page).
+ /// List of activities, newest-first
+ public IList ReadActivities(int limit = 0, int skip = 0)
+ {
+ if (_activitiesDatabase is LiteDatabase db)
+ {
+ var col = db.GetCollection(CollectionName);
+ var query = col.Query().OrderByDescending(x => x.Id);
+ if (limit <= 0)
+ return query.ToList();
+ if (skip > 0)
+ return query.Skip(skip).Limit(limit).ToList();
+ return query.Limit(limit).ToList();
+ }
+ else
+ return [];
+ }
+
+ ///
+ /// Total number of recorded activities in the current month collection. Used by the
+ /// Home activity log to decide whether "load more" has anything left to page.
+ ///
+ /// Count of activity rows in the current collection.
+ public long CountActivities()
+ {
+ if (_activitiesDatabase is LiteDatabase db)
+ return db.GetCollection(CollectionName).LongCount();
+ return 0;
+ }
+
+ ///
+ /// G6 retention: invoked on the write path but throttled to once every
+ /// writes; the actual trimming is delegated to
+ /// so the bounded-store invariant is testable and can be
+ /// enforced on demand regardless of the write-path throttle.
+ ///
+ /// The current-month collection to trim.
+ private void TrimIfDue(ILiteCollection col)
+ {
+ _writesSinceTrim++;
+ if (_writesSinceTrim < TrimEveryNWrites)
+ return;
+ _writesSinceTrim = 0;
+
+ TrimToCap(col);
+ }
+
+ ///
+ /// G6 retention: idempotently trims the current-month collection down to
+ /// rows by deleting the oldest excess
+ /// (smallest Id). Safe to call on an already-bounded store (no-op) and reentrant
+ /// under (called from the throttled write path).
+ ///
+ public void TrimToCap()
+ {
+ if (_activitiesDatabase is not LiteDatabase db)
+ return;
+ TrimToCap(db.GetCollection(CollectionName));
+ db.Commit();
+ }
+
+ private void TrimToCap(ILiteCollection col)
+ {
+ var count = col.LongCount();
+ if (count <= MaxActivitiesPerCollection)
+ return;
+
+ var excess = (int)(count - MaxActivitiesPerCollection);
+ var oldest = col.Query().OrderBy(x => x.Id).Limit(excess).ToList();
+ foreach (var activity in oldest)
+ col.Delete(new BsonValue(activity.Id));
+ }
+
+ ///
+ /// Records an activity to the database
+ ///
+ /// The activity to record
+ /// Key selector for indexing
+ public void Record(CActivity activity, Expression> keySelector)
+ {
+ const string location = $"{nameof(ActivityManager)}.{nameof(Record)}";
+
+ TasksManager.RunTask(
+ () =>
+ {
+ lock (_activityRecordLock)
+ {
+ if (_activitiesDatabase is LiteDatabase db)
+ {
+ var col = db.GetCollection(CollectionName);
+
+ col?.Insert(activity);
+
+ col?.EnsureIndex(keySelector);
+
+ if (col is not null)
+ TrimIfDue(col);
+
+ db.Commit();
+
+ ActivitiesUpdated?.Invoke(this, EventArgs.Empty);
+ }
+ }
+ },
+ location,
+ catchException: true
+ );
+ }
+
+ ///
+ /// Updates an activity in the database
+ ///
+ /// The activity to update
+ public void Update(CActivity activity)
+ {
+ const string location = $"{nameof(ActivityManager)}.{nameof(Update)}";
+
+ TasksManager.RunTask(
+ () =>
+ {
+ lock (_activityRecordLock)
+ {
+ if (_activitiesDatabase is LiteDatabase db)
+ {
+ var col = db.GetCollection(CollectionName);
+
+ col?.Update(activity);
+
+ db.Commit();
+
+ ActivitiesUpdated?.Invoke(this, EventArgs.Empty);
+ }
+ }
+ },
+ location,
+ catchException: true
+ );
+ }
+
+ ///
+ /// Records an activity (interface implementation for backward compatibility)
+ ///
+ /// Activity type
+ /// Activity details
+ public void RecordActivity(string type, Dictionary? details = null)
+ {
+ // This method is kept for interface compatibility but delegates to Record()
+ // Actual implementation should use Record() with Activity objects
+ var activity = new CActivity()
+ {
+ Id = NextActivityId(),
+ Name = type,
+ Author = "KitX",
+ Title = type,
+ Category = "General"
+ };
+
+ // C-13.2: remember the exact record time (the int Id cannot carry it).
+ _activityTimestamps[activity.Id] = DateTime.UtcNow;
+
+ Record(activity, x => x.Id);
+ }
+
+ ///
+ /// C-13.2: generates a collision-free int activity Id (LiteDB row key).
+ /// Clock + per-process counter mixing: unique within a process, and the clock
+ /// component makes Ids unlikely to repeat across restarts in the same month collection.
+ ///
+ private static int NextActivityId()
+ {
+ var ticks = DateTime.UtcNow.Ticks;
+ var counter = Interlocked.Increment(ref _activityIdCounter);
+ // 2654435761 = Knuth's multiplicative hash constant, scrambles the counter
+ // so consecutive Ids do not form a simple visible pattern.
+ return unchecked((int)(ticks ^ ((long)counter * 2654435761)));
+ }
+
+ ///
+ /// Gets activities (interface implementation)
+ ///
+ /// Optional start date filter
+ /// Optional end date filter
+ /// Maximum number of activities to return
+ /// List of activities
+ public IList GetActivities(DateTime? startDate = null, DateTime? endDate = null, int limit = 100)
+ {
+ var activities = ReadActivities();
+
+ // Convert to IActivity interface first to get proper Timestamp values
+ var adaptedActivities = activities.Select(a => new ActivityAdapter(a)).ToList();
+
+ // Filter by date range if specified
+ if (startDate.HasValue || endDate.HasValue)
+ {
+ adaptedActivities = adaptedActivities.Where(a =>
+ {
+ var ts = a.Timestamp;
+
+ if (startDate.HasValue && ts < startDate.Value)
+ return false;
+
+ if (endDate.HasValue && ts > endDate.Value)
+ return false;
+
+ return true;
+ }).ToList();
+ }
+
+ // Apply limit
+ if (limit > 0 && adaptedActivities.Count > limit)
+ {
+ adaptedActivities = adaptedActivities.Take(limit).ToList();
+ }
+
+ return adaptedActivities.Cast().ToList();
+ }
+
+ ///
+ /// Gets activity statistics
+ ///
+ /// Start date
+ /// End date
+ /// Activity statistics
+ public IActivityStatistics GetStatistics(DateTime startDate, DateTime endDate)
+ {
+ var activities = GetActivities(startDate, endDate);
+
+ var statistics = new ActivityStatistics
+ {
+ TotalActivities = activities.Count
+ };
+
+ foreach (var activity in activities)
+ {
+ if (!statistics.ActivitiesByType.ContainsKey(activity.Type))
+ {
+ statistics.ActivitiesByType[activity.Type] = 0;
+ }
+
+ statistics.ActivitiesByType[activity.Type]++;
+ }
+
+ return statistics;
+ }
+
+ ///
+ /// Updates an activity (interface implementation)
+ ///
+ /// The activity to update
+ public void UpdateActivity(IActivity activity)
+ {
+ if (activity is ActivityAdapter adapter)
+ {
+ Update(adapter.Activity);
+ }
+ }
+
+ ///
+ /// Records app start
+ ///
+ public void RecordAppStart()
+ {
+ var activity = new CActivity()
+ {
+ Id = NextActivityId(),
+ Name = "AppLifetime",
+ Author = "KitX Dashboard",
+ Title = "Application Started",
+ Category = "DashboardEvent"
+ // C-13.1: IconKind removed — Core no longer references the Material.Icons
+ // enum (a UI-adjacent dependency resolved transitively via Common.Activity).
+ // The icon is cosmetic; D1 may re-attach an icon mapping on the Dashboard side
+ // (currently nothing reads activity.IconKind — verified by grep).
+ }.Open("KitX Dashboard");
+
+ // C-13.2: remember the exact record time (the int Id cannot carry it).
+ _activityTimestamps[activity.Id] = DateTime.UtcNow;
+
+ _appActivity = activity;
+
+ Record(activity, x => x.Id);
+ }
+
+ ///
+ /// Records app exit
+ ///
+ public void RecordAppExit()
+ {
+ if (_appActivity is CActivity activity)
+ {
+ activity.Close("KitX Dashboard");
+
+ Update(activity);
+ }
+ }
+
+ ///
+ /// Activity adapter to convert Common.Activity.Activity to IActivity
+ ///
+ private class ActivityAdapter : IActivity
+ {
+ private readonly CActivity _activity;
+
+ private readonly DateTime _timestamp;
+
+ public ActivityAdapter(CActivity activity)
+ {
+ _activity = activity;
+
+ // C-13.2: timestamp resolution order:
+ // 1. the exact ExecuteTime of an Open/Close operation (if any);
+ // 2. the in-process registry of records created by this manager;
+ // 3. legacy rows: best-effort decode of the old ticks-hash Id.
+ var openCloseOps = activity.Operations?.OpenAndCloseOperations;
+
+ if (openCloseOps is { Count: > 0 })
+ {
+ var earliest = openCloseOps
+ .Where(op => op.ExecuteTime.HasValue)
+ .MinBy(op => op.ExecuteTime);
+
+ _timestamp = earliest?.ExecuteTime
+ ?? ResolveFallbackTimestamp(activity.Id);
+ }
+ else
+ {
+ _timestamp = ResolveFallbackTimestamp(activity.Id);
+ }
+ }
+
+ private static DateTime ResolveFallbackTimestamp(int id) =>
+ _activityTimestamps.TryGetValue(id, out var recorded)
+ ? recorded
+ : DecodeTimestampFromId(id);
+
+ public CActivity Activity => _activity;
+
+ public string Id => _activity.Id.ToString();
+
+ public string Type => _activity.Name ?? "Unknown";
+
+ public DateTime Timestamp => _timestamp;
+
+ public Dictionary Details => new()
+ {
+ { "Title", _activity.Title ?? "" },
+ { "Category", _activity.Category ?? "" },
+ { "Author", _activity.Author ?? "" },
+ { "Status", _activity.Status.ToString() }
+ };
+
+ ///
+ /// C-13.2: legacy fallback only. Decodes a timestamp from the old-style activity Id
+ /// (generated from DateTime.UtcNow.Ticks.GetHashCode()). New records use
+ /// ; this remains only so historical rows still
+ /// produce an approximate timestamp for date-range filtering.
+ ///
+ private static DateTime DecodeTimestampFromId(int id)
+ {
+ // Id is derived from DateTime.UtcNow.Ticks.GetHashCode().
+ // GetHashCode() for Int64 returns (int)(value ^ (value >> 32)).
+ // We can recover the lower 32 bits by reversing the XOR:
+ // lower32 = (int)(ticks ^ (ticks >> 32))
+ // Since we only have the hash result, we reconstruct the approximate ticks
+ // by using the current UTC ticks as a reference for the upper 32 bits.
+ var nowTicks = DateTime.UtcNow.Ticks;
+ var upper32 = (int)(nowTicks >> 32);
+ var lower32 = (int)((uint)id ^ (uint)(upper32 ^ (int)(nowTicks >> 32)));
+
+ // Combine upper and lower 32 bits to form the approximate ticks
+ var approxTicks = ((long)upper32 << 32) | (uint)lower32;
+
+ // Clamp to valid DateTime range
+ if (approxTicks < DateTime.MinValue.Ticks)
+ approxTicks = DateTime.MinValue.Ticks;
+ else if (approxTicks > DateTime.MaxValue.Ticks)
+ approxTicks = DateTime.MaxValue.Ticks;
+
+ return new DateTime(approxTicks, DateTimeKind.Utc);
+ }
+ }
+
+ ///
+ /// Activity statistics implementation
+ ///
+ private class ActivityStatistics : IActivityStatistics
+ {
+ public int TotalActivities { get; set; }
+ public Dictionary ActivitiesByType { get; set; } = new();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Announcement/AnnouncementManager.cs b/KitX Clients/KitX Core/KitX.Core/Announcement/AnnouncementManager.cs
new file mode 100644
index 00000000..57d346cd
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Announcement/AnnouncementManager.cs
@@ -0,0 +1,296 @@
+using KitX.Core.Configuration;
+using KitX.Core.Contract.Announcement;
+using KitX.Core.Contract.Configuration;
+using Serilog;
+using System.Text.Json;
+
+namespace KitX.Core.Announcement;
+
+///
+/// Announcement manager for checking and displaying announcements
+/// Phase 5: Decoupled from UI, uses events instead
+///
+public class AnnouncementManager : IAnnouncementService
+{
+ ///
+ /// Gets the singleton instance (resolves from ServiceHost when available).
+ /// Internal code should use constructor injection instead.
+ ///
+ public static AnnouncementManager Instance
+ {
+ get
+ {
+ if (DI.ServiceHost.IsInitialized)
+ return (AnnouncementManager)DI.ServiceHost.GetRequiredService();
+ Log.Error("[AnnouncementManager] Instance: ServiceHost not initialized! Returning orphan instance — " +
+ "this indicates a DI initialization order bug. Use ServiceHost/constructor injection instead.");
+ return new AnnouncementManager();
+ }
+ }
+
+ private readonly HashSet _acceptedAnnouncementIds = new();
+
+ // C-15.8: shared serializer options instance.
+ private readonly JsonSerializerOptions _serializerOptions = KitX.Core.Configuration.NetworkSerialization.Options;
+
+ private readonly IConfigService? _configService;
+
+ // C-15.13: reuse one HttpClient instead of allocating per check call.
+ private static readonly HttpClient HttpClient = new()
+ {
+ Timeout = TimeSpan.FromSeconds(15)
+ };
+
+ private static readonly string AcceptedAnnouncementsFileName = "accepted_announcements.json";
+
+ ///
+ /// Gets the announcement configuration
+ ///
+ public IAnnouncementConf AnnouncementConfig =>
+ (_configService as ConfigManager)?.TypedAnnouncementConfig
+ ?? throw new InvalidOperationException("IConfigService not injected or not ConfigManager");
+
+ ///
+ /// Event raised when new announcements are available
+ /// Instead of directly creating UI windows, Core triggers events
+ ///
+ public event EventHandler? NewAnnouncementsAvailable;
+
+ ///
+ /// Event raised when announcement checking fails
+ ///
+ public event EventHandler? AnnouncementError;
+
+ ///
+ /// Creates a new announcement manager
+ ///
+ public AnnouncementManager()
+ {
+ LoadAcceptedIds();
+ }
+
+ ///
+ /// Constructor with IConfigService injection
+ ///
+ /// Configuration service
+ public AnnouncementManager(IConfigService configService) : this()
+ {
+ _configService = configService;
+ }
+
+ ///
+ /// Checks for new announcements
+ ///
+ /// List of new announcements
+ public async Task> CheckNewAnnouncementsAsync()
+ {
+ const string location = $"{nameof(AnnouncementManager)}.{nameof(CheckNewAnnouncementsAsync)}";
+
+ try
+ {
+ // Get API server and path from config service
+ string apiServer;
+ string apiPath;
+
+ if (_configService != null)
+ {
+ apiServer = _configService.AppConfig.Web?.ApiServer ?? "api.example.com";
+ apiPath = _configService.AppConfig.Web?.ApiPath ?? "/api/v1";
+ }
+ else
+ {
+ // Cannot proceed without config service
+ return Array.Empty();
+ }
+
+ var linkBase = $"https://{apiServer}{apiPath}";
+
+ var announcementsLink = $"{linkBase}/announcements";
+ var unreads = new List();
+
+ var client = HttpClient;
+ client.DefaultRequestHeaders.Accept.Clear();
+
+ // Fetch announcement dates
+ var msg = await client.GetStringAsync(announcementsLink);
+ var list = JsonSerializer.Deserialize>(msg);
+
+ if (list is null)
+ return Array.Empty();
+
+ // Filter unread announcements
+ foreach (var item in list)
+ {
+ if (!_acceptedAnnouncementIds.Contains(item))
+ {
+ if (DateTime.TryParse(item, out var date))
+ {
+ unreads.Add(date);
+ }
+ }
+ }
+
+ // Fetch announcement details
+ var announcements = new List();
+ foreach (var item in unreads)
+ {
+ var announcementLink = $"{linkBase}/announcement?lang=en&date={item:yyyy-MM-dd HH-mm}";
+ var markdown = JsonSerializer.Deserialize(await client.GetStringAsync(announcementLink));
+
+ if (!string.IsNullOrEmpty(markdown))
+ {
+ announcements.Add(new Announcement
+ {
+ Id = item.ToString("yyyy-MM-dd HH:mm"),
+ PublishDate = item,
+ Content = markdown,
+ Title = $"Announcement - {item:yyyy-MM-dd}",
+ Version = "1.0" // TODO: (Low Priority) Get version from API response when API supports it
+ });
+ }
+ }
+
+ // If new announcements found, trigger event
+ if (announcements.Count > 0)
+ {
+ NewAnnouncementsAvailable?.Invoke(this, new NewAnnouncementsEventArgs
+ {
+ Announcements = announcements
+ });
+ }
+
+ return announcements;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, $"In {location}: {ex.Message}");
+ return Array.Empty();
+ }
+ }
+
+ ///
+ /// Marks an announcement as read
+ ///
+ /// The announcement ID
+ public void MarkAsRead(string announcementId)
+ {
+ _acceptedAnnouncementIds.Add(announcementId);
+ SaveAcceptedIds();
+ }
+
+ ///
+ /// Gets all read announcement IDs
+ ///
+ /// List of read announcement IDs
+ public IReadOnlyList GetReadAnnouncementIds()
+ {
+ return _acceptedAnnouncementIds.ToList();
+ }
+
+ ///
+ /// Saves the announcement configuration
+ ///
+ public void SaveAnnouncementConfig()
+ {
+ var config = AnnouncementConfig;
+ if (!string.IsNullOrEmpty(config.ConfigFileLocation) && config is AnnouncementConfig typedConfig)
+ {
+ typedConfig.Save(config.ConfigFileLocation);
+ }
+ }
+
+ ///
+ /// Loads accepted announcement IDs from persistent storage
+ ///
+ private void LoadAcceptedIds()
+ {
+ try
+ {
+ var path = Path.GetFullPath(Path.Combine(ConstantTable.DataPath, AcceptedAnnouncementsFileName));
+
+ if (File.Exists(path))
+ {
+ var json = File.ReadAllText(path);
+ var ids = JsonSerializer.Deserialize>(json, _serializerOptions);
+
+ if (ids != null)
+ {
+ _acceptedAnnouncementIds.Clear();
+ foreach (var id in ids)
+ {
+ _acceptedAnnouncementIds.Add(id);
+ }
+
+ Log.Debug("[AnnouncementManager] Loaded {Count} accepted announcement IDs from {Path}",
+ _acceptedAnnouncementIds.Count, path);
+ }
+ }
+ else
+ {
+ Log.Debug("[AnnouncementManager] No accepted announcements file found at {Path}, starting fresh", path);
+ }
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[AnnouncementManager] Failed to load accepted announcement IDs");
+ }
+ }
+
+ ///
+ /// Saves accepted announcement IDs to persistent storage
+ ///
+ private void SaveAcceptedIds()
+ {
+ try
+ {
+ var path = Path.GetFullPath(Path.Combine(ConstantTable.DataPath, AcceptedAnnouncementsFileName));
+ var directory = Path.GetDirectoryName(path);
+
+ if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+ {
+ Directory.CreateDirectory(directory);
+ }
+
+ var json = JsonSerializer.Serialize(_acceptedAnnouncementIds, _serializerOptions);
+ File.WriteAllText(path, json);
+
+ Log.Debug("[AnnouncementManager] Saved {Count} accepted announcement IDs to {Path}",
+ _acceptedAnnouncementIds.Count, path);
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[AnnouncementManager] Failed to save accepted announcement IDs");
+ }
+ }
+
+ ///
+ /// Announcement implementation
+ ///
+ public class Announcement : IAnnouncement
+ {
+ ///
+ /// Gets or sets the announcement ID
+ ///
+ public string Id { get; set; } = string.Empty;
+
+ ///
+ /// Gets or sets the announcement title
+ ///
+ public string Title { get; set; } = string.Empty;
+
+ ///
+ /// Gets or sets the announcement content
+ ///
+ public string Content { get; set; } = string.Empty;
+
+ ///
+ /// Gets or sets the publish date
+ ///
+ public DateTime PublishDate { get; set; }
+
+ ///
+ /// Gets or sets the version
+ ///
+ public string Version { get; set; } = string.Empty;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Common/AsyncRelayCommand.cs b/KitX Clients/KitX Core/KitX.Core/Common/AsyncRelayCommand.cs
new file mode 100644
index 00000000..e1f83d32
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Common/AsyncRelayCommand.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace KitX.Core.Common;
+
+///
+/// Minimal asynchronous for Core types that need UI-bound
+/// commands without taking a ReactiveUI dependency (e.g. DeviceCase).
+/// Guards against re-entry while a previous execution is still running.
+///
+public sealed class AsyncRelayCommand : ICommand
+{
+ private readonly Func _execute;
+ private readonly Func? _canExecute;
+ private bool _isRunning;
+
+ public AsyncRelayCommand(Func execute, Func? canExecute = null)
+ {
+ _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+ _canExecute = canExecute;
+ }
+
+ public event EventHandler? CanExecuteChanged;
+
+ public bool CanExecute(object? parameter) => !_isRunning && (_canExecute?.Invoke() ?? true);
+
+ public async void Execute(object? parameter)
+ {
+ if (!CanExecute(parameter))
+ return;
+
+ _isRunning = true;
+ try
+ {
+ await _execute();
+ }
+ finally
+ {
+ _isRunning = false;
+ }
+ }
+
+ public void RaiseCanExecuteChanged() => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/AnnouncementConfig.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/AnnouncementConfig.cs
new file mode 100644
index 00000000..ee4b1a64
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/AnnouncementConfig.cs
@@ -0,0 +1,30 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Announcement configuration implementation
+///
+public class AnnouncementConfig : IAnnouncementConf
+{
+ ///
+ /// Gets or sets the list of accepted announcement IDs
+ ///
+ public List Accepted { get; set; } = [];
+
+ ///
+ /// Configuration file location (for backward compatibility)
+ ///
+ public string? ConfigFileLocation { get; set; }
+
+ ///
+ /// Saves the configuration to file (for backward compatibility)
+ ///
+ /// File path to save
+ /// This instance
+ public AnnouncementConfig Save(string path)
+ {
+ // Implementation would save to file - simplified for compatibility
+ return this;
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/AppConfig.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/AppConfig.cs
new file mode 100644
index 00000000..a05f1f42
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/AppConfig.cs
@@ -0,0 +1,54 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Application configuration implementation
+/// This class contains all application settings organized into logical sections
+///
+public class AppConfig : IAppConfig, IConfigWithMetadata
+{
+ ///
+ /// Configuration file location
+ ///
+ public string? ConfigFileLocation { get; set; }
+
+ ///
+ /// Configuration file watcher name
+ ///
+ public string? ConfigFileWatcherName { get; set; }
+
+ ///
+ /// Configuration generated time
+ ///
+ public DateTime? ConfigGeneratedTime { get; set; } = DateTime.Now;
+
+ public Config_App App { get; set; } = new();
+
+ public Config_Windows Windows { get; set; } = new();
+
+ public Config_Pages Pages { get; set; } = new();
+
+ public Config_Web Web { get; set; } = new();
+
+ public Config_Log Log { get; set; } = new();
+
+ public Config_IO IO { get; set; } = new();
+
+ public Config_Activity Activity { get; set; } = new();
+
+ public Config_Loaders Loaders { get; set; } = new();
+
+ public Config_Performance Performance { get; set; } = new();
+
+ // Explicit interface implementation with setters
+ IAppConf IAppConfig.App { get => App; set => App = (Config_App?)value ?? new(); }
+ IWindowsConf IAppConfig.Windows { get => Windows; set => Windows = (Config_Windows?)value ?? new(); }
+ IPagesConf IAppConfig.Pages { get => Pages; set => Pages = (Config_Pages?)value ?? new(); }
+ IWebConf IAppConfig.Web { get => Web; set => Web = (Config_Web?)value ?? new(); }
+ ILogConf IAppConfig.Log { get => Log; set => Log = (Config_Log?)value ?? new(); }
+ IIOConf IAppConfig.IO { get => IO; set => IO = (Config_IO?)value ?? new(); }
+ IActivityConf IAppConfig.Activity { get => Activity; set => Activity = (Config_Activity?)value ?? new(); }
+ ILoadersConf IAppConfig.Loaders { get => Loaders; set => Loaders = (Config_Loaders?)value ?? new(); }
+ IPerformanceConf IAppConfig.Performance { get => Performance; set => Performance = (Config_Performance?)value ?? new(); }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigLoader.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigLoader.cs
new file mode 100644
index 00000000..1a7dd5d4
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigLoader.cs
@@ -0,0 +1,153 @@
+using System.Text.Json;
+using KitX.Core.Contract.Configuration;
+using KitX.Shared.CSharp.Device;
+using Serilog;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Loads configuration from files
+///
+public class ConfigLoader : IConfigLoader
+{
+ ///
+ public T Load(string location, string fileName) where T : class, new()
+ {
+ var rawPath = Path.Combine(location, fileName);
+ var fullPath = Path.GetFullPath(rawPath);
+ var fInfo = new FileInfo(fullPath);
+
+ Log.Debug("[ConfigLoader] Load<{TypeName}> path={Path}, exists={Exists}, size={Size}, lastWrite={LastWrite}",
+ typeof(T).Name, fullPath, fInfo.Exists, fInfo.Exists ? fInfo.Length : -1,
+ fInfo.Exists ? fInfo.LastWriteTime.ToString("O") : "n/a");
+
+ if (!File.Exists(fullPath))
+ {
+ Log.Debug("[ConfigLoader] Load<{TypeName}> FILE NOT FOUND, returning default", typeof(T).Name);
+ return new T();
+ }
+
+ try
+ {
+ var json = File.ReadAllText(fullPath);
+ var config = JsonSerializer.Deserialize(json, ConfigSerializationOptions.Options);
+ if (config == null)
+ {
+ Log.Debug("[ConfigLoader] Load<{TypeName}> Deserialize returned NULL, returning default", typeof(T).Name);
+ return new T();
+ }
+ if (typeof(T) == typeof(AppConfig))
+ {
+ var ac = (AppConfig)(object)config;
+
+ // Diagnostic: parse JSON directly to see what the file really says
+ using var doc = JsonDocument.Parse(json);
+ var root = doc.RootElement;
+ string jLogLevel = "?", jHomePane = "?", jHomeSelView = "?";
+ if (root.TryGetProperty("Log", out var jLog) && jLog.TryGetProperty("LogLevel", out var jLevel))
+ jLogLevel = jLevel.GetInt32().ToString();
+ if (root.TryGetProperty("Pages", out var jPages) && jPages.TryGetProperty("Home", out var jHome))
+ {
+ if (jHome.TryGetProperty("IsNavigationViewPaneOpened", out var jOpen))
+ jHomePane = jOpen.GetBoolean() ? "open" : "closed";
+ if (jHome.TryGetProperty("SelectedViewName", out var jSvn))
+ jHomeSelView = jSvn.GetString() ?? "null";
+ }
+
+ Log.Debug("[ConfigLoader] Load JSON: LogLevel={JsonLevel}, HomePane={JsonHomePane}, HomeSelView={JsonHomeSelView}",
+ jLogLevel, jHomePane, jHomeSelView);
+ Log.Debug("[ConfigLoader] Load OBJ: LogLevel={ObjLevel}, HomePane={ObjHomePane}, HomeSelView={ObjHomeSelView}",
+ (int)ac.Log.LogLevel, ac.Pages.Home.IsNavigationViewPaneOpened ? "open" : "closed",
+ ac.Pages.Home.SelectedViewName);
+ }
+ Log.Debug("[ConfigLoader] Load<{TypeName}> SUCCESS, json={JsonLength} bytes", typeof(T).Name, json.Length);
+ return config;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[ConfigLoader] Load<{TypeName}> EXCEPTION: {Message}", typeof(T).Name, ex.Message);
+ return new T();
+ }
+ }
+
+ ///
+ public ISecurityConf LoadSecurityConfig(string location)
+ {
+ var path = Path.Combine(location, "SecurityConfig.json");
+
+ if (!File.Exists(path))
+ {
+ Log.Warning("SecurityConfig.json not found, creating default");
+ return new SecurityConfig();
+ }
+
+ try
+ {
+ var json = File.ReadAllText(path);
+ return DeserializeSecurityConfig(json);
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "Error loading SecurityConfig: {Message}", ex.Message);
+ return new SecurityConfig();
+ }
+ }
+
+ private static ISecurityConf DeserializeSecurityConfig(string json)
+ {
+ try
+ {
+ using var doc = JsonDocument.Parse(json);
+ var root = doc.RootElement;
+
+ var config = new SecurityConfig();
+
+ if (root.TryGetProperty("ConfigFileLocation", out var configFileLocation))
+ config.ConfigFileLocation = configFileLocation.GetString();
+ if (root.TryGetProperty("ConfigFileWatcherName", out var configFileWatcherName))
+ config.ConfigFileWatcherName = configFileWatcherName.GetString();
+ if (root.TryGetProperty("ConfigGeneratedTime", out var configGeneratedTime))
+ if (DateTime.TryParse(configGeneratedTime.GetString(), out var generatedTime))
+ config.ConfigGeneratedTime = generatedTime;
+
+ if (root.TryGetProperty("DeviceKeys", out var deviceKeysElement))
+ {
+ var deviceKeys = new List();
+
+ foreach (var keyElement in deviceKeysElement.EnumerateArray())
+ {
+ var impl = new DeviceKeyImpl();
+
+ if (keyElement.TryGetProperty("Device", out var deviceElement))
+ {
+ impl.Device = new DeviceLocator
+ {
+ DeviceName = deviceElement.TryGetProperty("DeviceName", out var dn) ? dn.GetString() ?? "" : "",
+ IPv4 = deviceElement.TryGetProperty("IPv4", out var ipv4) ? ipv4.GetString() ?? "" : "",
+ IPv6 = deviceElement.TryGetProperty("IPv6", out var ipv6) ? ipv6.GetString() ?? "" : "",
+ MacAddress = deviceElement.TryGetProperty("MacAddress", out var mac) ? mac.GetString() ?? "" : ""
+ };
+ }
+
+ impl.RsaPublicKeyPem = keyElement.TryGetProperty("RsaPublicKeyPem", out var pubKey) ? pubKey.GetString() : null;
+ impl.RsaPrivateKeyPem = keyElement.TryGetProperty("RsaPrivateKeyPem", out var privKey) ? privKey.GetString() : null;
+
+ if (keyElement.TryGetProperty("AddedAt", out var addedAtElement))
+ if (DateTime.TryParse(addedAtElement.GetString(), out var addedAt))
+ impl.AddedAt = addedAt;
+
+ deviceKeys.Add(impl);
+ }
+
+ config.DeviceKeys = deviceKeys;
+ }
+
+ return config;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "Error deserializing SecurityConfig: {Message}", ex.Message);
+ return new SecurityConfig();
+ }
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigManager.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigManager.cs
new file mode 100644
index 00000000..692f3235
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigManager.cs
@@ -0,0 +1,334 @@
+using KitX.Core.Contract.Configuration;
+using Serilog;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Configuration manager for managing application configurations
+/// Coordinates ConfigLoader, ConfigSaver, and file watching
+///
+public class ConfigManager : IConfigService, IDisposable
+{
+ private static ConfigManager? _instance;
+
+ ///
+ /// Gets the singleton instance.
+ /// Uses static instance to maintain singleton behavior.
+ ///
+ [Obsolete("Use DI container via ServiceHost.GetRequiredService() instead.", error: false)]
+ public static ConfigManager Instance => _instance ??= new ConfigManager();
+
+ private string? _configLocation;
+
+ private readonly Dictionary _configs = new();
+
+ ///
+ /// File system watchers for hot-reload
+ ///
+ private readonly Dictionary _fileWatchers = new();
+
+ ///
+ /// Exception counts to prevent infinite loops when saving files
+ ///
+ private readonly Dictionary _exceptCounts = new();
+
+ private readonly IConfigLoader _loader;
+ private readonly IConfigSaver _saver;
+
+ ///
+ /// Whether Load() has been called at least once. SaveAll() is deferred until after Load.
+ ///
+ private bool _loaded;
+
+ ///
+ /// Whether hot-reload is enabled
+ ///
+ public bool HotReloadEnabled { get; set; } = true;
+
+ ///
+ /// Event raised when configuration changes
+ ///
+ public event EventHandler? ConfigChanged;
+
+ ///
+ /// Gets the application configuration
+ ///
+ public IAppConfig AppConfig { get; private set; } = new AppConfig();
+
+ ///
+ /// Gets the typed application configuration (strong type version)
+ ///
+ public AppConfig TypedAppConfig => (AppConfig)AppConfig;
+
+ public IAnnouncementConf AnnouncementConfig { get; set; } = new AnnouncementConfig();
+
+ ///
+ /// Gets the typed announcement configuration (strong type version)
+ ///
+ public AnnouncementConfig TypedAnnouncementConfig => (AnnouncementConfig)AnnouncementConfig;
+
+ ///
+ /// Gets the plugins configuration
+ ///
+ public IPluginsConf PluginsConfig { get; private set; } = new PluginsConfig();
+
+ ///
+ /// Gets the security configuration
+ ///
+ public ISecurityConf SecurityConfig { get; private set; } = new SecurityConfig();
+
+ ///
+ /// Gets the typed security configuration (strong type version)
+ ///
+ public SecurityConfig TypedSecurityConfig => (SecurityConfig)SecurityConfig;
+
+ ///
+ /// Creates a new configuration manager
+ ///
+ public ConfigManager()
+ {
+ Log.Debug($"[ConfigManager] Constructor called, Instance hash: {GetHashCode()}");
+ _loader = new ConfigLoader();
+ _saver = new ConfigSaver();
+ }
+
+ ///
+ /// Sets the configuration file location
+ ///
+ /// The directory path
+ /// The config manager instance
+ public ConfigManager SetLocation(string location)
+ {
+ Log.Debug($"[ConfigManager] SetLocation called on instance {GetHashCode()} with location: {location}");
+ _configLocation = Path.GetFullPath(location);
+
+ if (!Directory.Exists(_configLocation))
+ {
+ Directory.CreateDirectory(_configLocation);
+ }
+
+ Log.Debug($"[ConfigManager] _configLocation set to: {_configLocation} on instance {GetHashCode()}");
+ return this;
+ }
+
+ ///
+ /// Loads all configurations from files
+ ///
+ public void Load()
+ {
+ // Step 1: Check if _configLocation is set
+ if (string.IsNullOrEmpty(_configLocation))
+ {
+ Log.Information($"[ConfigManager] _configLocation is null/empty, setting default");
+ SetLocation("./Config/");
+ }
+
+ Log.Information($"[ConfigManager] Loading configs from: {_configLocation}");
+ AppConfig = _loader.Load(_configLocation!, "AppConfig.json");
+ PluginsConfig = _loader.Load(_configLocation, "PluginsConfig.json");
+ SecurityConfig = _loader.LoadSecurityConfig(_configLocation);
+
+ Log.Information($"[ConfigManager] Load complete — LogLevel={AppConfig.Log.LogLevel}, HomePane={(AppConfig.Pages.Home.IsNavigationViewPaneOpened ? "open" : "closed")}");
+
+ _configs["AppConfig"] = AppConfig;
+ _configs["PluginsConfig"] = PluginsConfig;
+ _configs["SecurityConfig"] = SecurityConfig;
+
+ _loaded = true;
+ Log.Information("[ConfigManager] Load complete & SaveAll gate opened.");
+
+ if (HotReloadEnabled)
+ {
+ RegisterFileWatcher("AppConfig.json");
+ RegisterFileWatcher("PluginsConfig.json");
+ RegisterFileWatcher("SecurityConfig.json");
+ }
+
+ Log.Debug($"[ConfigManager] Load() completed on instance {GetHashCode()}");
+ }
+
+ ///
+ /// Registers a file watcher for a config file to enable hot-reload
+ ///
+ private void RegisterFileWatcher(string fileName) where T : class, new()
+ {
+ var watcherName = $"ConfigFileWatcher_{typeof(T).Name}";
+ var path = Path.Combine(_configLocation!, fileName);
+
+ if (_fileWatchers.ContainsKey(watcherName))
+ return;
+
+ var directory = Path.GetDirectoryName(path);
+ var filter = Path.GetFileName(path);
+
+ if (string.IsNullOrEmpty(directory))
+ return;
+
+ var watcher = new FileSystemWatcher(directory)
+ {
+ Filter = filter,
+ NotifyFilter = NotifyFilters.LastWrite,
+ EnableRaisingEvents = true
+ };
+
+ watcher.Changed += (sender, args) =>
+ {
+ if (_exceptCounts.TryGetValue(watcherName, out var count) && count > 0)
+ {
+ _exceptCounts[watcherName] = count - 1;
+ Log.Debug("FileWatcher {WatcherName}: Skipping change event (ExceptCount: {Count})", watcherName, _exceptCounts[watcherName]);
+ return;
+ }
+
+ Log.Information("[ConfigManager] FileWatcher {WatcherName}: Reloading config from disk", watcherName);
+
+ try
+ {
+ ReloadConfigFile(fileName);
+ if (typeof(T) == typeof(AppConfig))
+ Log.Information("[ConfigManager] FileWatcher: After reload, LogLevel={Level}", ((AppConfig)(object)_configs["AppConfig"]!).Log.LogLevel);
+ Log.Information("[ConfigManager] FileWatcher {WatcherName}: Reload complete", watcherName);
+ OnConfigChanged(typeof(T).Name, "FileChanged", null, null);
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "FileWatcher {WatcherName}: Error reloading config: {Message}", watcherName, ex.Message);
+ }
+ };
+
+ _fileWatchers[watcherName] = watcher;
+ _exceptCounts[watcherName] = 0;
+
+ Log.Information("FileWatcher {WatcherName}: Registered for {Path}", watcherName, path);
+ }
+
+ ///
+ /// Reloads a single config file from disk
+ ///
+ private void ReloadConfigFile(string fileName) where T : class, new()
+ {
+ var path = Path.Combine(_configLocation!, fileName);
+
+ if (!File.Exists(path))
+ {
+ Log.Warning("Config file {FileName} not found for reload", fileName);
+ return;
+ }
+
+ object? config = typeof(T) == typeof(SecurityConfig)
+ ? _loader.LoadSecurityConfig(_configLocation)
+ : _loader.Load(_configLocation, fileName);
+
+ if (config != null)
+ {
+ _configs[typeof(T).Name] = config;
+ ApplyConfig(config);
+ Log.Information("Reloaded config file {FileName}", fileName);
+ }
+ }
+
+ ///
+ /// Increases the exception count to prevent file change events from triggering reloads
+ ///
+ public void IncreaseExceptCount(string watcherName, int count = 1)
+ {
+ if (_exceptCounts.TryGetValue(watcherName, out var current))
+ _exceptCounts[watcherName] = current + count;
+ else
+ _exceptCounts[watcherName] = count;
+ }
+
+ ///
+ /// Decreases the exception count
+ ///
+ public void DecreaseExceptCount(string watcherName, int count = 1)
+ {
+ if (_exceptCounts.TryGetValue(watcherName, out var current))
+ _exceptCounts[watcherName] = Math.Max(0, current - count);
+ }
+
+ ///
+ /// Saves all configurations to files
+ ///
+ public void SaveAll()
+ {
+ if (!_loaded)
+ {
+ Log.Debug("[ConfigManager] SaveAll() skipped (not loaded yet), LogLevel={Level}", (int)AppConfig.Log.LogLevel);
+ return;
+ }
+
+ Log.Debug("[ConfigManager] SaveAll() START, LogLevel={Level}", (int)AppConfig.Log.LogLevel);
+
+ if (string.IsNullOrEmpty(_configLocation))
+ {
+ Log.Error($"[ConfigManager] SaveAll() called with null _configLocation on instance {GetHashCode()}!");
+ // Fallback: set location before saving
+ SetLocation("./Config/");
+ Log.Debug($"[ConfigManager] Emergency SetLocation called, _configLocation now: {_configLocation}");
+ }
+
+ var watcherName = "ConfigFileWatcher_AppConfig";
+ IncreaseExceptCount(watcherName, 2);
+ _saver.Save(AppConfig, _configLocation!, "AppConfig.json");
+
+ watcherName = "ConfigFileWatcher_PluginsConfig";
+ IncreaseExceptCount(watcherName, 2);
+ _saver.Save(PluginsConfig, _configLocation!, "PluginsConfig.json");
+
+ watcherName = "ConfigFileWatcher_SecurityConfig";
+ IncreaseExceptCount(watcherName, 2);
+ _saver.Save(SecurityConfig, _configLocation!, "SecurityConfig.json");
+ }
+
+ ///
+ /// Reloads all configurations from files
+ ///
+ public void Reload()
+ {
+ Load();
+ }
+
+ ///
+ /// Updates the public config properties based on the config object's type
+ ///
+ private void ApplyConfig(object config)
+ {
+ if (config is IAppConfig appConfig)
+ AppConfig = appConfig;
+ else if (config is IPluginsConf pluginsConfig)
+ PluginsConfig = pluginsConfig;
+ else if (config is ISecurityConf securityConfig)
+ SecurityConfig = securityConfig;
+ }
+
+ ///
+ /// Raises the config changed event
+ ///
+ protected void OnConfigChanged(string configType, string propertyName, object? oldValue = null, object? newValue = null)
+ {
+ ConfigChanged?.Invoke(this, new ConfigChangedEventArgs
+ {
+ ConfigType = configType,
+ PropertyName = propertyName,
+ OldValue = oldValue,
+ NewValue = newValue
+ });
+ }
+
+ ///
+ /// Disposes the configuration manager and releases all resources
+ ///
+ public void Dispose()
+ {
+ foreach (var watcher in _fileWatchers.Values)
+ {
+ watcher.EnableRaisingEvents = false;
+ watcher.Dispose();
+ }
+ _fileWatchers.Clear();
+ _exceptCounts.Clear();
+
+ Log.Information("ConfigManager disposed");
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSaver.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSaver.cs
new file mode 100644
index 00000000..aad85d50
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSaver.cs
@@ -0,0 +1,39 @@
+using System.Text.Json;
+using KitX.Core.Contract.Configuration;
+using Serilog;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Saves configuration to files
+///
+public class ConfigSaver : IConfigSaver
+{
+ ///
+ public void Save(T config, string location, string fileName) where T : class
+ {
+ try
+ {
+ var path = Path.Combine(location, fileName);
+
+ // Update metadata fields before serialization
+ if (config is IConfigWithMetadata metadata)
+ {
+ var watcherName = $"ConfigFileWatcher_{typeof(T).Name}";
+ metadata.ConfigFileLocation = path;
+ metadata.ConfigFileWatcherName = watcherName;
+ metadata.ConfigGeneratedTime = DateTime.Now;
+ }
+
+ var jsonContent = JsonSerializer.Serialize(config, ConfigSerializationOptions.Options);
+ var fullPath = Path.GetFullPath(path);
+ File.WriteAllText(fullPath, jsonContent);
+
+ Log.Information("[ConfigSaver] Saved {FileName} → {FullPath} ({Bytes} bytes)", fileName, fullPath, jsonContent.Length);
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "Error saving config file {FileName}: {Message}", fileName, ex.Message);
+ }
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSerializationOptions.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSerializationOptions.cs
new file mode 100644
index 00000000..9779b7d4
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/ConfigSerializationOptions.cs
@@ -0,0 +1,14 @@
+using System.Text.Json;
+
+namespace KitX.Core.Configuration;
+
+///
+/// JSON serializer options for configuration files.
+/// C-15.8: reuses the shared network-protocol options (WriteIndented +
+/// PropertyNameCaseInsensitive superset; IncludeFields/ignore-null are no-ops
+/// for config POCOs).
+///
+internal static class ConfigSerializationOptions
+{
+ internal static readonly JsonSerializerOptions Options = NetworkSerialization.Options;
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Activity.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Activity.cs
new file mode 100644
index 00000000..246ef7d9
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Activity.cs
@@ -0,0 +1,11 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Activity configuration section
+///
+public class Config_Activity : IActivityConf
+{
+ public int TotalRecorded { get; set; } = 0;
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_AnnouncementWindow.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_AnnouncementWindow.cs
new file mode 100644
index 00000000..85b3ac8b
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_AnnouncementWindow.cs
@@ -0,0 +1,31 @@
+using Common.BasicHelper.Graphics.Screen;
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Announcement window configuration
+///
+public class Config_AnnouncementWindow : IAnnouncementWindowConf
+{
+ private Resolution _size = Resolution.Parse("1280x720");
+ private Distances _location = new(left: -1, top: -1);
+
+ ///
+ /// Window size (strong type)
+ ///
+ public Resolution Size
+ {
+ get => _size;
+ set => _size = value;
+ }
+
+ ///
+ /// Window location (strong type)
+ ///
+ public Distances Location
+ {
+ get => _location;
+ set => _location = value;
+ }
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_App.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_App.cs
new file mode 100644
index 00000000..efdbff37
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_App.cs
@@ -0,0 +1,50 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Application configuration section
+///
+public class Config_App : IAppConf
+{
+ public string IconFileName { get; set; } = "KitX-Icon-1920x-margin-2x.png";
+
+ public string CoverIconFileName { get; set; } = "KitX-Icon-Background.png";
+
+ public string AppLanguage { get; set; } = "zh-cn";
+
+ public string Theme { get; set; } = "Follow";
+
+ public string ThemeColor { get; set; } = "#FF3873D9";
+
+ public Dictionary SurpportLanguages { get; set; } =
+ new()
+ {
+ { "zh-cn", "中文 (简体)" },
+ { "zh-tw", "中文 (繁體)" },
+ { "ru-ru", "Русский" },
+ { "en-us", "English (US)" },
+ { "fr-fr", "Français" },
+ { "ja-jp", "日本語" },
+ { "ko-kr", "한국어" },
+ };
+
+ public string LocalPluginsFileFolder { get; set; } = "./Plugins/";
+
+ public string LocalPluginsDataFolder { get; set; } = "./PluginsDatas/";
+
+ public bool DeveloperSetting { get; set; } = false;
+
+ public bool ShowAnnouncementWhenStart { get; set; } = true;
+
+ public ulong RanTime { get; set; } = 0;
+
+ public int LastBreakAfterExit { get; set; } = 2000;
+
+ ///
+ /// Default expand mode for blueprint nested (Block) nodes.
+ /// "Embedded" (default) = Picture-in-Picture inner editor inside the
+ /// NestedNode body; "SubEditor" = modal overlay with breadcrumb.
+ ///
+ public string BlueprintNestedNodeExpandMode { get; set; } = "Embedded";
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_DevicePage.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_DevicePage.cs
new file mode 100644
index 00000000..ae5ef675
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_DevicePage.cs
@@ -0,0 +1,10 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Device page configuration
+///
+public class Config_DevicePage : IDevicePageConf
+{
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_HomePage.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_HomePage.cs
new file mode 100644
index 00000000..614beb01
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_HomePage.cs
@@ -0,0 +1,17 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Home page configuration
+///
+public class Config_HomePage : IHomePageConf
+{
+ public NavigationViewPaneDisplayMode NavigationViewPaneDisplayMode { get; set; } = NavigationViewPaneDisplayMode.Auto;
+
+ public string SelectedViewName { get; set; } = "View_Recent";
+
+ public bool IsNavigationViewPaneOpened { get; set; } = true;
+
+ public bool UseAreaExpanded { get; set; } = true;
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_IO.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_IO.cs
new file mode 100644
index 00000000..a0dce008
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_IO.cs
@@ -0,0 +1,13 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// IO configuration section
+///
+public class Config_IO : IIOConf
+{
+ public int UpdatingCheckPerThreadFilesCount { get; set; } = 20;
+
+ public int OperatingSystemVersionUpdateInterval { get; set; } = 60;
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Loaders.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Loaders.cs
new file mode 100644
index 00000000..8008bf7b
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Loaders.cs
@@ -0,0 +1,11 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Loaders configuration section
+///
+public class Config_Loaders : ILoadersConf
+{
+ public string InstallPath { get; set; } = "./Loaders/";
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Log.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Log.cs
new file mode 100644
index 00000000..00f9d759
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Log.cs
@@ -0,0 +1,29 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Log configuration section
+///
+public class Config_Log : ILogConf
+{
+ public long LogFileSingleMaxSize { get; set; } = 1024 * 1024 * 10; // 10MB
+
+ public string LogFilePath { get; set; } = "./Log/";
+
+ public string LogTemplate { get; set; } = "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] {Message:lj}{NewLine}{Exception}";
+
+ public int LogFileMaxCount { get; set; } = 50;
+
+ public int LogFileFlushInterval { get; set; } = 30;
+
+#if DEBUG
+
+ public LogLevel LogLevel { get; set; } = LogLevel.Information;
+
+#else
+
+ public LogLevel LogLevel { get; set; } = LogLevel.Warning;
+
+#endif
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MainWindow.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MainWindow.cs
new file mode 100644
index 00000000..1436927f
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MainWindow.cs
@@ -0,0 +1,52 @@
+using Common.BasicHelper.Graphics.Screen;
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Main window configuration
+///
+public class Config_MainWindow : IMainWindowConf
+{
+ private Resolution _size = Resolution.Parse("1280x720");
+ private Distances _location = new(left: -1, top: -1);
+
+ ///
+ /// Window size (strong type)
+ ///
+ public Resolution Size
+ {
+ get => _size;
+ set => _size = value;
+ }
+
+ ///
+ /// Window location (strong type)
+ ///
+ public Distances Location
+ {
+ get => _location;
+ set => _location = value;
+ }
+
+ ///
+ /// Window state (strong type)
+ ///
+ public WindowState WindowState { get; set; } = WindowState.Normal;
+
+ public bool IsHidden { get; set; } = false;
+
+ public Dictionary Tags { get; set; } = new() { { "SelectedPage", "Page_Home" } };
+
+ public int GreetingTextCount_Morning { get; set; } = 5;
+
+ public int GreetingTextCount_Noon { get; set; } = 3;
+
+ public int GreetingTextCount_AfterNoon { get; set; } = 3;
+
+ public int GreetingTextCount_Evening { get; set; } = 2;
+
+ public int GreetingTextCount_Night { get; set; } = 4;
+
+ public int GreetingUpdateInterval { get; set; } = 10;
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MarketPage.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MarketPage.cs
new file mode 100644
index 00000000..be6fc30b
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_MarketPage.cs
@@ -0,0 +1,10 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Market page configuration
+///
+public class Config_MarketPage : IMarketPageConf
+{
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Pages.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Pages.cs
new file mode 100644
index 00000000..ff682502
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Pages.cs
@@ -0,0 +1,26 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Pages configuration section
+///
+public class Config_Pages : IPagesConf
+{
+ public Config_HomePage Home { get; set; } = new();
+
+ // Concrete types (not interface): System.Text.Json cannot instantiate an
+ // interface on deserialization — an interface-typed property here made the
+ // whole AppConfig.json load fail and reset every setting to defaults.
+ public Config_DevicePage Device { get; set; } = new();
+
+ public Config_MarketPage Market { get; set; } = new();
+
+ public Config_SettingsPage Settings { get; set; } = new();
+
+ // Explicit interface implementation with setters
+ IHomePageConf IPagesConf.Home { get => Home; set => Home = (Config_HomePage?)value ?? new(); }
+ IDevicePageConf IPagesConf.Device { get => Device; set => Device = (Config_DevicePage?)value ?? new(); }
+ IMarketPageConf IPagesConf.Market { get => Market; set => Market = (Config_MarketPage?)value ?? new(); }
+ ISettingsPageConf IPagesConf.Settings { get => Settings; set => Settings = (Config_SettingsPage?)value ?? new(); }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Performance.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Performance.cs
new file mode 100644
index 00000000..fa6b5343
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Performance.cs
@@ -0,0 +1,29 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Performance configuration section
+///
+public class Config_Performance : IPerformanceConf
+{
+ ///
+ /// Maximum number of compiled workflow assemblies kept in the WorkflowV6
+ /// ScriptCompiler in-memory LRU cache. Larger values trade memory for fewer
+ /// recompilations. Applies at startup.
+ ///
+ public int ScriptCompilerCacheCapacity { get; set; } = 256;
+
+ ///
+ /// Maximum number of Completed instances retained by the ToolKit instance manager.
+ /// Applies at startup.
+ ///
+ public int CompletedInstanceCap { get; set; } = 200;
+
+ ///
+ /// Maximum number of log entries retained per Log panel control. When a control
+ /// appends past this cap the oldest entries are trimmed so the on-screen list stays
+ /// bounded. Read at startup and by the Panel host when building a control.
+ ///
+ public int PanelLogLimit { get; set; } = 1000;
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_SettingsPage.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_SettingsPage.cs
new file mode 100644
index 00000000..787faca8
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_SettingsPage.cs
@@ -0,0 +1,33 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Settings page configuration
+///
+public class Config_SettingsPage : ISettingsPageConf
+{
+ public NavigationViewPaneDisplayMode NavigationViewPaneDisplayMode { get; set; } = NavigationViewPaneDisplayMode.Auto;
+
+ public string SelectedViewName { get; set; } = "View_General";
+
+ public bool PaletteAreaExpanded { get; set; } = false;
+
+ public bool WebRelatedAreaExpanded { get; set; } = true;
+
+ public bool WebRelatedAreaOfNetworkInterfacesExpanded { get; set; } = false;
+
+ public bool LogRelatedAreaExpanded { get; set; } = true;
+
+ public bool UpdateRelatedAreaExpanded { get; set; } = true;
+
+ public bool AboutAreaExpanded { get; set; } = false;
+
+ public bool AuthorsAreaExpanded { get; set; } = false;
+
+ public bool LinksAreaExpanded { get; set; } = false;
+
+ public bool ThirdPartyLicensesAreaExpanded { get; set; } = false;
+
+ public bool IsNavigationViewPaneOpened { get; set; } = true;
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Web.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Web.cs
new file mode 100644
index 00000000..f2ec7c6d
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Web.cs
@@ -0,0 +1,49 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Web configuration section
+///
+public class Config_Web : IWebConf
+{
+ public double DelayStartSeconds { get; set; } = 0.5;
+
+ public string ApiServer { get; set; } = "api.catrol.cn";
+
+ public string ApiPath { get; set; } = "/apps/kitx/";
+
+ public int DevicesViewRefreshDelay { get; set; } = 1000;
+
+ public List? AcceptedNetworkInterfaces { get; set; } = null;
+
+ public int? UserSpecifiedDevicesServerPort { get; set; } = null;
+
+ public int? UserSpecifiedPluginsServerPort { get; set; } = null;
+
+ public int UdpPortSend { get; set; } = 23404;
+
+ public int UdpPortReceive { get; set; } = 24040;
+
+ public int UdpSendFrequency { get; set; } = 1000;
+
+ public string UdpBroadcastAddress { get; set; } = "224.0.0.0";
+
+ public string IPFilter { get; set; } = "192.168";
+
+ public int SocketBufferSize { get; set; } = 1024 * 100;
+
+ public int DeviceInfoTTLSeconds { get; set; } = 7;
+
+ public bool DisableRemovingOfflineDeviceCard { get; set; } = false;
+
+ public string UpdateServer { get; set; } = "api.catrol.cn";
+
+ public string UpdatePath { get; set; } = "/apps/kitx/%platform%/";
+
+ public string UpdateDownloadPath { get; set; } = "/apps/kitx/update/%platform%/";
+
+ public string UpdateChannel { get; set; } = "stable";
+
+ public string UpdateSource { get; set; } = "latest-components.json";
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Windows.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Windows.cs
new file mode 100644
index 00000000..94ee9f2d
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/Config_Windows.cs
@@ -0,0 +1,17 @@
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Windows configuration section
+///
+public class Config_Windows : IWindowsConf
+{
+ public Config_MainWindow MainWindow { get; set; } = new();
+
+ public Config_AnnouncementWindow AnnouncementWindow { get; set; } = new();
+
+ // Explicit interface implementation with setters
+ IMainWindowConf IWindowsConf.MainWindow { get => MainWindow; set => MainWindow = (Config_MainWindow?)value ?? new(); }
+ IAnnouncementWindowConf IWindowsConf.AnnouncementWindow { get => AnnouncementWindow; set => AnnouncementWindow = (Config_AnnouncementWindow?)value ?? new(); }
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/DeviceKeyImpl.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/DeviceKeyImpl.cs
new file mode 100644
index 00000000..5c86b9e0
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/DeviceKeyImpl.cs
@@ -0,0 +1,41 @@
+using System.Text.Json.Serialization;
+using KitX.Core.Contract.Configuration;
+using KitX.Shared.CSharp.Device;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Device key implementation for JSON serialization
+///
+public class DeviceKeyImpl : IDeviceKey
+{
+ ///
+ /// Device locator
+ ///
+ [JsonPropertyName("Device")]
+ public DeviceLocator Device { get; set; } = new();
+
+ ///
+ /// RSA public key in PEM format
+ ///
+ [JsonPropertyName("RsaPublicKeyPem")]
+ public string? RsaPublicKeyPem { get; set; }
+
+ ///
+ /// RSA private key in PEM format
+ ///
+ [JsonPropertyName("RsaPrivateKeyPem")]
+ public string? RsaPrivateKeyPem { get; set; }
+
+ ///
+ /// Time when this key was added
+ ///
+ [JsonPropertyName("AddedAt")]
+ public DateTime AddedAt { get; set; } = DateTime.Now;
+
+ // Explicit interface implementations - these won't be serialized since they use different names
+ string IDeviceKey.MacAddress => Device?.MacAddress ?? string.Empty;
+ string IDeviceKey.DeviceName => Device?.DeviceName ?? string.Empty;
+ string IDeviceKey.PublicKey => RsaPublicKeyPem ?? string.Empty;
+ DateTime IDeviceKey.AddedAt => AddedAt;
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/NetworkSerialization.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/NetworkSerialization.cs
new file mode 100644
index 00000000..1734c454
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/NetworkSerialization.cs
@@ -0,0 +1,21 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace KitX.Core.Configuration;
+
+///
+/// C-15.8: single source of truth for the JSON serializer options used by the
+/// KitX network protocol (legacy wire format). Previously each of
+/// DeviceHttpClient / DevicesServer / PluginsServer / AnnouncementManager /
+/// ConfigSerializationOptions declared its own near-identical copy.
+///
+internal static class NetworkSerialization
+{
+ internal static readonly JsonSerializerOptions Options = new()
+ {
+ WriteIndented = true,
+ IncludeFields = true,
+ PropertyNameCaseInsensitive = true,
+ DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+ };
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/PluginsConfig.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/PluginsConfig.cs
new file mode 100644
index 00000000..ea83ee79
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/PluginsConfig.cs
@@ -0,0 +1,41 @@
+using System.Text.Json.Serialization;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Plugin;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Plugins configuration implementation
+///
+public class PluginsConfig : IPluginsConf, IConfigWithMetadata
+{
+ ///
+ /// Configuration file location
+ ///
+ public string? ConfigFileLocation { get; set; }
+
+ ///
+ /// Configuration file watcher name
+ ///
+ public string? ConfigFileWatcherName { get; set; }
+
+ ///
+ /// Configuration generated time
+ ///
+ public DateTime? ConfigGeneratedTime { get; set; } = DateTime.Now;
+
+ ///
+ /// Plugins list (concrete type for proper serialization)
+ ///
+ public List Plugins { get; set; } = [];
+
+ ///
+ /// Gets plugins as interface (for external use)
+ ///
+ [JsonIgnore]
+ IList IPluginsConf.Plugins
+ {
+ get => Plugins.Cast().ToList();
+ set => Plugins = value?.Cast().ToList() ?? [];
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Configuration/SecurityConfig.cs b/KitX Clients/KitX Core/KitX.Core/Configuration/SecurityConfig.cs
new file mode 100644
index 00000000..130f12e0
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Configuration/SecurityConfig.cs
@@ -0,0 +1,40 @@
+using System.Text.Json.Serialization;
+using KitX.Core.Contract.Configuration;
+
+namespace KitX.Core.Configuration;
+
+///
+/// Security configuration implementation
+///
+public class SecurityConfig : ISecurityConf, IConfigWithMetadata
+{
+ ///
+ /// Configuration file location
+ ///
+ public string? ConfigFileLocation { get; set; }
+
+ ///
+ /// Configuration file watcher name
+ ///
+ public string? ConfigFileWatcherName { get; set; }
+
+ ///
+ /// Configuration generated time
+ ///
+ public DateTime? ConfigGeneratedTime { get; set; } = DateTime.Now;
+
+ ///
+ /// Gets or sets the device keys list (concrete type for proper serialization)
+ ///
+ public List DeviceKeys { get; set; } = [];
+
+ ///
+ /// Gets the device keys as interface (for external use)
+ ///
+ [JsonIgnore]
+ IList ISecurityConf.DeviceKeys
+ {
+ get => DeviceKeys.Cast().ToList();
+ set => DeviceKeys = value?.Cast().ToList() ?? [];
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/ConstantTable.cs b/KitX Clients/KitX Core/KitX.Core/ConstantTable.cs
new file mode 100644
index 00000000..e0c10147
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/ConstantTable.cs
@@ -0,0 +1,62 @@
+using Common.BasicHelper.Utils.Extensions;
+
+namespace KitX.Core;
+
+public static class ConstantTable
+{
+ public const string AppName = "KitX";
+
+ public const string AppFullName = "KitX Dashboard";
+
+ public const string DataPath = "./Data/";
+
+ public const string LanguageFilePath = "./Languages/";
+
+ public const string AssetsPath = "./Assets/";
+
+ public const string UpdateSavePath = "./Update/";
+
+ public const string IconBase64FileName = "KitX.Base64.txt";
+
+ private const string activitiesDataBaseFilePath = $"{DataPath}Activities.db";
+
+ private const string thirdPartyLicenseFilePath = $"{AssetsPath}ThirdPartyLicense.md";
+
+ public static string ActivitiesDataBaseFilePath => activitiesDataBaseFilePath.GetFullPath();
+
+ public static string ThirdPartyLicenseFilePath => thirdPartyLicenseFilePath.GetFullPath();
+
+ ///
+ /// Devices Server Port
+ ///
+ public static int DevicesServerPort = -1;
+
+ ///
+ /// Plugins Server Port
+ ///
+ public static int PluginsServerPort = -1;
+
+ public static bool Running = true;
+
+ public static bool Exiting = false;
+
+ public static bool Restarting = false;
+
+ public static bool EnsureExiting = false;
+
+ public static bool IsMainMachine = false;
+
+ public static string? MainMachineAddress;
+
+ public static int MainMachinePort = -1;
+
+ public static bool SkipNetworkSystemOnStartup = false;
+
+ public static DateTime ServerBuildTime = new();
+
+ public static string KitXIconBase64 = string.Empty;
+
+ public static bool IsSingleProcessStartMode = true;
+
+ public static bool EnabledConfigFileHotReload = true;
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/DI/CoreServiceCollectionExtensions.cs b/KitX Clients/KitX Core/KitX.Core/DI/CoreServiceCollectionExtensions.cs
new file mode 100644
index 00000000..b5c9c3d8
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/DI/CoreServiceCollectionExtensions.cs
@@ -0,0 +1,166 @@
+using Microsoft.Extensions.DependencyInjection;
+using KitX.Core.Contract.Activity;
+using KitX.Core.Contract.Announcement;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.FileWatcher;
+using KitX.Core.Contract.Hotkey;
+using KitX.Core.Contract.Plugin;
+using KitX.Core.Contract.Security;
+using KitX.Core.Contract.Statistics;
+using KitX.Core.Contract.Tasks;
+using KitX.Core.Contract.Event;
+using KitX.Core.Activity;
+using KitX.Core.Announcement;
+using KitX.Core.Configuration;
+using KitX.Core.Device;
+using KitX.Core.FileWatcher;
+using KitX.Core.Hotkey;
+using KitX.Core.Plugin;
+using KitX.Core.Security;
+using KitX.Core.Statistics;
+using KitX.Core.Tasks;
+using EventService = KitX.Core.Event.EventService;
+// Phase 12-prep: legacy KitX.Workflow.Hosting archived. Workflow DI registration is
+// now provided by the new KitX.WorkflowIR library via AddKitXWorkflowIR().
+// using KitX.Workflow.Hosting;
+using Serilog;
+
+namespace KitX.Core.DI;
+
+///
+/// Extension methods for configuring KitX Core services in the dependency injection container
+///
+public static class CoreServiceCollectionExtensions
+{
+ ///
+ /// Adds all KitX Core services to the dependency injection container
+ ///
+ /// The service collection to add services to
+ /// The service collection for chaining
+ public static IServiceCollection AddCoreServices(this IServiceCollection services)
+ {
+ Log.Information("AddCoreServices started...");
+
+ // ServerBuildTime marks the startup time of this process.
+ // Assign it here (the earliest DI assembly point, before any service instance
+ // is constructed) so that NetworkHelper.GetDeviceInfo() and
+ // DevicesDiscoveryServer.UpdateDefaultDeviceInfo() always read a meaningful value.
+ // Guarded to keep the very first assignment when AddCoreServices runs multiple times.
+ if (ConstantTable.ServerBuildTime == DateTime.MinValue)
+ ConstantTable.ServerBuildTime = DateTime.Now;
+
+ // Register all core services as singletons
+ // These services maintain state and should have only one instance throughout the application lifetime
+
+ // Configuration Services
+ Log.Information("Registering IConfigService...");
+ services.AddSingleton(sp => ConfigManager.Instance);
+
+ // Security Services
+ Log.Information("Registering IDeviceKeyService and IEncryptionService...");
+ // Register the concrete SecurityManager once and point both interfaces at that
+ // same instance — MS DI instantiates per (interface, implementation) registration,
+ // so two AddSingleton() calls would create two distinct
+ // SecurityManager instances and split state (device keys, RSA keypair).
+ services.AddSingleton();
+ services.AddSingleton(sp => sp.GetRequiredService());
+ services.AddSingleton(sp => sp.GetRequiredService());
+
+ // Plugin Services
+ Log.Information("Registering IPluginService...");
+ services.AddSingleton();
+
+ // Activity Services
+ Log.Information("Registering IActivityService...");
+ services.AddSingleton();
+
+ // Statistics Services
+ Log.Information("Registering IStatisticsService...");
+ services.AddSingleton();
+
+ // Task Services
+ Log.Information("Registering ITasksService...");
+ services.AddSingleton();
+
+ // File Watcher Services
+ Log.Information("Registering IFileWatcherService...");
+ services.AddSingleton();
+
+ // Hotkey Services
+ Log.Information("Registering IKeyHookService...");
+ services.AddSingleton();
+
+ // Event Services
+ Log.Information("Registering IEventService...");
+ services.AddSingleton();
+
+ // Phase 5: Device and Network Services
+ Log.Information("Registering IDeviceDiscoveryService...");
+ services.AddSingleton();
+
+ Log.Information("Registering IDeviceServer...");
+ services.AddSingleton();
+
+ Log.Information("Registering IDevicesOrganizer...");
+ services.AddSingleton();
+
+ Log.Information("Registering IPluginServer...");
+ services.AddSingleton();
+
+ // Network orchestration — single entry point for starting/stopping the
+ // discovery, devices and plugins servers (replaces the Dashboard's
+ // AppFramework "Initialize WebManager" orchestration).
+ Log.Information("Registering INetworkService...");
+ services.AddSingleton();
+
+ // Kscript plugin bridge → Core: DashboardPluginServiceProvider wires IPluginServer +
+ // IEventService to Kscript's IPluginServiceProvider; RealPluginManager is the live
+ // IPluginManager; PluginHostAdapter bridges it to WorkflowV6's IPluginHost so
+ // workflow PluginCall builtins reach live plugins.
+ services.AddSingleton(sp =>
+ new Plugin.DashboardPluginServiceProvider(
+ sp.GetRequiredService(),
+ sp.GetRequiredService()));
+ services.AddSingleton(sp =>
+ new Kscript.CSharp.Parser.Core.RealPluginManager(
+ sp.GetRequiredService()));
+ services.AddSingleton(sp =>
+ new Plugin.PluginHostAdapter(
+ sp.GetService()
+ ?? new Plugin.NoOpPluginManager(),
+ sp.GetService()));
+
+ // Phase 5: Device HTTP Client (for cross-device plugin invocation)
+ Log.Information("Registering IDeviceHttpClient...");
+ services.AddSingleton();
+
+ // Phase 5: Device Connection Client (for outbound key exchange + authenticated connect)
+ Log.Information("Registering IDeviceConnectionClient...");
+ services.AddSingleton();
+
+ // Phase 5: Announcement Service
+ Log.Information("Registering IAnnouncementService...");
+ services.AddSingleton();
+
+ // Workflow Services — full graph registered by the KitX.Workflow library.
+ // This includes RealPluginManager (registered as a singleton so PluginsServer and
+ // WorkflowScriptService share the same instance and receive plugin connection events;
+ // the caller pre-resolves it after BuildServiceProvider()).
+ //
+ // Phase 12-prep: legacy KitX.Workflow archived to Package\Archive. The new
+ // KitX.WorkflowIR library exposes its own DI entry (AddKitXWorkflowIR), wired by
+ // the host once the front-end migration lands. Workflow services are intentionally
+ // NOT registered here for now — the solution compiles, but workflow features are
+ // disconnected (TODO: re-enable via AddKitXWorkflowIR when Dashboard migrates).
+ // services.AddKitXWorkflow();
+
+ // IMPORTANT: Do NOT call BuildServiceProvider() here.
+ // The caller is responsible for building the single IServiceProvider and passing it
+ // to ServiceHost.Initialize().
+
+ Log.Information("AddCoreServices completed.");
+ return services;
+ }
+
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/DI/ServiceHost.cs b/KitX Clients/KitX Core/KitX.Core/DI/ServiceHost.cs
new file mode 100644
index 00000000..0e415349
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/DI/ServiceHost.cs
@@ -0,0 +1,87 @@
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+
+namespace KitX.Core.DI;
+
+///
+/// 统一动态服务注册管理中心，持有唯一 IServiceProvider。
+/// 所有服务解析通过此类进行，确保单例一致性。
+///
+public static class ServiceHost
+{
+ private static IServiceProvider? _serviceProvider;
+ private static bool _isInitialized;
+
+ ///
+ /// Gets the single IServiceProvider for the application.
+ /// Throws if accessed before initialization.
+ ///
+ public static IServiceProvider ServiceProvider
+ {
+ get
+ {
+ if (_serviceProvider == null)
+ throw new InvalidOperationException(
+ "ServiceHost has not been initialized. " +
+ "Call ServiceHost.Initialize() first.");
+
+ return _serviceProvider;
+ }
+ }
+
+ ///
+ /// Gets whether the ServiceHost has been initialized.
+ ///
+ public static bool IsInitialized => _isInitialized;
+
+ ///
+ /// Initializes the ServiceHost with the single IServiceProvider.
+ /// This should be called exactly ONCE during application startup,
+ /// after building the service provider.
+ ///
+ /// The single IServiceProvider instance
+ public static void Initialize(IServiceProvider serviceProvider)
+ {
+ if (_isInitialized)
+ {
+ Log.Warning("[ServiceHost] Initialize called more than once. Ignoring.");
+ return;
+ }
+
+ _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
+ _isInitialized = true;
+
+ Log.Information("[ServiceHost] Initialized. ServiceProvider HashCode: {HashCode}",
+ serviceProvider.GetHashCode());
+ }
+
+ ///
+ /// Gets a required service from the DI container.
+ /// Throws InvalidOperationException if the service is not registered.
+ /// Use this for all core services that MUST be registered.
+ ///
+ public static T GetRequiredService() where T : notnull
+ {
+ return ServiceProvider.GetRequiredService();
+ }
+
+ ///
+ /// Gets a service from the DI container, or null if not registered.
+ /// Use this for optional services.
+ ///
+ public static T? GetService() where T : class
+ {
+ return ServiceProvider.GetService();
+ }
+
+ ///
+ /// Creates an instance of an unregistered type using constructor injection
+ /// from the DI container. Use this for ViewModels and other types that
+ /// are not explicitly registered but have constructor dependencies on
+ /// registered services.
+ ///
+ public static T CreateInstance() where T : class
+ {
+ return ActivatorUtilities.CreateInstance(ServiceProvider);
+ }
+}
\ No newline at end of file
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DeviceCase.cs b/KitX Clients/KitX Core/KitX.Core/Device/DeviceCase.cs
new file mode 100644
index 00000000..e25ef455
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DeviceCase.cs
@@ -0,0 +1,217 @@
+using System;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using KitX.Core.Common;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.Security;
+using KitX.Shared.CSharp.Device;
+using Serilog;
+
+namespace KitX.Core.Device;
+
+///
+/// Device case implementation
+/// Phase 6.5: Aligned with legacy DeviceCase functionality
+///
+public class DeviceCase : IDeviceCase, INotifyPropertyChanged
+{
+ private readonly IConfigService _configService;
+ private readonly IDeviceKeyService _securityService;
+ private readonly IDeviceServer _devicesServer;
+ private readonly IDeviceDiscoveryService _deviceDiscoveryService;
+ private readonly IDeviceConnectionClient _connectionClient;
+ private readonly IDeviceKeyExchangeUi _keyExchangeUi;
+
+ ///
+ /// Creates a new device case with dependency injection
+ ///
+ public DeviceCase(
+ IConfigService configService,
+ IDeviceKeyService securityService,
+ IDeviceServer devicesServer,
+ IDeviceDiscoveryService deviceDiscoveryService,
+ IDeviceConnectionClient connectionClient,
+ IDeviceKeyExchangeUi keyExchangeUi)
+ : this(new DeviceInfo(), configService, securityService, devicesServer, deviceDiscoveryService,
+ connectionClient, keyExchangeUi)
+ {
+ }
+
+ ///
+ /// Creates a new device case with device info and dependency injection
+ ///
+ /// Device information
+ /// The config service
+ /// The security service
+ /// The devices server
+ /// The device discovery service
+ /// The outbound device connection client
+ /// The device key-exchange UI abstraction
+ public DeviceCase(
+ DeviceInfo deviceInfo,
+ IConfigService configService,
+ IDeviceKeyService securityService,
+ IDeviceServer devicesServer,
+ IDeviceDiscoveryService deviceDiscoveryService,
+ IDeviceConnectionClient connectionClient,
+ IDeviceKeyExchangeUi keyExchangeUi)
+ {
+ DeviceInfo = deviceInfo;
+ _configService = configService ?? throw new ArgumentNullException(nameof(configService));
+ _securityService = securityService ?? throw new ArgumentNullException(nameof(securityService));
+ _devicesServer = devicesServer ?? throw new ArgumentNullException(nameof(devicesServer));
+ _deviceDiscoveryService = deviceDiscoveryService ?? throw new ArgumentNullException(nameof(deviceDiscoveryService));
+ _connectionClient = connectionClient ?? throw new ArgumentNullException(nameof(connectionClient));
+ _keyExchangeUi = keyExchangeUi ?? throw new ArgumentNullException(nameof(keyExchangeUi));
+
+ AuthorizeAndExchangeDeviceKeyCommand = new AsyncRelayCommand(AuthorizeAndExchangeDeviceKeyAsync);
+ UnAuthorizeCommand = new AsyncRelayCommand(UnAuthorizeAsync);
+ }
+
+ ///
+ /// Raised when a bound property changes. The DevicesPage card binds
+ /// DeviceInfo.* chains; without this, refreshed discovery broadcasts
+ /// (new PluginsCount/SendTime) replace the backing object silently and the
+ /// card freezes at its first-render values.
+ ///
+ public event PropertyChangedEventHandler? PropertyChanged;
+
+ private DeviceInfo? _deviceInfo;
+
+ ///
+ public DeviceInfo DeviceInfo
+ {
+ get => _deviceInfo!;
+ set
+ {
+ _deviceInfo = value;
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(DeviceInfo)));
+ }
+ }
+
+ ///
+ public bool IsAuthorized => _securityService.IsDeviceAuthorized(DeviceInfo.Device);
+
+ ///
+ public bool IsMainDevice => DeviceInfo?.IsMainDevice ?? false;
+
+ ///
+ public bool IsOnline => !IsOffline();
+
+ ///
+ public DateTime LastSeen => DeviceInfo?.SendTime ?? DateTime.UtcNow;
+
+ ///
+ /// Gets a value indicating whether the device is currently signed in
+ ///
+ public bool IsConnected => _devicesServer.IsDeviceSignedIn(DeviceInfo.Device) || ConnectionToken is not null;
+
+ ///
+ /// Gets a value indicating whether this is the current device
+ ///
+ public bool IsCurrentDevice => DeviceInfo.IsCurrentDevice(_deviceDiscoveryService.DefaultDeviceInfo);
+
+ ///
+ /// Connection token for authenticated communication
+ ///
+ public string? ConnectionToken { get; set; }
+
+ ///
+ /// Initiates the encrypted key exchange and authenticated connection against the
+ /// target device (initiating side). Displays the temporary password, exchanges
+ /// public keys, then connects to obtain a session token.
+ ///
+ public ICommand AuthorizeAndExchangeDeviceKeyCommand { get; }
+
+ ///
+ /// Removes this device's key, revoking authorization.
+ ///
+ public ICommand UnAuthorizeCommand { get; }
+
+ private async Task AuthorizeAndExchangeDeviceKeyAsync()
+ {
+ if (IsCurrentDevice)
+ return;
+
+ var password = GeneratePassword();
+
+ try
+ {
+ using (_keyExchangeUi.ShowPasswordForInitiator(password))
+ {
+ var result = await _connectionClient.ExchangeKeyAsync(DeviceInfo, password);
+ if (!result.Success)
+ {
+ Log.Warning("[DeviceCase] Key exchange failed for {Device}: {Error}",
+ DeviceInfo.Device.DeviceName, result.Error);
+ return;
+ }
+ }
+
+ var token = await _connectionClient.ConnectAsync(DeviceInfo);
+ if (token is not null)
+ ConnectionToken = token;
+
+ NotifyStateChanged();
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceCase] AuthorizeAndExchangeDeviceKeyAsync failed for {Device}",
+ DeviceInfo.Device.DeviceName);
+ }
+ }
+
+ private async Task UnAuthorizeAsync()
+ {
+ await Task.Yield();
+
+ try
+ {
+ _securityService.RemoveDeviceKey(DeviceInfo.Device.MacAddress);
+ ConnectionToken = null;
+ NotifyStateChanged();
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceCase] UnAuthorizeAsync failed for {Device}", DeviceInfo.Device.DeviceName);
+ }
+ }
+
+ ///
+ /// Generates an 8-digit temporary password using digits 1-9 (matching the receive-side
+ /// entry regex [1-9]{8}).
+ ///
+ private static string GeneratePassword()
+ {
+ const string digits = "123456789";
+ var bytes = new byte[8];
+ RandomNumberGenerator.Fill(bytes);
+ var chars = new char[8];
+ for (var i = 0; i < chars.Length; ++i)
+ chars[i] = digits[bytes[i] % digits.Length];
+ return new string(chars);
+ }
+
+ private void NotifyStateChanged()
+ {
+ OnPropertyChanged(nameof(IsAuthorized));
+ OnPropertyChanged(nameof(IsConnected));
+ OnPropertyChanged(nameof(ConnectionToken));
+ }
+
+ private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+ => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+
+ ///
+ /// Checks if the device is offline (not seen within TTL period)
+ ///
+ private bool IsOffline()
+ {
+ var ttl = TimeSpan.FromSeconds(_configService.AppConfig.Web.DeviceInfoTTLSeconds);
+ return DeviceInfo.IsOffline(_configService.AppConfig.Web.DeviceInfoTTLSeconds);
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DeviceConnectionClient.cs b/KitX Clients/KitX Core/KitX.Core/Device/DeviceConnectionClient.cs
new file mode 100644
index 00000000..7c375a0d
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DeviceConnectionClient.cs
@@ -0,0 +1,272 @@
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.Security;
+using KitX.Shared.CSharp.Device;
+using Serilog;
+
+namespace KitX.Core.Device;
+
+///
+/// Outbound device encrypted-authentication connection client.
+/// Initiates key exchange and connection against a remote DevicesServer,
+/// mirroring the receive-side endpoints implemented in .
+/// Only public keys are ever sent to the remote; the local private key never leaves
+/// this process.
+///
+public class DeviceConnectionClient : IDeviceConnectionClient
+{
+ private static readonly HttpClient _httpClient = new(new SocketsHttpHandler
+ {
+ MaxConnectionsPerServer = 8,
+ PooledConnectionLifetime = TimeSpan.FromMinutes(5)
+ })
+ {
+ // Generous timeout: an exchange waits on the remote user's confirmation for up
+ // to 60 seconds (ExchangeKeyConfirmationTimeout) before it responds.
+ Timeout = TimeSpan.FromSeconds(75)
+ };
+
+ private readonly IDeviceKeyService _deviceKeyService;
+ private readonly IEncryptionService _encryptionService;
+
+ ///
+ /// JSON serializer options (compatible with legacy KitX network protocol).
+ /// C-15.8: shared instance.
+ ///
+ private static readonly JsonSerializerOptions SerializerOptions = KitX.Core.Configuration.NetworkSerialization.Options;
+
+ public DeviceConnectionClient(IDeviceKeyService deviceKeyService, IEncryptionService encryptionService)
+ {
+ _deviceKeyService = deviceKeyService ?? throw new System.ArgumentNullException(nameof(deviceKeyService));
+ _encryptionService = encryptionService ?? throw new System.ArgumentNullException(nameof(encryptionService));
+ }
+
+ ///
+ public async Task ExchangeKeyAsync(
+ DeviceInfo targetDevice,
+ string password,
+ CancellationToken ct = default)
+ {
+ if (targetDevice?.Device == null || !TryGetAddress(targetDevice, out var ipv4, out var port))
+ return Fail("Invalid target device");
+
+ try
+ {
+ var publicKeyJson = BuildLocalPublicKeyJson();
+ var encryptedKey = _encryptionService.AesEncrypt(publicKeyJson, password);
+
+ var request = new ExchangeKeyRequest
+ {
+ DeviceKey = encryptedKey,
+ Address = GetLocalIpv4()
+ };
+ var body = JsonSerializer.Serialize(request, SerializerOptions);
+
+ var url = $"http://{ipv4}:{port}/Api/V1/Device/ExchangeKey";
+ Log.Information("[DeviceConnectionClient] Exchanging key with {Url}", url);
+
+ using var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
+ {
+ Content = new StringContent(body, Encoding.UTF8, "application/json")
+ };
+
+ var response = await _httpClient.SendAsync(httpRequest, ct);
+ if (!response.IsSuccessStatusCode)
+ {
+ var err = await response.Content.ReadAsStringAsync(ct);
+ Log.Warning("[DeviceConnectionClient] ExchangeKey failed: {Status} {Error}",
+ (int)response.StatusCode, err);
+ return Fail($"ExchangeKey failed: {(int)response.StatusCode} {err}");
+ }
+
+ var encryptedRemoteKey = await response.Content.ReadAsStringAsync(ct);
+
+ // The server wraps the Base64 in a JSON string literal ("..."), so unwrap it.
+ var encryptedRemoteKeyBase64 = JsonSerializer.Deserialize(encryptedRemoteKey, SerializerOptions);
+ if (string.IsNullOrEmpty(encryptedRemoteKeyBase64))
+ {
+ Log.Warning("[DeviceConnectionClient] ExchangeKey returned an empty remote key payload");
+ return Fail("Remote device returned an invalid public key");
+ }
+
+ var remoteKeyJson = _encryptionService.AesDecrypt(encryptedRemoteKeyBase64, password);
+ var remoteKey = JsonSerializer.Deserialize(remoteKeyJson, SerializerOptions);
+
+ if (remoteKey == null || string.IsNullOrEmpty(remoteKey.RsaPublicKeyPem))
+ {
+ Log.Warning("[DeviceConnectionClient] ExchangeKey returned an invalid remote key");
+ return Fail("Remote device returned an invalid public key");
+ }
+
+ _deviceKeyService.AddDeviceKey(
+ remoteKey.Device.MacAddress,
+ remoteKey.Device.DeviceName,
+ remoteKey.RsaPublicKeyPem);
+
+ Log.Information("[DeviceConnectionClient] Key exchange complete with {Device}", remoteKey.Device.DeviceName);
+ return new ExchangeKeyResult { Success = true, RemoteDeviceKey = remoteKey };
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceConnectionClient] ExchangeKeyAsync failed");
+ return Fail(ex.Message);
+ }
+ }
+
+ ///
+ public async Task ExchangeKeyBackAsync(
+ DeviceInfo targetDevice,
+ string password,
+ CancellationToken ct = default)
+ {
+ if (targetDevice?.Device == null || !TryGetAddress(targetDevice, out var ipv4, out var port))
+ return false;
+
+ try
+ {
+ var publicKeyJson = BuildLocalPublicKeyJson();
+ var encryptedKey = _encryptionService.AesEncrypt(publicKeyJson, password);
+ var url = $"http://{ipv4}:{port}/Api/V1/Device/ExchangeKeyBack";
+
+ using var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
+ {
+ Content = new StringContent(encryptedKey, Encoding.UTF8, "application/json")
+ };
+
+ var response = await _httpClient.SendAsync(httpRequest, ct);
+ return response.IsSuccessStatusCode;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceConnectionClient] ExchangeKeyBackAsync failed");
+ return false;
+ }
+ }
+
+ ///
+ public async Task CancelExchangingKeyAsync(DeviceInfo targetDevice, CancellationToken ct = default)
+ {
+ if (targetDevice?.Device == null || !TryGetAddress(targetDevice, out var ipv4, out var port))
+ return false;
+
+ try
+ {
+ var url = $"http://{ipv4}:{port}/Api/V1/Device/CancelExchangingKey";
+ using var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
+ {
+ Content = new StringContent(string.Empty, Encoding.UTF8, "application/json")
+ };
+ var response = await _httpClient.SendAsync(httpRequest, ct);
+ return response.IsSuccessStatusCode;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceConnectionClient] CancelExchangingKeyAsync failed");
+ return false;
+ }
+ }
+
+ ///
+ public async Task ConnectAsync(DeviceInfo targetDevice, CancellationToken ct = default)
+ {
+ if (targetDevice?.Device == null || !TryGetAddress(targetDevice, out var ipv4, out var port))
+ return null;
+
+ try
+ {
+ var localKey = _deviceKeyService.GetPrivateDeviceKey();
+ if (localKey == null)
+ return null;
+
+ // The target must already have our public key (from a completed exchange).
+ var targetKey = _deviceKeyService.SearchDeviceKey(targetDevice.Device);
+ if (targetKey == null || string.IsNullOrEmpty(targetKey.RsaPublicKeyPem))
+ {
+ Log.Warning("[DeviceConnectionClient] No public key for target {Device}; exchange first",
+ targetDevice.Device.DeviceName);
+ return null;
+ }
+
+ // Sign our device name with our PRIVATE key and send our OWN locator. The remote
+ // verifies the signature against the public key it stored during the exchange,
+ // proving we hold the private key (PKI) before issuing a session token.
+ var signature = _encryptionService.RsaSignString(localKey, localKey.Device.DeviceName);
+ if (string.IsNullOrEmpty(signature))
+ return null;
+
+ var locatorJson = JsonSerializer.Serialize(localKey.Device, SerializerOptions);
+ var deviceBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(locatorJson));
+ var url = $"http://{ipv4}:{port}/Api/V1/Device/Connect?deviceBase64={Uri.EscapeDataString(deviceBase64)}";
+
+ using var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
+ {
+ Content = new StringContent(signature, Encoding.UTF8, "application/json")
+ };
+
+ var response = await _httpClient.SendAsync(httpRequest, ct);
+ if (!response.IsSuccessStatusCode)
+ {
+ var err = await response.Content.ReadAsStringAsync(ct);
+ Log.Warning("[DeviceConnectionClient] Connect failed: {Status} {Error}", (int)response.StatusCode, err);
+ return null;
+ }
+
+ var encryptedToken = await response.Content.ReadAsStringAsync(ct);
+ var token = await _encryptionService.DecryptStringAsync(encryptedToken, localKey.Device.MacAddress);
+ Log.Information("[DeviceConnectionClient] Connected to {Device}", targetDevice.Device.DeviceName);
+ return token;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceConnectionClient] ConnectAsync failed");
+ return null;
+ }
+ }
+
+ ///
+ /// Serializes the local public-key-only (never the private key).
+ ///
+ private string BuildLocalPublicKeyJson()
+ {
+ var localKey = _deviceKeyService.GetPrivateDeviceKey()
+ ?? throw new InvalidOperationException("Local device key not set up");
+
+ // GetPrivateDeviceKey now carries the public key, so use it directly rather than
+ // re-looking it up by locator — the locator lookup can transiently miss when the
+ // local key was just (re)generated, causing a spurious "Local public key not found".
+ var publicKeyPem = localKey.RsaPublicKeyPem;
+ if (string.IsNullOrEmpty(publicKeyPem))
+ throw new InvalidOperationException("Local public key not found");
+
+ var publicOnlyKey = new DeviceKey
+ {
+ Device = localKey.Device,
+ RsaPublicKeyPem = publicKeyPem
+ };
+ return JsonSerializer.Serialize(publicOnlyKey, SerializerOptions);
+ }
+
+ private string GetLocalIpv4()
+ {
+ try
+ {
+ return NetworkHelper.GetInterNetworkIPv4() ?? string.Empty;
+ }
+ catch
+ {
+ return string.Empty;
+ }
+ }
+
+ private static bool TryGetAddress(DeviceInfo target, out string ipv4, out int port)
+ {
+ ipv4 = target.Device.IPv4;
+ port = target.DevicesServerPort;
+ return !string.IsNullOrEmpty(ipv4) && port > 0;
+ }
+
+ private static ExchangeKeyResult Fail(string error) =>
+ new() { Success = false, Error = error };
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DeviceHttpClient.cs b/KitX Clients/KitX Core/KitX.Core/Device/DeviceHttpClient.cs
new file mode 100644
index 00000000..2af61145
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DeviceHttpClient.cs
@@ -0,0 +1,113 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using KitX.Core.Contract.Device;
+using KitX.Shared.CSharp.Device;
+using KitX.Shared.CSharp.WebCommand;
+using Serilog;
+
+namespace KitX.Core.Device;
+
+///
+/// Device HTTP client implementation.
+/// Sends plugin invoke requests to remote DevicesServer over HTTP.
+/// Protocol compatible with legacy PluginControllerExtensions.RemoteInvoke.
+/// Implements the contract now defined in KitX.Core.Contract.
+///
+public class DeviceHttpClient : IDeviceHttpClient
+{
+ // C-15.3: cap per-server connections so fan-out plugin invokes to one device
+ // cannot exhaust the connection pool.
+ private static readonly HttpClient _httpClient = new(new SocketsHttpHandler
+ {
+ MaxConnectionsPerServer = 8,
+ PooledConnectionLifetime = TimeSpan.FromMinutes(5)
+ })
+ {
+ Timeout = TimeSpan.FromSeconds(35)
+ };
+
+ ///
+ /// JSON serializer options (compatible with legacy KitX network protocol).
+ /// C-15.8: shared instance.
+ ///
+ private static readonly JsonSerializerOptions SerializerOptions = KitX.Core.Configuration.NetworkSerialization.Options;
+
+ ///
+ /// Invokes a plugin method on a remote device.
+ ///
+ public async Task InvokePluginAsync(
+ DeviceInfo targetDevice,
+ string token,
+ Request request,
+ CancellationToken ct = default)
+ {
+ if (targetDevice?.Device == null)
+ {
+ Log.Warning("[DeviceHttpClient] InvokePluginAsync called with null targetDevice");
+ return null;
+ }
+
+ var ipv4 = targetDevice.Device.IPv4;
+ var port = targetDevice.DevicesServerPort;
+
+ if (string.IsNullOrEmpty(ipv4) || port <= 0)
+ {
+ Log.Warning("[DeviceHttpClient] Invalid device address: IPv4={IPv4}, Port={Port}",
+ ipv4, port);
+ return null;
+ }
+
+ try
+ {
+ // Step 1: Serialize Request to JSON
+ var requestJson = JsonSerializer.Serialize(request, SerializerOptions);
+
+ // Step 2: Wrap in base64 (legacy protocol format)
+ var requestJsonBytes = Encoding.UTF8.GetBytes(requestJson);
+ var requestJsonBase64 = Convert.ToBase64String(requestJsonBytes);
+ var wrappedJson = JsonSerializer.Serialize(requestJsonBase64);
+
+ // Step 3: Build URL — the token is deliberately NOT placed in the URL query
+ // (tokens in URLs leak via logs/history). It travels in the Authorization
+ // header as a bearer credential.
+ var url = $"http://{ipv4}:{port}/Api/V1/Plugin/Invoke";
+
+ Log.Debug("[DeviceHttpClient] Sending plugin invoke to {Url}, Target={Target}, Function={Function}",
+ url, request.Target, request.Content);
+
+ // Step 4: Send HTTP POST with the token in the header
+ var httpRequest = new HttpRequestMessage(HttpMethod.Post, url)
+ {
+ Content = new StringContent(wrappedJson, Encoding.UTF8, "application/json")
+ };
+ httpRequest.Headers.TryAddWithoutValidation("Authorization", $"Bearer {token}");
+ httpRequest.Headers.TryAddWithoutValidation("X-Device-Token", token);
+
+ var response = await _httpClient.SendAsync(httpRequest, ct);
+
+ Log.Debug("[DeviceHttpClient] Received response from {Url}: Status={Status}",
+ url, response.StatusCode);
+
+ return response;
+ }
+ catch (HttpRequestException ex)
+ {
+ Log.Error(ex, "[DeviceHttpClient] HTTP error invoking plugin on device {Device}:{Port}",
+ ipv4, port);
+ return null;
+ }
+ catch (TaskCanceledException ex) when (ex.CancellationToken != ct)
+ {
+ Log.Error(ex, "[DeviceHttpClient] Timeout invoking plugin on device {Device}:{Port}",
+ ipv4, port);
+ return null;
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, "[DeviceHttpClient] Unexpected error invoking plugin on device {Device}:{Port}",
+ ipv4, port);
+ return null;
+ }
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DevicesDiscoveryServer.cs b/KitX Clients/KitX Core/KitX.Core/Device/DevicesDiscoveryServer.cs
new file mode 100644
index 00000000..8596cc89
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DevicesDiscoveryServer.cs
@@ -0,0 +1,433 @@
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Text.Json;
+using CTask = System.Threading.Tasks.Task;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.Event;
+using KitX.Core.Contract.Plugin;
+using KitX.Shared.CSharp.Device;
+using Serilog;
+
+namespace KitX.Core.Device;
+
+///
+/// Device discovery server for UDP broadcast
+///
+public class DevicesDiscoveryServer : ServerBase, IDeviceDiscoveryService
+{
+ private readonly IConfigService _configService;
+ private readonly IEventService _eventService;
+ private readonly IPluginServer _pluginServer;
+ private UdpClient? _udpSender;
+ private UdpClient? _udpReceiver;
+ private System.Timers.Timer? _udpSendTimer;
+ private readonly List _supportedNetworkInterfacesIndexes = new();
+
+ // C-15.10: handle on the Stop() grace task so a subsequent Run() can cancel it and
+ // no orphan continuation lingers after shutdown.
+ private CTask? _stopGraceTask;
+ private CancellationTokenSource? _stopGraceCts;
+
+ private bool _disposed;
+ private int _deviceInfoUpdatedTimes = 0;
+ private int _lastTimeToOSVersionUpdated = 0;
+
+ ///
+ /// Gets or sets the port
+ ///
+ public int? Port { get; private set; }
+
+ ///
+ /// Configured port for the server
+ ///
+ private int? _configuredPort;
+
+ ///
+ /// Configures the port for the server
+ ///
+ /// The port number
+ public void ConfigurePort(int port)
+ {
+ _configuredPort = port > 0 ? port : null;
+ }
+
+ ///
+ /// Request to close the server
+ ///
+ public bool CloseDevicesDiscoveryServerRequest { get; internal set; }
+
+ ///
+ /// Queue of messages to broadcast
+ ///
+ public Queue Messages2BroadCast { get; } = new();
+
+ ///
+ /// Default device information
+ ///
+ public DeviceInfo DefaultDeviceInfo { get; private set; }
+
+ ///
+ /// Event raised when a device is discovered
+ ///
+ public event EventHandler? DeviceDiscovered;
+
+ ///
+ /// Event raised when a device goes offline
+ ///
+#pragma warning disable CS0067
+ public event EventHandler? DeviceOffline;
+#pragma warning restore CS0067
+
+ ///
+ /// Creates a new device discovery server with dependency injection
+ ///
+ /// The configuration service
+ /// The event service for publishing events
+ /// The plugin server for querying connection info
+ public DevicesDiscoveryServer(IConfigService configService, IEventService eventService, IPluginServer pluginServer)
+ {
+ _configService = configService ?? throw new ArgumentNullException(nameof(configService));
+ _eventService = eventService ?? throw new ArgumentNullException(nameof(eventService));
+ _pluginServer = pluginServer ?? throw new ArgumentNullException(nameof(pluginServer));
+ DefaultDeviceInfo = NetworkHelper.GetDeviceInfo();
+
+ // Note: DevicesOrganizer.Run() should be called after services are fully initialized
+ // to avoid blocking during DI container setup
+ }
+
+ ///
+ /// Starts the device discovery service
+ ///
+ /// The service instance
+ public IDeviceDiscoveryService Run()
+ {
+ if (!TryStart())
+ return this;
+
+ // C-15.10: cancel a pending stop-grace wait from an earlier Stop().
+ _stopGraceCts?.Cancel();
+ _stopGraceCts?.Dispose();
+ _stopGraceCts = null;
+ _stopGraceTask = null;
+
+ Initialize();
+
+ // Read configuration from IConfigService
+ var udpPortSend = _configService.AppConfig.Web.UdpPortSend;
+ var udpPortReceive = _configService.AppConfig.Web.UdpPortReceive;
+ var udpBroadcastAddress = _configService.AppConfig.Web.UdpBroadcastAddress;
+
+ Port = udpPortSend;
+
+ _udpSender = new UdpClient(udpPortSend, AddressFamily.InterNetwork)
+ {
+ EnableBroadcast = true,
+ MulticastLoopback = true,
+ };
+
+ _udpReceiver = new UdpClient(new IPEndPoint(IPAddress.Any, udpPortReceive));
+
+ CTask.Run(() =>
+ {
+ try
+ {
+ FindSupportNetworkInterfaces(
+ [_udpSender, _udpReceiver],
+ IPAddress.Parse(udpBroadcastAddress)
+ );
+ }
+ catch (Exception ex)
+ {
+ const string location = $"{nameof(DevicesDiscoveryServer)}.{nameof(Run)}";
+ Log.Warning(ex, $"In {location}: {ex.Message}");
+ }
+ });
+
+ CTask.Run(MultiDevicesBroadCastSend);
+ CTask.Run(MultiDevicesBroadCastReceive);
+
+ SetRunning();
+
+ return this;
+ }
+
+ ///
+ /// Stops the device discovery service
+ ///
+ public void Stop()
+ {
+ if (!TryStop())
+ return;
+
+ CloseDevicesDiscoveryServerRequest = true;
+
+ // C-15.10: cancellable grace period instead of a fire-and-forget. The broadcast/
+ // receive loops observe CloseDevicesDiscoveryServerRequest asynchronously; status
+ // flips to Pending only after they had one cycle to shut down. A subsequent
+ // Run() cancels this wait instead of racing it.
+ _stopGraceCts?.Cancel();
+ _stopGraceCts?.Dispose();
+
+ var cts = new CancellationTokenSource();
+ _stopGraceCts = cts;
+
+ _stopGraceTask = CTask.Run(async () =>
+ {
+ try
+ {
+ await CTask.Delay(1000, cts.Token); // Wait for threads to finish
+ SetPending();
+ }
+ catch (OperationCanceledException)
+ {
+ // Cancelled by a subsequent Run() — nothing to do.
+ }
+ });
+ }
+
+ private void Initialize()
+ {
+ _disposed = false;
+ CloseDevicesDiscoveryServerRequest = false;
+ _supportedNetworkInterfacesIndexes.Clear();
+ Messages2BroadCast.Clear();
+ DefaultDeviceInfo = NetworkHelper.GetDeviceInfo();
+ _deviceInfoUpdatedTimes = 0;
+ _lastTimeToOSVersionUpdated = 0;
+ }
+
+ private void FindSupportNetworkInterfaces(List clients, IPAddress multicastAddress)
+ {
+ var multicastGroupJoinedInterfacesCount = 0;
+
+ foreach (var adapter in NetworkInterface.GetAllNetworkInterfaces())
+ {
+ var adapterProperties = adapter.GetIPProperties();
+
+ if (adapterProperties is null)
+ continue;
+
+ if (!CheckNetworkInterface(adapter, adapterProperties))
+ continue;
+
+ var unicastIPAddresses = adapterProperties.UnicastAddresses;
+
+ if (unicastIPAddresses is null)
+ continue;
+
+ var p = adapterProperties.GetIPv4Properties();
+
+ if (p is null)
+ continue;
+
+ _supportedNetworkInterfacesIndexes.Add(IPAddress.HostToNetworkOrder(p.Index));
+
+ foreach (var ipAddress in unicastIPAddresses.Select(x => x.Address).Where(x => x.AddressFamily == AddressFamily.InterNetwork))
+ {
+ try
+ {
+ foreach (var udpClient in clients)
+ udpClient?.JoinMulticastGroup(multicastAddress, ipAddress);
+
+ ++multicastGroupJoinedInterfacesCount;
+ }
+ catch (Exception ex)
+ {
+ const string location = $"{nameof(DevicesDiscoveryServer)}.{nameof(FindSupportNetworkInterfaces)}";
+
+ Log.Error(ex, $"In {location}: {ex.Message}");
+ }
+ }
+ }
+
+ Log.Information($"Find {_supportedNetworkInterfacesIndexes.Count} supported network interfaces.");
+ Log.Information($"Joined {multicastGroupJoinedInterfacesCount} multicast groups.");
+ }
+
+ private bool CheckNetworkInterface(NetworkInterface adapter, IPInterfaceProperties adapterProperties)
+ {
+ // Filter for operational, supported network interfaces
+ return adapter.OperationalStatus == OperationalStatus.Up &&
+ adapter.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
+ adapter.Supports(NetworkInterfaceComponent.IPv4);
+ }
+
+ private void UpdateDefaultDeviceInfo()
+ {
+ DefaultDeviceInfo.IsMainDevice = ConstantTable.IsMainMachine;
+ DefaultDeviceInfo.SendTime = DateTime.UtcNow;
+ DefaultDeviceInfo.Device.ResetIPv4(NetworkHelper.GetInterNetworkIPv4())
+ .ResetIPv6(NetworkHelper.GetInterNetworkIPv6());
+ DefaultDeviceInfo.PluginsServerPort = ConstantTable.PluginsServerPort;
+ DefaultDeviceInfo.PluginsCount = _pluginServer.Connections?.Count ?? 0;
+ DefaultDeviceInfo.DevicesServerPort = ConstantTable.DevicesServerPort;
+ DefaultDeviceInfo.DevicesServerBuildTime = ConstantTable.ServerBuildTime;
+
+ // Update OS version periodically
+ if (_lastTimeToOSVersionUpdated > _configService.AppConfig.IO.OperatingSystemVersionUpdateInterval)
+ {
+ _lastTimeToOSVersionUpdated = 0;
+ DefaultDeviceInfo.DeviceOSVersion = NetworkHelper.TryGetOsVersionString() ?? "";
+ }
+
+ ++_deviceInfoUpdatedTimes;
+ ++_lastTimeToOSVersionUpdated;
+
+ if (_deviceInfoUpdatedTimes < 0)
+ _deviceInfoUpdatedTimes = 0;
+ }
+
+ private void MultiDevicesBroadCastSend()
+ {
+ const string location = $"{nameof(DevicesDiscoveryServer)}.{nameof(MultiDevicesBroadCastSend)}";
+
+ var udpPortReceive = _configService.AppConfig.Web.UdpPortReceive;
+ var udpBroadcastAddress = _configService.AppConfig.Web.UdpBroadcastAddress;
+ var udpSendFrequency = _configService.AppConfig.Web.UdpSendFrequency;
+
+ var multicast = new IPEndPoint(
+ IPAddress.Parse(udpBroadcastAddress),
+ udpPortReceive
+ );
+
+ _udpSender?.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+
+ var erroredInterfacesIndexes = new List();
+ var erroredInterfacesIndexesTTL = 60;
+
+ _udpSendTimer = new System.Timers.Timer { Interval = udpSendFrequency, AutoReset = true };
+
+ _udpSendTimer.Elapsed += (_, _) =>
+ {
+ var closingRequest = CloseDevicesDiscoveryServerRequest;
+
+ --erroredInterfacesIndexesTTL;
+
+ if (erroredInterfacesIndexesTTL <= 0)
+ {
+ erroredInterfacesIndexesTTL = 60;
+ erroredInterfacesIndexes.Clear();
+ }
+
+ UpdateDefaultDeviceInfo();
+
+ if (closingRequest)
+ DefaultDeviceInfo.SendTime -= TimeSpan.FromSeconds(20);
+
+ var sendText = JsonSerializer.Serialize(DefaultDeviceInfo);
+ var sendBytes = System.Text.Encoding.UTF8.GetBytes(sendText);
+
+ foreach (var item in _supportedNetworkInterfacesIndexes)
+ {
+ if (erroredInterfacesIndexes.Contains(item))
+ continue;
+
+ try
+ {
+ _udpSender?.Client.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, item);
+ _udpSender?.Send(sendBytes, sendBytes.Length, multicast);
+
+ while (Messages2BroadCast.Count > 0)
+ {
+ var messageBytes = System.Text.Encoding.UTF8.GetBytes(Messages2BroadCast.Dequeue());
+ _udpSender?.Send(messageBytes, messageBytes.Length, multicast);
+ }
+ }
+ catch (Exception ex)
+ {
+ if (!erroredInterfacesIndexes.Contains(item))
+ erroredInterfacesIndexes.Add(item);
+
+ Log.Warning(ex, $"In {location}: Errored interface index: {item}, recorded.");
+ }
+ }
+
+ if (closingRequest)
+ {
+ _udpSendTimer?.Stop();
+ _udpSendTimer?.Close();
+ _udpSender?.Close();
+ _udpReceiver?.Close();
+ CloseDevicesDiscoveryServerRequest = false;
+ }
+ };
+
+ _udpSendTimer.Start();
+ }
+
+ private void MultiDevicesBroadCastReceive()
+ {
+ const string location = $"{nameof(DevicesDiscoveryServer)}.{nameof(MultiDevicesBroadCastReceive)}";
+
+ var multicast = new IPEndPoint(IPAddress.Any, 0);
+
+ _udpReceiver?.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+
+ var thread = new Thread(async () =>
+ {
+ try
+ {
+ while (!CloseDevicesDiscoveryServerRequest)
+ {
+ var bytes = _udpReceiver?.Receive(ref multicast);
+ var client = $"{multicast.Address}:{multicast.Port}";
+
+ if (bytes is null)
+ continue;
+
+ var result = System.Text.Encoding.UTF8.GetString(bytes);
+
+ Log.Verbose($"UDP From: {client, -21}, Receive: {result}");
+
+ try
+ {
+ var info = JsonSerializer.Deserialize(result);
+
+ if (info is not null)
+ {
+ DeviceDiscovered?.Invoke(this, new DeviceDiscoveredEventArgs
+ {
+ DeviceInfo = info
+ });
+ }
+ }
+ catch (Exception ex)
+ {
+ Log.Warning(ex, $"When trying to deserialize `{result}`");
+ }
+ }
+
+ SetPending();
+ }
+ catch (Exception e)
+ {
+ Log.Error(e, $"In {location}: {e.Message}");
+ SetErrored(e, nameof(DevicesDiscoveryServer));
+ }
+
+ await CTask.Run(() => Stop());
+ });
+
+ thread.Start();
+ }
+
+ ///
+ /// Disposes the server
+ ///
+ public void Dispose()
+ {
+ if (_disposed)
+ return;
+
+ _disposed = true;
+
+ CloseDevicesDiscoveryServerRequest = false;
+
+ _udpSender?.Dispose();
+ _udpReceiver?.Dispose();
+
+ GC.Collect();
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DevicesOrganizer.cs b/KitX Clients/KitX Core/KitX.Core/Device/DevicesOrganizer.cs
new file mode 100644
index 00000000..92cda411
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DevicesOrganizer.cs
@@ -0,0 +1,383 @@
+using System.Text;
+using KitX.Core.Contract.Configuration;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.Event;
+using KitX.Core.Contract.Security;
+using KitX.Shared.CSharp.Device;
+using Serilog;
+using Timer = System.Timers.Timer;
+
+namespace KitX.Core.Device;
+
+///
+/// Devices organizer for managing discovered devices
+/// Phase 6.5: Aligned with legacy DevicesOrganizer functionality
+///
+public class DevicesOrganizer : IDevicesOrganizer, IDisposable
+{
+ private readonly IConfigService _configService;
+ private readonly IEventService _eventService;
+ private readonly IDeviceDiscoveryService _deviceDiscoveryService;
+ private readonly IDeviceKeyService _deviceKeyService;
+ private readonly object _receivedDeviceInfo4WatchLock = new();
+
+ // C-10: concurrent queue — the UDP receive path (DeviceDiscovered handler)
+ // enqueues while the timer path dequeues, previously unsynchronized.
+ private readonly System.Collections.Concurrent.ConcurrentQueue _deviceInfosQueue = new();
+ private bool _keepCheckAndRemoveTaskRunning = false;
+ private List? _receivedDeviceInfo4Watch;
+
+ // C-10: guards that at most one main-device observation thread is alive
+ // (the old recursive restart leaked a new thread per failure).
+ private int _observingMainDevice;
+
+ private System.Timers.Timer? _keepCheckAndRemoveTimer;
+
+ ///
+ /// Max queued device infos before dropping the oldest one
+ ///
+ private const int MaxQueuedDeviceInfos = 1024;
+
+ ///
+ /// Event raised when a device is discovered
+ ///
+ public event EventHandler? DeviceDiscovered;
+
+ ///
+ /// Event raised when a device goes offline
+ ///
+ public event EventHandler? DeviceOffline;
+
+ ///
+ /// Creates a new devices organizer with dependency injection
+ ///
+ public DevicesOrganizer(IConfigService configService, IEventService eventService, IDeviceDiscoveryService deviceDiscoveryService, IDeviceKeyService deviceKeyService)
+ {
+ _configService = configService ?? throw new ArgumentNullException(nameof(configService));
+ _eventService = eventService ?? throw new ArgumentNullException(nameof(eventService));
+ _deviceDiscoveryService = deviceDiscoveryService ?? throw new ArgumentNullException(nameof(deviceDiscoveryService));
+ _deviceKeyService = deviceKeyService ?? throw new ArgumentNullException(nameof(deviceKeyService));
+ Initialize();
+ }
+
+ ///
+ /// Initializes the devices organizer
+ ///
+ private void Initialize()
+ {
+ InitEvents();
+
+ KeepCheckAndRemove();
+
+ ObserveMainDevice();
+ }
+
+ ///
+ /// Initializes event subscriptions
+ ///
+ private void InitEvents()
+ {
+ // Subscribe to device discovery events from DevicesDiscoveryServer
+ _deviceDiscoveryService.DeviceDiscovered += (_, args) =>
+ {
+ if (args.DeviceInfo is null) return;
+
+ // Bounded queue: drop the oldest entries if the queue grows too large
+ while (_deviceInfosQueue.Count >= MaxQueuedDeviceInfos)
+ {
+ if (!_deviceInfosQueue.TryDequeue(out DeviceInfo _))
+ break;
+ }
+
+ _deviceInfosQueue.Enqueue(args.DeviceInfo);
+
+ lock (_receivedDeviceInfo4WatchLock)
+ {
+ _receivedDeviceInfo4Watch?.Add(args.DeviceInfo);
+ }
+
+ // Check for main device changes
+ if (args.DeviceInfo.IsMainDevice && args.DeviceInfo.DevicesServerBuildTime < ConstantTable.ServerBuildTime)
+ {
+ // Only authorized devices may claim the main device role.
+ // A forged IsMainDevice broadcast from an unauthorized device
+ // must not make this machine yield its main device identity.
+ if (!_deviceKeyService.IsDeviceAuthorized(args.DeviceInfo.Device))
+ {
+ Log.Debug(
+ $"In {nameof(DevicesOrganizer)}.{nameof(InitEvents)}: " +
+ $"Ignoring main device claim from unauthorized device {args.DeviceInfo.Device.IPv4}:{args.DeviceInfo.DevicesServerPort}."
+ );
+ }
+ else
+ {
+ ConstantTable.IsMainMachine = false;
+
+ ObserveMainDevice();
+
+ Log.Information(
+ new StringBuilder()
+ .AppendLine("Watched earlier built server.")
+ .AppendLine($"DevicesServerAddress: {args.DeviceInfo.Device.IPv4}:{args.DeviceInfo.DevicesServerPort}")
+ .AppendLine($"DevicesServerBuildTime: {args.DeviceInfo.DevicesServerBuildTime}")
+ .ToString()
+ );
+ }
+ }
+ };
+ }
+
+ ///
+ /// Keeps checking and removing offline devices
+ ///
+ private void KeepCheckAndRemove()
+ {
+ const string location = $"{nameof(DevicesOrganizer)}.{nameof(KeepCheckAndRemove)}";
+
+ var timer = new Timer
+ {
+ Interval = _configService.AppConfig.Web.DevicesViewRefreshDelay,
+ AutoReset = true
+ };
+
+ _keepCheckAndRemoveTimer = timer;
+
+ timer.Elapsed += (_, _) =>
+ {
+ try
+ {
+ if (_keepCheckAndRemoveTaskRunning)
+ {
+ Log.Information($"In {location}: Timer elapsed and skip task.");
+ }
+ else
+ {
+ _keepCheckAndRemoveTaskRunning = true;
+
+ UpdateSourceAndAddCards();
+
+ if (_configService.AppConfig.Web.DisableRemovingOfflineDeviceCard == false)
+ RemoveOfflineCards();
+
+ // TODO: Implement MoveSelfCardToFirst if needed
+
+ _keepCheckAndRemoveTaskRunning = false;
+ }
+ }
+ catch (Exception ex)
+ {
+ Log.Error(ex, $"In {location}: {ex.Message}");
+ }
+ };
+
+ timer.Start();
+
+ // Subscribe to config changes via IEventService
+ _eventService.Subscribe(EventNames.AppConfigChanged, (s, e) =>
+ {
+ timer.Interval = _configService.AppConfig.Web.DevicesViewRefreshDelay;
+ });
+ }
+
+ ///
+ /// Updates source and adds cards from queue
+ ///
+ private void UpdateSourceAndAddCards()
+ {
+ var thisTurnAdded = new List();
+
+ while (_deviceInfosQueue.TryDequeue(out var info))
+ {
+ var hashCode = info.GetHashCode();
+
+ if (thisTurnAdded.Contains(hashCode))
+ continue;
+
+ // Trigger event for UI layer to handle deduplication
+ DeviceDiscovered?.Invoke(this, new DeviceDiscoveredEventArgs
+ {
+ DeviceInfo = info
+ });
+
+ thisTurnAdded.Add(hashCode);
+ }
+ }
+
+ ///
+ /// Removes offline device cards
+ ///
+ private void RemoveOfflineCards()
+ {
+ // Trigger offline events for devices that haven't been seen recently
+ if (_receivedDeviceInfo4Watch is null) return;
+
+ var ttl = TimeSpan.FromSeconds(_configService.AppConfig.Web.DeviceInfoTTLSeconds);
+ var now = DateTime.UtcNow;
+
+ foreach (var device in _receivedDeviceInfo4Watch)
+ {
+ if (now - device.SendTime.ToUniversalTime() > ttl)
+ {
+ DeviceOffline?.Invoke(this, new DeviceOfflineEventArgs
+ {
+ DeviceId = device.GetHashCode().ToString()
+ });
+ }
+ }
+ }
+
+ ///
+ /// Observes main device in the network
+ ///
+ /// Cancellation token
+ internal void ObserveMainDevice(CancellationToken token = default)
+ {
+ const string location = $"{nameof(DevicesOrganizer)}.{nameof(ObserveMainDevice)}";
+
+ // C-10: only one observation thread at a time. The old implementation restarted
+ // itself recursively on failure (leaking a thread per failure) and could be invoked
+ // again from the DeviceDiscovered handler while an earlier pass was still running,
+ // letting two threads fight over _receivedDeviceInfo4Watch.
+ if (Interlocked.CompareExchange(ref _observingMainDevice, 1, 0) != 0)
+ return;
+
+ new Thread(() =>
+ {
+ try
+ {
+ // C-10: retry loop replaces the recursive restart — on failure, wait and
+ // retry on this same thread instead of spawning a new one.
+ while (!token.IsCancellationRequested)
+ {
+ _receivedDeviceInfo4Watch = [];
+
+ var checkedTime = 0;
+ var hadMainDevice = false;
+ var earliestBuiltServerTime = DateTime.UtcNow;
+ var serverPort = 0;
+ var serverAddress = string.Empty;
+
+ try
+ {
+ while (checkedTime < 7 && token.IsCancellationRequested == false)
+ {
+ if (_receivedDeviceInfo4Watch is null)
+ continue;
+
+ lock (_receivedDeviceInfo4WatchLock)
+ {
+ foreach (var item in _receivedDeviceInfo4Watch)
+ {
+ // Only authorized devices may participate in the main device decision.
+ // Forged IsMainDevice broadcasts from unauthorized devices must not
+ // contribute to hadMainDevice / earliestBuiltServerTime, and must not
+ // redirect MainMachineAddress / MainMachinePort.
+ if (!_deviceKeyService.IsDeviceAuthorized(item.Device))
+ {
+ if (item.IsMainDevice)
+ {
+ Log.Debug(
+ $"In {location}: Ignoring main device claim from unauthorized device " +
+ $"{item.Device.IPv4}:{item.DevicesServerPort}."
+ );
+ }
+
+ continue;
+ }
+
+ if (item.IsMainDevice)
+ {
+ if (item.DevicesServerBuildTime.ToUniversalTime() < earliestBuiltServerTime)
+ {
+ serverPort = item.DevicesServerPort;
+ serverAddress = item.Device.IPv4;
+ }
+ hadMainDevice = true;
+ }
+ }
+ }
+
+ ++checkedTime;
+
+ Log.Information($"In {location}: Watched for {checkedTime} times.");
+
+ if (checkedTime == 7)
+ {
+ _receivedDeviceInfo4Watch?.Clear();
+ _receivedDeviceInfo4Watch = null;
+
+ if (token.IsCancellationRequested == false)
+ WatchingOver(hadMainDevice, serverAddress, serverPort);
+ }
+
+ // Dedicated observation thread — a blocking sleep is intentional
+ // (C-10: keep, converting to Task.Delay would require async plumbing
+ // for no benefit on this long-lived thread).
+ Thread.Sleep(1 * 1000); // Sleep 1 second
+ }
+
+ // C-10: observation pass completed — fall through and start the
+ // next 7-second pass (the outer while is the retry/continuous loop;
+ // an early `break` here would exit it and kill the observer).
+ }
+ catch (Exception e)
+ {
+ _receivedDeviceInfo4Watch?.Clear();
+ _receivedDeviceInfo4Watch = null;
+
+ Log.Error(e, $"In {location}: {e.Message} Rewatch.");
+
+ // Retry on this thread after a brief pause (was: recursive ObserveMainDevice()).
+ Thread.Sleep(1 * 1000);
+ }
+ }
+ }
+ finally
+ {
+ Interlocked.Exchange(ref _observingMainDevice, 0);
+ }
+ }).Start();
+ }
+
+ ///
+ /// Called when main device observation is complete
+ ///
+ private void WatchingOver(bool foundMainDevice, string serverAddress, int serverPort)
+ {
+ const string location = $"{nameof(DevicesOrganizer)}.{nameof(WatchingOver)}";
+
+ Log.Information(
+ new StringBuilder()
+ .Append($"In {location}: ")
+ .Append($"{nameof(foundMainDevice)} -> {foundMainDevice}")
+ .Append(", ")
+ .Append($"{nameof(serverAddress)} -> {serverAddress}")
+ .Append(", ")
+ .Append($"{nameof(serverPort)} -> {serverPort}")
+ .ToString()
+ );
+
+ if (foundMainDevice)
+ {
+ ConstantTable.MainMachineAddress = serverAddress;
+ ConstantTable.MainMachinePort = serverPort;
+ }
+ else
+ {
+ ConstantTable.IsMainMachine = true;
+ }
+ }
+
+ ///
+ /// C-10: releases the resident check-and-remove timer. Registered as a singleton in DI;
+ /// the container disposes it on shutdown. (The main-device observation thread is
+ /// short-lived and needs no disposal.)
+ ///
+ public void Dispose()
+ {
+ _keepCheckAndRemoveTimer?.Stop();
+ _keepCheckAndRemoveTimer?.Dispose();
+ _keepCheckAndRemoveTimer = null;
+ GC.SuppressFinalize(this);
+ }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core/Device/DevicesServer.cs b/KitX Clients/KitX Core/KitX.Core/Device/DevicesServer.cs
new file mode 100644
index 00000000..ba0cb2bd
--- /dev/null
+++ b/KitX Clients/KitX Core/KitX.Core/Device/DevicesServer.cs
@@ -0,0 +1,1134 @@
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using KitX.Core.Contract.Device;
+using KitX.Core.Contract.Event;
+using KitX.Core.Contract.Plugin;
+using KitX.Core.Contract.Plugin.Events;
+using KitX.Core.Contract.Security;
+using KitX.Shared.CSharp.Device;
+using KitX.Shared.CSharp.Security;
+using KitX.Shared.CSharp.WebCommand;
+using KitX.Shared.CSharp.WebCommand.Infos;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Hosting.Server.Features;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+
+namespace KitX.Core.Device;
+
+///
+/// Device server for HTTP API
+/// Phase 5: Simplified implementation using direct WebHostBuilder
+///
+public class DevicesServer : ServerBase, IDeviceServer
+{
+ private readonly IEncryptionService _encryptionService;
+ private readonly IDeviceKeyService _deviceKeyService;
+ private readonly IEventService _eventService;
+ private readonly IPluginServer _pluginServer;
+ private readonly IDeviceDiscoveryService _deviceDiscoveryService;
+
+ private readonly ConcurrentDictionary _signedDeviceTokens = new();
+
+ ///
+ /// Reverse index token → device locator, so token lookups are O(1) and atomic.
+ /// Kept in sync with under .
+ ///
+ private readonly ConcurrentDictionary _tokenToLocator = new();
+
+ ///
+ /// Serializes multi-entry updates of the token maps (AddDeviceToken / SignInDevice).
+ ///
+ private readonly object _signedDeviceTokensLock = new();
+ private IWebHost? _host;
+ private int? _configuredPort;
+
+ ///
+ /// Whether device key exchange is in progress
+ ///
+ private bool _isExchangingDeviceKey = false;
+
+ ///
+ /// Password entered by the user on this device, read from the initiating device's screen.
+ /// Used to decrypt the exchanged device key payload. The correctness of the password is
+ /// verified by the decrypt attempt itself (per the encryption-ring spec), so no separate
+ /// verification code is needed.
+ ///
+ private string? _exchangeKeyPassword;
+
+ ///
+ /// TaskCompletionSource for awaiting user confirmation on key exchange
+ ///
+ private TaskCompletionSource? _exchangeKeyTcs;
+
+ ///