feat: add host infrastructure service implementations and DI wiring

sharpninja · Copilot · sharpninja · commit 6feeeab972cf · 2026-03-05T12:10:57.000-06:00
P1.6: Create 5 host-side implementations in Services/Infrastructure/:
- FileSystemService wraps System.IO.File/Directory
- ProcessLauncherService wraps Process.Start
- TimerService wraps System.Threading.Timer
- JsonParsingService wraps System.Text.Json
- FileSystemWatcherService wraps FileSystemWatcher

P1.7: Register all 5 in UiCoreServiceProviderFactory with defaults.
Update UiCoreAppRuntime to forward infrastructure params.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/src/McpServerManager.Core/Services/Infrastructure/FileSystemService.cs b/src/McpServerManager.Core/Services/Infrastructure/FileSystemService.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using McpServer.UI.Core.Services;
+
+namespace McpServerManager.Core.Services.Infrastructure;
+
+/// <summary>
+/// Host implementation of <see cref="IFileSystemService"/> backed by <see cref="System.IO"/>.
+/// </summary>
+public sealed class FileSystemService : IFileSystemService
+{
+    public bool FileExists(string path) => File.Exists(path);
+
+    public bool DirectoryExists(string path) => Directory.Exists(path);
+
+    public string ReadAllText(string path) => File.ReadAllText(path);
+
+    public Task<string> ReadAllTextAsync(string path, CancellationToken ct = default)
+        => File.ReadAllTextAsync(path, ct);
+
+    public string[] ReadAllLines(string path) => File.ReadAllLines(path);
+
+    public void WriteAllText(string path, string content) => File.WriteAllText(path, content);
+
+    public Task WriteAllTextAsync(string path, string content, CancellationToken ct = default)
+        => File.WriteAllTextAsync(path, content, ct);
+
+    public void MoveFile(string source, string destination) => File.Move(source, destination);
+
+    public void DeleteFile(string path) => File.Delete(path);
+
+    public DateTime GetLastWriteTimeUtc(string path) => File.GetLastWriteTimeUtc(path);
+
+    public IEnumerable<FileEntry> EnumerateFiles(string directory, string searchPattern, bool recursive)
+    {
+        var option = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+        return new DirectoryInfo(directory)
+            .EnumerateFiles(searchPattern, option)
+            .Select(fi => new FileEntry(fi.FullName, fi.Name, fi.Extension, false));
+    }
+
+    public IEnumerable<DirectoryEntry> EnumerateDirectories(string directory, string searchPattern, bool recursive)
+    {
+        var option = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+        return new DirectoryInfo(directory)
+            .EnumerateDirectories(searchPattern, option)
+            .Select(di => new DirectoryEntry(di.FullName, di.Name));
+    }
+
+    public string GetFullPath(string path) => Path.GetFullPath(path);
+
+    public string? GetDirectoryName(string path) => Path.GetDirectoryName(path);
+
+    public string CombinePath(params string[] paths) => Path.Combine(paths);
+}
diff --git a/src/McpServerManager.Core/Services/Infrastructure/FileSystemWatcherService.cs b/src/McpServerManager.Core/Services/Infrastructure/FileSystemWatcherService.cs
@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+using McpServer.UI.Core.Services;
+
+namespace McpServerManager.Core.Services.Infrastructure;
+
+/// <summary>
+/// Host implementation of <see cref="IFileSystemWatcherService"/> backed by <see cref="FileSystemWatcher"/>.
+/// </summary>
+public sealed class FileSystemWatcherService : IFileSystemWatcherService
+{
+    public IWatcherHandle Watch(string directory, string filter, Action<string> onChanged)
+        => new WatcherHandle(directory, filter, onChanged);
+
+    private sealed class WatcherHandle : IWatcherHandle
+    {
+        private FileSystemWatcher? _watcher;
+
+        public WatcherHandle(string directory, string filter, Action<string> onChanged)
+        {
+            _watcher = new FileSystemWatcher(directory, filter)
+            {
+                NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.CreationTime,
+                EnableRaisingEvents = true
+            };
+
+            _watcher.Changed += (_, e) => onChanged(e.FullPath);
+            _watcher.Created += (_, e) => onChanged(e.FullPath);
+            _watcher.Renamed += (_, e) => onChanged(e.FullPath);
+        }
+
+        public void Stop()
+        {
+            if (_watcher is not null)
+                _watcher.EnableRaisingEvents = false;
+        }
+
+        public void Dispose()
+        {
+            _watcher?.Dispose();
+            _watcher = null;
+        }
+    }
+}
diff --git a/src/McpServerManager.Core/Services/Infrastructure/JsonParsingService.cs b/src/McpServerManager.Core/Services/Infrastructure/JsonParsingService.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using McpServer.UI.Core.Services;
+
+namespace McpServerManager.Core.Services.Infrastructure;
+
+/// <summary>
+/// Host implementation of <see cref="IJsonParsingService"/> backed by <see cref="System.Text.Json"/>.
+/// </summary>
+public sealed class JsonParsingService : IJsonParsingService
+{
+    private static readonly JsonSerializerOptions IndentedOptions = new() { WriteIndented = true };
+
+    public JsonTreeResult ParseToTree(string jsonText)
+    {
+        var node = JsonNode.Parse(jsonText);
+        int count = CountNodes(node);
+        return new JsonTreeResult(node!, count);
+    }
+
+    public string? Validate(string jsonText)
+    {
+        try
+        {
+            using var doc = JsonDocument.Parse(jsonText);
+            return null;
+        }
+        catch (JsonException ex)
+        {
+            return ex.Message;
+        }
+    }
+
+    public string PrettyPrint(string jsonText)
+    {
+        var node = JsonNode.Parse(jsonText);
+        return node?.ToJsonString(IndentedOptions) ?? jsonText;
+    }
+
+    private static int CountNodes(JsonNode? node)
+    {
+        if (node is null) return 0;
+
+        int count = 1;
+        if (node is JsonObject obj)
+        {
+            foreach (var kvp in obj)
+                count += CountNodes(kvp.Value);
+        }
+        else if (node is JsonArray arr)
+        {
+            foreach (var item in arr)
+                count += CountNodes(item);
+        }
+        return count;
+    }
+}
diff --git a/src/McpServerManager.Core/Services/Infrastructure/ProcessLauncherService.cs b/src/McpServerManager.Core/Services/Infrastructure/ProcessLauncherService.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using McpServer.UI.Core.Services;
+
+namespace McpServerManager.Core.Services.Infrastructure;
+
+/// <summary>
+/// Host implementation of <see cref="IProcessLauncherService"/> backed by <see cref="Process"/>.
+/// </summary>
+public sealed class ProcessLauncherService : IProcessLauncherService
+{
+    public void OpenWithDefaultApp(string pathOrUrl)
+    {
+        Process.Start(new ProcessStartInfo(pathOrUrl) { UseShellExecute = true });
+    }
+
+    public async Task<ProcessResult> RunAsync(
+        string fileName,
+        string arguments,
+        string? workingDirectory = null,
+        CancellationToken ct = default)
+    {
+        using var process = new Process
+        {
+            StartInfo = new ProcessStartInfo
+            {
+                FileName = fileName,
+                Arguments = arguments,
+                WorkingDirectory = workingDirectory ?? string.Empty,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
+            }
+        };
+
+        process.Start();
+
+        var stdout = await process.StandardOutput.ReadToEndAsync(ct).ConfigureAwait(false);
+        var stderr = await process.StandardError.ReadToEndAsync(ct).ConfigureAwait(false);
+        await process.WaitForExitAsync(ct).ConfigureAwait(false);
+
+        return new ProcessResult(process.ExitCode, stdout, stderr);
+    }
+
+    public void ShellExecute(string command, string arguments)
+    {
+        Process.Start(new ProcessStartInfo(command, arguments) { UseShellExecute = true });
+    }
+}
diff --git a/src/McpServerManager.Core/Services/Infrastructure/TimerService.cs b/src/McpServerManager.Core/Services/Infrastructure/TimerService.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using McpServer.UI.Core.Services;
+
+namespace McpServerManager.Core.Services.Infrastructure;
+
+/// <summary>
+/// Host implementation of <see cref="ITimerService"/> backed by <see cref="System.Threading.Timer"/>.
+/// </summary>
+public sealed class TimerService : ITimerService
+{
+    public ITimerHandle CreateRecurring(TimeSpan interval, Func<CancellationToken, Task> callback)
+        => new TimerHandle(interval, callback, recurring: true);
+
+    public ITimerHandle CreateOneShot(TimeSpan delay, Func<CancellationToken, Task> callback)
+        => new TimerHandle(delay, callback, recurring: false);
+
+    private sealed class TimerHandle : ITimerHandle
+    {
+        private Timer? _timer;
+        private CancellationTokenSource? _cts;
+        private readonly Func<CancellationToken, Task> _callback;
+        private readonly bool _recurring;
+        private TimeSpan _interval;
+
+        public TimerHandle(TimeSpan interval, Func<CancellationToken, Task> callback, bool recurring)
+        {
+            _interval = interval;
+            _callback = callback;
+            _recurring = recurring;
+            _cts = new CancellationTokenSource();
+            _timer = new Timer(OnTick, null, interval, recurring ? interval : Timeout.InfiniteTimeSpan);
+        }
+
+        private async void OnTick(object? state)
+        {
+            var cts = _cts;
+            if (cts is null || cts.IsCancellationRequested)
+                return;
+
+            try
+            {
+                await _callback(cts.Token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) { }
+        }
+
+        public void Stop()
+        {
+            _timer?.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);
+        }
+
+        public void Restart(TimeSpan? newInterval = null)
+        {
+            if (newInterval.HasValue)
+                _interval = newInterval.Value;
+
+            _timer?.Change(_interval, _recurring ? _interval : Timeout.InfiniteTimeSpan);
+        }
+
+        public void Dispose()
+        {
+            _cts?.Cancel();
+            _cts?.Dispose();
+            _cts = null;
+            _timer?.Dispose();
+            _timer = null;
+        }
+    }
+}
diff --git a/src/McpServerManager.Core/Services/UiCoreAppRuntime.cs b/src/McpServerManager.Core/Services/UiCoreAppRuntime.cs
@@ -1,4 +1,5 @@
 using System;
