@myagentroam/node 0.1.8 → 0.9.2

package/dist/capabilities.js

@@ -3,6 +3,7 @@ import nodePackage from '../package.json' with { type: 'json' };
 import { probeClaudeCode, probeClaudeCodeAsync } from './claude-agent-sdk.js';
 import { probeCodex, probeCodexAsync } from './codex-app-server.js';
 import { probeOpenCode, probeOpenCodeAsync } from './opencode-runtime.js';
+import { detectRuntimeCommands } from './runtime-command-detector.js';
 const nodeAppVersion = typeof nodePackage.version === 'string' ? nodePackage.version : 'unknown';
 function reportedPlatform() {
     return process.platform === 'win32' ? 'windows' : 'linux';
@@ -59,10 +60,11 @@ export async function detectCapabilitiesAsync(commands = {}) {
     if (process.platform !== 'win32' && process.platform !== 'linux') {
         throw new Error('NODE_PLATFORM_UNSUPPORTED');
     }
-    const [codex, claudeCode, openCode] = await Promise.all([
+    const [codex, claudeCode, openCode, runtimeCommands] = await Promise.all([
         probeCodexAsync(commands.codex),
         probeClaudeCodeAsync(commands.claudeCode),
-        probeOpenCodeAsync(commands.openCode)
+        probeOpenCodeAsync(commands.openCode),
+        detectRuntimeCommands()
     ]);
     return {
         platform: reportedPlatform(),
@@ -71,7 +73,8 @@ export async function detectCapabilitiesAsync(commands = {}) {
         nodeVersion: process.version,
         metadata: {
             osRelease: release(),
-            osVersion: version()
+            osVersion: version(),
+            runtimeCommands
         },
         codex: {
             available: codex.available && codex.compatible,

package/dist/claude-agent-sdk.d.ts

@@ -22,6 +22,7 @@ export interface ClaudeQueryInput {
     readonly onMessage: (message: SDKMessage) => void;
     readonly onChannelReply?: (content: string) => void;
     readonly environment?: Readonly<Record<string, string>>;
+    readonly mcpServers?: NonNullable<Options['mcpServers']>;
 }
 /** Image blocks accepted by the Claude Agent SDK message input. */
 export interface ClaudeImageAttachment {

package/dist/claude-agent-sdk.js

@@ -66,7 +66,14 @@ export class ClaudeAgentSdkAdapter {
                 settings: { showThinkingSummaries: true },
                 abortController,
                 canUseTool: input.onPermission,
-                ...(channelEnabled ? { mcpServers: { myagentroam: channelMcpServer(input) } } : {})
+                ...(input.mcpServers !== undefined || channelEnabled
+                    ? {
+                        mcpServers: {
+                            ...(input.mcpServers ?? {}),
+                            ...(channelEnabled ? { myagentroam: channelMcpServer(input) } : {})
+                        }
+                    }
+                    : {})
             }
         });
         const completed = consume(stream, input.onMessage);

package/dist/codex-app-server.d.ts

@@ -49,6 +49,7 @@ export interface CodexRunConfiguration {
     readonly access?: string | null;
     readonly serviceTier?: 'fast';
     readonly collaborationMode?: 'default' | 'plan';
+    readonly mcpServers?: unknown;
 }
 /** Public App Server turn inputs supported by the Workbench Composer. */
 export type CodexComposerInput = {
@@ -84,6 +85,11 @@ export declare class CodexAppServerClient {
     startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
     listThreads(): Promise<unknown>;
     listCollaborationModes(): Promise<unknown>;
+    listModels(params: {
+        readonly cursor: string | null;
+        readonly limit: number;
+        readonly includeHidden: boolean;
+    }): Promise<unknown>;
     readThread(threadId: string, includeTurns?: boolean): Promise<unknown>;
     forkThread(threadId: string, cwd: string, lastTurnId: string, configuration?: CodexRunConfiguration): Promise<unknown>;
     setThreadName(threadId: string, name: string): Promise<unknown>;

package/dist/codex-app-server.js

@@ -170,6 +170,9 @@ export class CodexAppServerClient {
     listCollaborationModes() {
         return this.request('collaborationMode/list', {});
     }
+    listModels(params) {
+        return this.request('model/list', params);
+    }
     readThread(threadId, includeTurns = true) {
         return this.request('thread/read', { threadId, includeTurns });
     }
@@ -263,6 +266,9 @@ export class CodexAppServerClient {
 function codexThreadConfiguration(cwd, configuration) {
     return {
         ...modelOption(configuration.model),
+        ...(configuration.mcpServers === undefined
+            ? {}
+            : { config: { mcp_servers: configuration.mcpServers } }),
         ...codexPermissionConfiguration(cwd, configuration.access, 'thread')
     };
 }

package/dist/connector/node-connector-options.d.ts

@@ -16,6 +16,7 @@ export interface NodeConnectorOptions {
     readonly fakeRunner?: FakeRunner;
     readonly fakeScript?: (input: unknown, runId: string) => readonly FakeRunnerStep[];
     readonly codexClient?: CodexAppServerClient;
+    readonly codexProfileClientFactory?: () => CodexAppServerClient;
     readonly claudeClient?: ClaudeAgentSdkAdapter;
     readonly openCodeClient?: OpenCodeServerClient;
     readonly database?: NodeDatabase;

package/dist/connector.d.ts

@@ -27,6 +27,7 @@ export declare class NodeConnector {
     private readonly sessionIdentityService;
     private readonly nativeSessionProjectionService;
     private readonly conversationHistoryService;
+    private readonly conversationSegmentService;
     private readonly runnerInteractionService;
     private readonly runnerChannelMessages;
     private readonly managedRunnerSessions;
@@ -78,6 +79,7 @@ export declare class NodeConnector {
     private readonly handleMessage;
     private readonly emitRunEvent;
     private readonly emitConversationItem;
+    private readonly emitConversationTurn;
     private readonly emitWorkbenchEvent;
     private readonly discoverWorkspaceSessions;
     private readonly invalidateWorkspaceWatchTopics;

package/dist/connector.js

@@ -19,6 +19,7 @@ import { OpenCodeRunner } from './runner/opencode-runner.js';
 import { OpenCodeManagedRunController } from './runner/opencode/managed-run-controller.js';
 import { NodeOperationRouter } from './connector/node-operation-router.js';
 import { SkillNodeOperationService } from './service/skill-node-operation-service.js';
+import { McpNodeOperationService } from './service/mcp-node-operation-service.js';
 import { RunnerService } from './service/runner-service.js';
 import { TerminalService } from './service/terminal-service.js';
 import { WorkspaceService } from './service/workspace-service.js';
@@ -43,6 +44,7 @@ import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbe
 import { SessionIdentityService } from './service/session-identity-service.js';
 import { NativeSessionProjectionService } from './service/native-session-projection-service.js';
 import { ConversationHistoryService, hasManagedActiveRun } from './service/conversation-history-service.js';
+import { ConversationSegmentService, conversationSegmentIdentityForItem, conversationSegments } from './service/conversation-segment-service.js';
 import { RunnerInteractionService } from './service/runner-interaction-service.js';
 import { SessionLifecycleService } from './service/session-lifecycle-service.js';
 import { ExternalSessionResumeService } from './service/external-session-resume-service.js';
@@ -50,7 +52,7 @@ import { SessionMessageService } from './service/session-message-service.js';
 import { SessionCatalogService } from './service/session-catalog-service.js';
 import { SessionCommandService } from './service/session-command-service.js';
 import { SessionPresentationService } from './service/session-presentation-service.js';
-import { isRunnerImageAttachment, parseRunnerImageAttachments } from './runner/codex/conversation-parser.js';
+import { isPlainRecord, isRunnerImageAttachment, parseRunnerImageAttachments } from './runner/codex/conversation-parser.js';
 export { nodeConnectEndpoint, validatedCapabilities } from './runner/codex/conversation-parser.js';
 import { NodeControlChannel } from './service/node-control-channel.js';
 import { NodeControlMessageService } from './service/node-control-message-service.js';
@@ -113,6 +115,7 @@ export class NodeConnector {
     sessionIdentityService;
     nativeSessionProjectionService;
     conversationHistoryService;
+    conversationSegmentService;
     runnerInteractionService;
     runnerChannelMessages;
     managedRunnerSessions;
@@ -172,7 +175,12 @@ export class NodeConnector {
         isBootstrapSession: (sessionId) => this.sessionIdentityService.bootstrapIds.has(sessionId),
         presentSession: (session) => this.sessionPresentationService.present(session),
         rejectBootstrap: (sessionId, code) => this.sessionIdentityService.reject(sessionId, code),
-        emitWorkbench: (category, payload) => this.emitWorkbenchEvent(category, payload),
+        emitWorkbench: (category, payload) => {
+            if (category === 'conversation' && isPlainRecord(payload) && 'turn' in payload)
+                this.emitConversationTurn(payload.turn);
+            else
+                this.emitWorkbenchEvent(category, payload);
+        },
         cleanupAttachments: (runId) => this.runAttachmentService.cleanup(runId),
         expireImages: (runId) => this.runAttachmentService.expire(runId),
         scheduleContextRefresh: (sessionId) => this.sessionContextService.schedule(sessionId),
@@ -189,8 +197,9 @@ export class NodeConnector {
         refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
         present: (session) => this.sessionPresentationService.present(session),
         readPage: (session, limit) => this.conversationHistoryService.read(session, { limit }),
+        projectInitialPage: (session, page, _unit, limit) => this.conversationSegmentService.projectInitial(session, page, limit),
         emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
-        emitTurn: (turn) => this.emitWorkbenchEvent('conversation', { turn })
+        emitTurn: (turn) => this.emitConversationTurn(turn)
     });
     constructor(options = {}) {
         this.config = options.config;
@@ -229,8 +238,8 @@ export class NodeConnector {
         this.fakeRunner =
             options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
         this.fakeScript = options.fakeScript;
-        this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoot(session));
-        this.codexClient = new CodexRunner(options.codexClient);
+        this.runAttachmentService = new RunAttachmentService((session) => this.runners.require(session.runner).nativeImageRoots(session));
+        this.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
             intercepted: () => this.fakeRunner !== undefined,
@@ -251,7 +260,7 @@ export class NodeConnector {
             cancel: (runId, threadId, turnId, cwd, status) => this.runnerInteractionService.cancelCodexTurn(runId, threadId, turnId, cwd, status),
             createApproval: (input) => this.runtime.createApproval(input),
             publishApproval: (input) => this.runEventBridge.publishApproval(input),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             appendImages: (runId, images) => this.runAttachmentService.append(runId, images.filter(isRunnerImageAttachment)),
             captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
@@ -272,8 +281,9 @@ export class NodeConnector {
             intercepted: () => this.fakeRunner !== undefined,
             active: this.runState.active,
             parseAttachments: parseRunnerImageAttachments,
+            persistAttachments: (cwd, runId, attachments) => this.runAttachmentService.persistFiles(cwd, `${runId}-opencode-images`, attachments),
             emit: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             adopt: (input) => this.runtime.adoptRun(input),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
@@ -305,7 +315,7 @@ export class NodeConnector {
             rememberNative: (nativeSessionId, sessionId) => this.managedRunnerSessions.remember(nativeSessionId, sessionId),
             promote: (sessionId, nativeSessionId) => this.sessionIdentityService.promote(sessionId, nativeSessionId),
             send: (type, payload) => this.send(type, payload),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             syncTitle: (sessionId, nativeSessionId, cwd) => this.managedRunnerSessions.refreshTitle(sessionId, nativeSessionId, cwd),
             setChannelToken: (sessionId, token) => this.runtime.setChannelToken(sessionId, token),
             commandState: (sessionId, commandId) => this.commandStates.get(sessionId, commandId),
@@ -329,7 +339,7 @@ export class NodeConnector {
             claude: () => this.claudeClient,
             runners: this.runners,
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            emitItem: (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item),
+            emitItem: (runId, item) => this.emitConversationItem(runId, item),
             captureSnapshot: (runId, cwd) => this.workspaceCoordinator.captureRunSnapshot(runId, cwd),
             approvalTimeoutMs: this.claudeApprovalTimeoutMs,
             publishApproval: (input) => this.runEventBridge.publishApproval(input)
@@ -367,6 +377,7 @@ export class NodeConnector {
             hasManagedActiveRun: (session) => hasManagedActiveRun(this.runtime, session),
             setExternalActivity: (sessionId, activity) => this.sessionState.externalActivity.set(sessionId, activity)
         });
+        this.conversationSegmentService = new ConversationSegmentService((session, input) => this.conversationHistoryService.read(session, input));
         this.sessionContextService = new SessionContextService({
             runners: this.runners,
             session: (sessionId) => this.runtime.getAgentSession(sessionId),
@@ -391,6 +402,7 @@ export class NodeConnector {
             resolve: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
             present: (session) => this.sessionPresentationService.present(session),
             history: (session, input) => this.conversationHistoryService.read(session, input),
+            segments: (session, input) => this.conversationSegmentService.read(session, input),
             context: this.sessionContextService,
             discover: (runner, workspaceId) => this.nativeSessionProjectionService.discover(runner, workspaceId),
             workspaceIdForCwd: (cwd) => this.database?.listWorkspaces().find((candidate) => candidate.path === cwd)?.id
@@ -400,11 +412,12 @@ export class NodeConnector {
             emit: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
             clearImages: (runId) => this.runAttachmentService.clear(runId),
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
-            emitConversation: (turn) => this.emitWorkbenchEvent('conversation', { turn }),
+            emitConversation: (turn) => this.emitConversationTurn(turn),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             stopped: () => this.stopped,
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId),
-            prepareInput: (runner, input, collaborationMode) => this.runners.require(runner).prepareMessageInput(input, collaborationMode)
+            prepareInput: (runner, input, collaborationMode) => this.runners.require(runner).prepareMessageInput(input, collaborationMode),
+            mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? []
         });
         this.sessionIdentityService = new SessionIdentityService({
             runtime: this.runtime,
@@ -426,7 +439,7 @@ export class NodeConnector {
             emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
             emitRun: (run) => this.emitWorkbenchEvent('run', { run }),
             emitQueue: (workspaceId, sessionId) => this.runEventBridge.emitQueue(workspaceId, sessionId),
-            emitTurn: (turn) => this.emitWorkbenchEvent('conversation', { turn })
+            emitTurn: (turn) => this.emitConversationTurn(turn)
         });
         this.sessionLifecycleService = new SessionLifecycleService({
             database: () => {
@@ -594,7 +607,7 @@ export class NodeConnector {
                 this.terminalChannel.disconnect();
                 if (code === 4000 && reason === 'NODE_CONNECTION_REPLACED')
                     nodeLog('node.connection.replaced', {
-                        message: '当前 Node 已被同一身份的新实例接管，请检查是否启动了重复实例。'
+                        message: 'This Node connection was replaced by a newer instance with the same identity. Check for duplicate processes.'
                     });
                 if (code === 4003 || code === 1001)
                     void this.terminalManager.shutdown();
@@ -714,6 +727,7 @@ export class NodeConnector {
                 throw new Error('NODE_CONFIG_UNAVAILABLE');
             return this.config;
         }).operations());
+        this.operationRouter.registerAll(new McpNodeOperationService(requireDatabase).operations());
         this.operationRouter.register('node.metrics', () => ({
             metrics: {
                 ...this.metrics.snapshot(),
@@ -778,7 +792,22 @@ export class NodeConnector {
     /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
     handleMessage = (raw) => this.controlMessages.handle(raw);
     emitRunEvent = (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status);
-    emitConversationItem = (runId, item) => this.runEventBridge.emitRun(runId, 'conversation.item', item);
+    emitConversationItem = (runId, item) => {
+        this.runEventService.flushPendingText(runId);
+        const itemId = isPlainRecord(item) && typeof item.itemId === 'string' ? item.itemId : undefined;
+        const itemKind = isPlainRecord(item) && typeof item.kind === 'string' ? item.kind : undefined;
+        const turn = this.runtime.conversationTurnForRun(runId);
+        const segment = itemId === undefined || turn === undefined
+            ? undefined
+            : conversationSegmentIdentityForItem(turn, itemId, itemKind);
+        this.runEventBridge.emitRun(runId, 'conversation.item', segment === undefined || !isPlainRecord(item)
+            ? item
+            : { ...item, segmentId: segment.id, segmentIndex: segment.index });
+    };
+    emitConversationTurn = (turn) => {
+        const segments = isPlainRecord(turn) && Array.isArray(turn.items) ? conversationSegments(turn) : [];
+        this.emitWorkbenchEvent('conversation', { turn, segments });
+    };
     emitWorkbenchEvent = (category, payload) => this.runEventBridge.emitWorkbench(category, payload);
     discoverWorkspaceSessions = (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId);
     invalidateWorkspaceWatchTopics = (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId);

package/dist/database.d.ts

@@ -1,6 +1,19 @@
 import { DatabaseSync } from 'node:sqlite';
 import { type AgentRunStatus, type RunnerDefaultConfiguration, type RunnerName } from '@myagentroam/protocol';
+import { type McpCatalogEntry, type McpInstallationConfiguration, type McpRuntimeDescriptor } from '@myagentroam/protocol';
 import type { NativeSessionHistory } from './native-session-history.js';
+export interface NodeMcpInstallation {
+    readonly targetKind: 'NODE' | 'WORKSPACE';
+    readonly targetId: string;
+    readonly catalogEntryId: string;
+    readonly serverName: string;
+    readonly displayName: string;
+    readonly version: string;
+    readonly enabled: boolean;
+    readonly runtime: McpRuntimeDescriptor;
+    readonly configuration: McpInstallationConfiguration;
+    readonly installedAt: number;
+}
 export type RunRecoveryState = 'ACTIVE' | 'SUSPECT' | 'LOST';
 export type ApprovalStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'EXPIRED';
 /** Whether a native session ID was created by this Node or merely discovered. */
@@ -153,6 +166,16 @@ export declare class NodeDatabase {
     close(): void;
     getRunnerDefaults(): readonly RunnerDefaultConfiguration[];
     saveRunnerDefaults(input: RunnerDefaultConfiguration): RunnerDefaultConfiguration;
+    listMcpInstallations(targetKind: 'NODE' | 'WORKSPACE', targetId?: string): readonly NodeMcpInstallation[];
+    saveMcpInstallation(input: {
+        readonly targetKind: 'NODE' | 'WORKSPACE';
+        readonly targetId?: string;
+        readonly entry: McpCatalogEntry;
+        readonly enabled: boolean;
+        readonly configuration: NodeMcpInstallation['configuration'];
+    }): NodeMcpInstallation;
+    removeMcpInstallation(targetKind: 'NODE' | 'WORKSPACE', targetId: string, serverName: string): boolean;
+    effectiveMcpInstallations(workspaceId: string): readonly NodeMcpInstallation[];
     /**
      * Stores only terminal lifecycle metadata. PTY input/output must remain in
      * the Node-local bounded replay buffer and must never be passed here.

package/dist/database.js

@@ -3,10 +3,12 @@ import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
+import { mcpCatalogEntrySchema, mcpInstallationConfigurationSchema, mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 import { assertNodeSchema, NODE_SCHEMA_V1 } from './migrations/v001.js';
 import { assertNodeSchemaV2, migrateNodeSchemaV2 } from './migrations/v002.js';
-import { assertNodeSchemaV3, migrateNodeSchemaV3, NODE_SCHEMA_VERSION_V3 } from './migrations/v003.js';
-const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V3;
+import { assertNodeSchemaV3, migrateNodeSchemaV3 } from './migrations/v003.js';
+import { assertNodeSchemaV4, migrateNodeSchemaV4, NODE_SCHEMA_VERSION_V4 } from './migrations/v004.js';
+const NODE_SCHEMA_VERSION = NODE_SCHEMA_VERSION_V4;
 export class NodeDatabase {
     now;
     activeWorkspaceLeaseCount() {
@@ -63,6 +65,57 @@ export class NodeDatabase {
             .run(input.runner, input.model, input.effort, input.access);
         return input;
     }
+    listMcpInstallations(targetKind, targetId = '') {
+        const rows = this.raw
+            .prepare(`SELECT target_kind,target_id,catalog_entry_id,server_name,display_name,version,
+                enabled,runtime,configuration,installed_at
+         FROM mcp_installations WHERE target_kind=? AND target_id=? ORDER BY display_name,server_name`)
+            .all(targetKind, targetKind === 'NODE' ? '' : targetId);
+        return rows.map(mcpInstallation);
+    }
+    saveMcpInstallation(input) {
+        const entry = mcpCatalogEntrySchema.parse(input.entry);
+        const configuration = mcpInstallationConfigurationSchema.parse(input.configuration);
+        const targetId = input.targetKind === 'NODE' ? '' : (input.targetId ?? '');
+        if (input.targetKind === 'WORKSPACE' && this.getWorkspace(targetId) === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const installedAt = this.now();
+        this.raw
+            .prepare(`INSERT INTO mcp_installations
+         (target_kind,target_id,catalog_entry_id,server_name,display_name,version,enabled,runtime,configuration,installed_at)
+         VALUES (?,?,?,?,?,?,?,?,?,?)
+         ON CONFLICT(target_kind,target_id,server_name) DO UPDATE SET
+           catalog_entry_id=excluded.catalog_entry_id,display_name=excluded.display_name,
+           version=excluded.version,enabled=excluded.enabled,runtime=excluded.runtime,
+           configuration=excluded.configuration,installed_at=excluded.installed_at`)
+            .run(input.targetKind, targetId, entry.id, entry.serverName, entry.displayName, entry.version, input.enabled ? 1 : 0, JSON.stringify(entry.runtime), JSON.stringify(configuration), installedAt);
+        return {
+            targetKind: input.targetKind,
+            targetId,
+            catalogEntryId: entry.id,
+            serverName: entry.serverName,
+            displayName: entry.displayName,
+            version: entry.version,
+            enabled: input.enabled,
+            runtime: entry.runtime,
+            configuration,
+            installedAt
+        };
+    }
+    removeMcpInstallation(targetKind, targetId, serverName) {
+        return (Number(this.raw
+            .prepare('DELETE FROM mcp_installations WHERE target_kind=? AND target_id=? AND server_name=?')
+            .run(targetKind, targetKind === 'NODE' ? '' : targetId, serverName).changes) > 0);
+    }
+    effectiveMcpInstallations(workspaceId) {
+        const effective = new Map(this.listMcpInstallations('NODE').map((installation) => [
+            installation.serverName,
+            installation
+        ]));
+        for (const installation of this.listMcpInstallations('WORKSPACE', workspaceId))
+            effective.set(installation.serverName, installation);
+        return [...effective.values()].filter((installation) => installation.enabled);
+    }
     /**
      * Stores only terminal lifecycle metadata. PTY input/output must remain in
      * the Node-local bounded replay buffer and must never be passed here.
@@ -138,6 +191,9 @@ export class NodeDatabase {
             // record itself never represents a filesystem deletion.
             this.raw.prepare('DELETE FROM agent_sessions WHERE workspace_id = ?').run(id);
             this.raw.prepare('DELETE FROM legacy_agent_sessions WHERE workspace_id = ?').run(id);
+            this.raw
+                .prepare("DELETE FROM mcp_installations WHERE target_kind='WORKSPACE' AND target_id = ?")
+                .run(id);
             this.raw.prepare('DELETE FROM workspaces WHERE id = ?').run(id);
             this.raw.exec('COMMIT');
             return current;
@@ -1028,6 +1084,8 @@ function migrate(database) {
             database.exec('COMMIT');
             migrateNodeSchemaV3(database);
             assertNodeSchemaV3(database);
+            migrateNodeSchemaV4(database);
+            assertNodeSchemaV4(database);
             return;
         }
         catch (error) {
@@ -1066,6 +1124,8 @@ function migrate(database) {
         assertNodeSchemaV2(database);
         migrateNodeSchemaV3(database);
         assertNodeSchemaV3(database);
+        migrateNodeSchemaV4(database);
+        assertNodeSchemaV4(database);
         return;
     }
     if (current === 0) {
@@ -1092,7 +1152,29 @@ function migrate(database) {
         .get();
     if (numberValue(afterV2, 'version') === 2)
         migrateNodeSchemaV3(database);
+    const afterV3 = database
+        .prepare('SELECT MAX(version) AS version FROM node_schema_migrations')
+        .get();
+    if (numberValue(afterV3, 'version') === 3)
+        migrateNodeSchemaV4(database);
     assertNodeSchemaV3(database);
+    assertNodeSchemaV4(database);
+}
+function mcpInstallation(row) {
+    const runtime = mcpRuntimeDescriptorSchema.parse(JSON.parse(stringValue(row, 'runtime')));
+    const configuration = mcpInstallationConfigurationSchema.parse(JSON.parse(stringValue(row, 'configuration')));
+    return {
+        targetKind: stringValue(row, 'target_kind'),
+        targetId: stringValue(row, 'target_id'),
+        catalogEntryId: stringValue(row, 'catalog_entry_id'),
+        serverName: stringValue(row, 'server_name'),
+        displayName: stringValue(row, 'display_name'),
+        version: stringValue(row, 'version'),
+        enabled: numberValue(row, 'enabled') === 1,
+        runtime,
+        configuration,
+        installedAt: numberValue(row, 'installed_at')
+    };
 }
 function sessionMetadata(row) {
     const raw = JSON.parse(stringValue(row, 'metadata'));

package/dist/migrations/v004.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare const NODE_SCHEMA_VERSION_V4 = 4;
+export declare function migrateNodeSchemaV4(database: DatabaseSync): void;
+export declare function assertNodeSchemaV4(database: DatabaseSync): void;

package/dist/migrations/v004.js

@@ -0,0 +1,35 @@
+export const NODE_SCHEMA_VERSION_V4 = 4;
+export function migrateNodeSchemaV4(database) {
+    database.exec('BEGIN IMMEDIATE');
+    try {
+        database.exec(`CREATE TABLE mcp_installations (
+      target_kind TEXT NOT NULL CHECK (target_kind IN ('NODE','WORKSPACE')),
+      target_id TEXT NOT NULL,
+      catalog_entry_id TEXT NOT NULL,
+      server_name TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      version TEXT NOT NULL,
+      enabled INTEGER NOT NULL CHECK (enabled IN (0,1)),
+      runtime TEXT NOT NULL CHECK (json_valid(runtime)),
+      configuration TEXT NOT NULL CHECK (json_valid(configuration)),
+      installed_at INTEGER NOT NULL,
+      PRIMARY KEY (target_kind,target_id,server_name),
+      CHECK ((target_kind='NODE' AND target_id='') OR (target_kind='WORKSPACE' AND target_id<>''))
+    ) STRICT;`);
+        database
+            .prepare('INSERT INTO node_schema_migrations (version, applied_at) VALUES (?, ?)')
+            .run(NODE_SCHEMA_VERSION_V4, Date.now());
+        database.exec('COMMIT');
+    }
+    catch (error) {
+        database.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function assertNodeSchemaV4(database) {
+    const row = database
+        .prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='mcp_installations'")
+        .get();
+    if (typeof row?.sql !== 'string' || !row.sql.includes("target_kind IN ('NODE','WORKSPACE')"))
+        throw new Error('NODE_DATABASE_SCHEMA_INVALID:mcp_installations');
+}