diff --git a/packages/core/src/mcp/index.ts b/packages/core/src/mcp/index.ts index 4d548c49a8f..c823223c221 100644 --- a/packages/core/src/mcp/index.ts +++ b/packages/core/src/mcp/index.ts @@ -678,7 +678,13 @@ export const layer = (options?: Options) => yield* bus.publish(McpEvent.StatusChanged, { server: name }) continue } - fork(startServer(name, entry).pipe(locks.withLock(name))) + fork( + Effect.gen(function* () { + // connect() or disconnect() may have settled the server while this startup waited to run. + if (entry.status.status !== "pending") return yield* entry.startup.open + yield* startServer(name, entry) + }).pipe(locks.withLock(name)), + ) } return } diff --git a/packages/core/test/mcp.test.ts b/packages/core/test/mcp.test.ts index 9b0cb2dff9c..70ad0cd9a33 100644 --- a/packages/core/test/mcp.test.ts +++ b/packages/core/test/mcp.test.ts @@ -2099,6 +2099,53 @@ shutdownIt.effect("discards in-flight and queued MCP notifications after its lay }), ) +describe.each(["connect", "disconnect"] as const)("%s during initial MCP startup", (operation) => { + shutdownIt.live("is not undone by the queued startup", () => + Effect.gen(function* () { + const bus = yield* Bus.Service + const server = yield* resourceServer() + const entered = yield* Deferred.make() + const release = yield* Deferred.make() + const root = yield* Scope.make() + yield* Effect.addFinalizer(() => + Deferred.succeed(release, undefined).pipe(Effect.andThen(State.shutdown(Scope.close(root, Exit.void)))), + ) + const service = Context.get(yield* Layer.buildWithScope(Mcp.layer(), root), Mcp.Service) + // Pausing the disabled server's status event holds initial reconciliation after every entry exists + // but before the enabled server's startup is scheduled. + yield* Effect.acquireRelease( + bus.listen((event) => + Effect.gen(function* () { + if (event.type !== McpEvent.StatusChanged.type) return + if (Schema.decodeUnknownSync(McpEvent.StatusChanged.data)(event.data).server !== "gate") return + yield* Deferred.succeed(entered, undefined) + yield* Deferred.await(release) + }), + ), + (unsubscribe) => unsubscribe, + ) + const reconciling = yield* service + .transform((editor) => { + editor.set("gate", { type: "local", command: ["unused"], disabled: true }) + editor.set("resources", { type: "remote", url: server.url, oauth: false }) + }) + .pipe(Scope.provide(root), Effect.forkChild({ startImmediately: true })) + yield* Deferred.await(entered) + + yield* service[operation]("resources") + yield* Deferred.succeed(release, undefined) + yield* Fiber.join(reconciling) + // The queued startup already holds or awaits the server lock, so this waits for it to finish. + yield* service.disconnect("resources") + + expect(server.state.initializations).toBe(operation === "connect" ? 1 : 0) + expect((yield* service.servers()).find((item) => item.name === "resources")?.status).toEqual({ + status: "disabled", + }) + }), + ) +}) + test("serializes concurrent MCP lifecycle operations", async () => { await Effect.runPromise( Effect.scoped(