+using McpServer.UI.Core.Services;
 using McpServer.UI.Core.ViewModels;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -12,12 +13,20 @@ public UiCoreAppRuntime(
         McpVoiceConversationService? voiceService = null,
         McpSessionLogService? sessionLogService = null,
         McpAgentEventStreamService? eventStreamService = null,
+        IFileSystemService? fileSystemService = null,
+        IProcessLauncherService? processLauncherService = null,
+        ITimerService? timerService = null,
+        IJsonParsingService? jsonParsingService = null,
+        IFileSystemWatcherService? fileSystemWatcherService = null,
         WorkspaceContextViewModel? workspaceContext = null)
     {
         WorkspaceContext = workspaceContext ?? new WorkspaceContextViewModel();
         Services = UiCoreServiceProviderFactory.Build(
             todoService, workspaceService, voiceService,
-            sessionLogService, eventStreamService, WorkspaceContext);
+            sessionLogService, eventStreamService,
+            fileSystemService, processLauncherService,
+            timerService, jsonParsingService, fileSystemWatcherService,
+            WorkspaceContext);
     }
 
     public WorkspaceContextViewModel WorkspaceContext { get; }
diff --git a/src/McpServerManager.Core/Services/UiCoreServiceProviderFactory.cs b/src/McpServerManager.Core/Services/UiCoreServiceProviderFactory.cs
@@ -3,6 +3,7 @@
 using McpServer.UI.Core;
 using McpServer.UI.Core.Services;
 using McpServer.UI.Core.ViewModels;
