fix(mcp): share app dependencies with stdio

Author: hubab1

OpenASO/App/AppServices.swift

@@ -40,6 +40,7 @@ final class AppServices {
     let refreshCoordinator: RankingRefreshCoordinator
     let appDetailRefreshService: AppDetailRefreshService?
     let refreshProgressStore: AppRefreshProgressStore
+    let mcpServerProvider: OpenASOMCPServerProvider
     let mcpServerController: OpenASOMCPServerController
     let keywordResearchProjectStore: KeywordResearchProjectStore?
     let keywordResearchProjectCopyService: KeywordResearchProjectCopyService?
@@ -383,9 +384,7 @@ final class AppServices {
         self.keywordResearchProjectCopyService = keywordResearchProjectCopyService
         self.keywordResearchRankingWorkflow = keywordResearchRankingWorkflow
         self.keywordResearchMetricsWorkflow = keywordResearchMetricsWorkflow
-        self.mcpServerController = OpenASOMCPServerController(portProvider: {
-            settingsStore.mcpServerPort
-        }) {
+        let mcpServerProvider = OpenASOMCPServerProvider {
             guard let backgroundModelStore, let keywordResearchProjectStore else {
                 throw OpenASOError.providerUnavailable("OpenASO MCP needs an initialized workspace store.")
             }
@@ -417,6 +416,12 @@ final class AppServices {
                 configuration: OpenASOMCPServerConfiguration(version: "1.5.0")
             ).makeServer()
         }
+        self.mcpServerProvider = mcpServerProvider
+        self.mcpServerController = OpenASOMCPServerController(portProvider: {
+            settingsStore.mcpServerPort
+        }) {
+            try await mcpServerProvider.makeServer()
+        }
         self.backgroundModelStore = backgroundModelStore
         self.backgroundModelStoreRevision = backgroundModelStore == nil ? 0 : 1
         if let headlessRefreshService {

OpenASO/App/OpenASOApp.swift

@@ -10,11 +10,17 @@ struct OpenASOApp: App {
     private let startupState: OpenASOStartupState
 
     init() {
+        let startupState = Self.makeStartupState()
         if Self.shouldRunMCPStdio {
-            Self.runMCPStdioAndExit()
+            switch startupState {
+            case .ready(_, let services):
+                Self.runMCPStdioAndExit(serverProvider: services.mcpServerProvider)
+            case .storeUnavailable(let error):
+                Self.exitMCPStdio(with: error.diagnosticReport)
+            }
         }
 
-        startupState = Self.makeStartupState()
+        self.startupState = startupState
         _launchAlert = State(initialValue: nil)
     }
 
@@ -36,13 +42,13 @@ struct OpenASOApp: App {
         ProcessInfo.processInfo.arguments.contains("--mcp-stdio")
     }
 
-    private static func runMCPStdioAndExit() -> Never {
+    private static func runMCPStdioAndExit(
+        serverProvider: OpenASOMCPServerProvider
+    ) -> Never {
         Task.detached {
             let exitCode: Int32
             do {
-                try await OpenASOMCPRuntime.runStdio(
-                    configuration: OpenASOMCPServerConfiguration(version: "1.5.0")
-                )
+                try await OpenASOMCPRuntime.runStdio(serverProvider: serverProvider)
                 exitCode = 0
             } catch {
                 let description = (error as? PersistentStoreError)?.diagnosticReport
@@ -56,6 +62,11 @@ struct OpenASOApp: App {
         dispatchMain()
     }
 
+    private static func exitMCPStdio(with diagnostic: String) -> Never {
+        FileHandle.standardError.write(Data("OpenASO MCP server failed: \(diagnostic)\n".utf8))
+        Foundation.exit(1)
+    }
+
     var body: some Scene {
         WindowGroup("OpenASO") {
             switch startupState {

OpenASO/Features/Settings/SettingsView.swift

@@ -194,7 +194,7 @@ struct SettingsView: View {
         } header: {
             Text("MCP Server")
         } footer: {
-            Text("Starts a local loopback MCP HTTP server for agents that can connect to an already-running app. Stop the server before changing the port. Stdio MCP clients should still launch the OpenASOMCP command-line target directly.")
+            Text("Starts a local loopback MCP HTTP server for agents that can connect to an already-running app. Stop the server before changing the port. Stdio MCP clients should launch the OpenASO app executable with --mcp-stdio; both transports use the same workspace and configured providers.")
         }
     }
 

OpenASO/Services/MCP/OpenASOMCPRuntime.swift

@@ -2,7 +2,55 @@ import Foundation
 import MCP
 import SwiftData
 
+struct OpenASOMCPServerProvider: Sendable {
+    private let makeServerImplementation: @MainActor @Sendable () async throws -> Server
+
+    init(
+        makeServer: @escaping @MainActor @Sendable () async throws -> Server
+    ) {
+        self.makeServerImplementation = makeServer
+    }
+
+    @MainActor
+    func makeServer() async throws -> Server {
+        try await makeServerImplementation()
+    }
+}
+
 enum OpenASOMCPRuntime {
+    static func run(
+        serverProvider: OpenASOMCPServerProvider,
+        transport: any Transport
+    ) async throws {
+        let server = try await serverProvider.makeServer()
+        do {
+            try await server.start(transport: transport)
+            await withTaskCancellationHandler {
+                await server.waitUntilCompleted()
+            } onCancel: {
+                Task {
+                    await server.stop()
+                }
+            }
+            await server.stop()
+            try Task.checkCancellation()
+        } catch {
+            await server.stop()
+            throw error
+        }
+    }
+
+    static func runStdio(
+        serverProvider: OpenASOMCPServerProvider
+    ) async throws {
+        try await run(
+            serverProvider: serverProvider,
+            transport: StdioTransport()
+        )
+    }
+
+    // Retained for the dormant standalone target. The shipped app's --mcp-stdio
+    // path supplies AppServices.mcpServerProvider so HTTP and stdio share dependencies.
     static func makeServer(
         configuration: OpenASOMCPServerConfiguration = OpenASOMCPServerConfiguration()
     ) async throws -> Server {
@@ -62,9 +110,9 @@ enum OpenASOMCPRuntime {
     static func runStdio(
         configuration: OpenASOMCPServerConfiguration = OpenASOMCPServerConfiguration()
     ) async throws {
-        let server = try await makeServer(configuration: configuration)
-        let transport = StdioTransport()
-        try await server.start(transport: transport)
-        await server.waitUntilCompleted()
+        let serverProvider = OpenASOMCPServerProvider {
+            try await makeServer(configuration: configuration)
+        }
+        try await runStdio(serverProvider: serverProvider)
     }
 }