+using McpServerManager.Core.Services.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace McpServerManager.Core.Services;
@@ -15,6 +16,11 @@ public static ServiceProvider Build(
         McpVoiceConversationService? voiceService = null,
         McpSessionLogService? sessionLogService = null,
         McpAgentEventStreamService? eventStreamService = null,
+        IFileSystemService? fileSystemService = null,
+        IProcessLauncherService? processLauncherService = null,
+        ITimerService? timerService = null,
+        IJsonParsingService? jsonParsingService = null,
+        IFileSystemWatcherService? fileSystemWatcherService = null,
         WorkspaceContextViewModel? workspaceContext = null)
     {
         if (todoService is null && workspaceService is null)
@@ -40,6 +46,13 @@ public static ServiceProvider Build(
         if (eventStreamService is not null)
             services.AddSingleton<IEventStreamApiClient>(_ => new UiCoreEventStreamApiClientAdapter(eventStreamService));
 
+        // Infrastructure services — use host-provided or default implementations
+        services.AddSingleton(fileSystemService ?? new FileSystemService());
+        services.AddSingleton(processLauncherService ?? new ProcessLauncherService());
+        services.AddSingleton(timerService ?? new TimerService());
+        services.AddSingleton(jsonParsingService ?? new JsonParsingService());
+        services.AddSingleton(fileSystemWatcherService ?? new FileSystemWatcherService());
+
         services.AddCqrsDispatcher();
         services.AddUiCore();
         if (workspaceContext is not null)
