@myagentroam/node 0.1.8 → 0.9.0

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.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';
@@ -230,7 +231,7 @@ export class NodeConnector {
             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.codexClient = new CodexRunner(options.codexClient, options.codexProfileClientFactory);
         this.codexRunController = new CodexManagedRunController(this.codexClient, {
             available: () => this.capabilities.codex.available,
             intercepted: () => this.fakeRunner !== undefined,
@@ -404,7 +405,8 @@ export class NodeConnector {
             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,
@@ -714,6 +716,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(),

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');
+}

package/dist/opencode-server.d.ts

@@ -16,6 +16,7 @@ export declare class OpenCodeServerClient {
     start(): Promise<void>;
     private startServer;
     providers(directory: string): Promise<OpenCodeProviderCatalog>;
+    configureMcp(directory: string, mcp: unknown): Promise<void>;
     sessions(directory: string, limit?: number): Promise<readonly unknown[]>;
     sessionStatus(directory: string): Promise<Readonly<Record<string, unknown>>>;
     createSession(directory: string, title?: string): Promise<unknown>;

package/dist/opencode-server.js

@@ -77,6 +77,18 @@ export class OpenCodeServerClient {
         const client = await this.requireClient();
         return unwrap(await client.provider.list({ directory }));
     }
+    async configureMcp(directory, mcp) {
+        const client = await this.requireClient();
+        if (typeof mcp !== 'object' || mcp === null || Array.isArray(mcp))
+            return;
+        for (const [name, config] of Object.entries(mcp)) {
+            await client.mcp.add({
+                directory,
+                name,
+                config: config
+            });
+        }
+    }
     async sessions(directory, limit = 100) {
         const client = await this.requireClient();
         return unwrap(await client.session.list({ directory, limit }));

package/dist/runner/abstract-runner.d.ts

@@ -21,14 +21,15 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
     abstract profile(capabilities: NodeCapabilities): RunnerProfile | undefined;
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile | undefined>;
     abstract available(capabilities: NodeCapabilities): boolean;
-    abstract defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
+    abstract defaultConfiguration(workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
     protected abstract profileForValidation(): RunnerProfile;
     abstract resumeExternal(session: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
     abstract discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     abstract readContextUsage(session: NodeAgentSession): Promise<RunnerContextUsage | undefined>;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
+    mcpConfiguration(rawInstallations: unknown, secretEnvironment: Readonly<Record<string, string>>): unknown;
     channelToken(sessionId: string): string | undefined;
     deliverChannel(sessionId: string, messageId: string, senderId: string, token: string, content: string, notify: (runId: string, messageId: string, delivery: ChannelDelivery) => void): ChannelDelivery;
     executeGlobalCommand(commandId: string, input: string): unknown;
@@ -66,6 +67,15 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
         readonly secretEnvironment: Readonly<Record<string, string>>;
     }): Promise<unknown>;
 }
+export interface ResolvedMcpServer {
+    readonly name: string;
+    readonly transport: 'STDIO' | 'HTTP';
+    readonly command?: string;
+    readonly args?: readonly string[];
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly url?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
 export type RunnerCancellationIntent = 'CANCEL' | 'INTERRUPT';
 export interface RunnerControl {
     start(envelope: NodeEnvelope): void;

package/dist/runner/abstract-runner.js

@@ -1,3 +1,4 @@
+import { mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 /**
  * Stable lifecycle boundary for every Node Runner implementation.
  *
@@ -15,8 +16,8 @@ export class AbstractRunner {
         void [workspace, environment];
         return this.profile(capabilities);
     }
-    supportsConfiguration(configuration, workspace) {
-        void workspace;
+    supportsConfiguration(configuration, workspace, environment) {
+        void [workspace, environment];
         const profile = this.profileForValidation();
         const model = profile.models.find((candidate) => candidate.id === configuration.model);
         return (configuration.runner === this.name &&
@@ -32,6 +33,9 @@ export class AbstractRunner {
         void collaborationMode;
         return input;
     }
+    mcpConfiguration(rawInstallations, secretEnvironment) {
+        return resolvedMcpServers(rawInstallations, secretEnvironment);
+    }
     channelToken(sessionId) {
         void sessionId;
         return undefined;
@@ -143,6 +147,76 @@ export class AbstractRunner {
         return this.commandControl.execute(session, command, input, context);
     }
 }
+function resolvedMcpServers(raw, secrets) {
+    if (!Array.isArray(raw))
+        return [];
+    const result = [];
+    for (const value of raw) {
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const record = value;
+        if (typeof record['serverName'] !== 'string' || record['enabled'] !== true)
+            continue;
+        const runtime = mcpRuntimeDescriptorSchema.safeParse(record['runtime']);
+        if (!runtime.success)
+            continue;
+        const configuration = isRecord(record['configuration']) ? record['configuration'] : {};
+        const resolveReferences = (candidate) => {
+            if (!isRecord(candidate))
+                return {};
+            const result = {};
+            for (const [name, reference] of Object.entries(candidate)) {
+                if (!isRecord(reference) || typeof reference['secretName'] !== 'string')
+                    return undefined;
+                const secret = secrets[reference['secretName']];
+                if (secret === undefined)
+                    return undefined;
+                result[name] = secret;
+            }
+            return result;
+        };
+        if (runtime.data.transport === 'STDIO') {
+            const runtimeEnvironment = resolveReferences(runtime.data.environment);
+            const configuredEnvironment = resolveReferences(configuration['environment']);
+            if (runtimeEnvironment === undefined || configuredEnvironment === undefined)
+                continue;
+            result.push({
+                name: record['serverName'],
+                transport: 'STDIO',
+                command: runtime.data.command,
+                args: [
+                    ...runtime.data.args,
+                    ...(Array.isArray(configuration['arguments'])
+                        ? configuration['arguments'].filter((item) => typeof item === 'string')
+                        : [])
+                ],
+                environment: {
+                    ...runtimeEnvironment,
+                    ...configuredEnvironment
+                }
+            });
+        }
+        else {
+            const runtimeHeaders = resolveReferences(runtime.data.headers);
+            const configuredHeaders = resolveReferences(configuration['headers']);
+            if (runtimeHeaders === undefined || configuredHeaders === undefined)
+                continue;
+            result.push({
+                name: record['serverName'],
+                transport: 'HTTP',
+                url: runtime.data.url,
+                headers: {
+                    ...runtimeHeaders,
+                    ...configuredHeaders
+                }
+            });
+        }
+    }
+    return result;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 export class RunnerCapabilityError extends Error {
     runner;
     capability;

package/dist/runner/claude/managed-run-controller.js

@@ -27,7 +27,7 @@ export class ClaudeManagedRunController {
                 detail: '后续消息将以标签式规划模式运行，只读规划并输出计划卡。',
                 closable: true,
                 closeInput: '/plan',
-                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
@@ -138,6 +138,7 @@ export class ClaudeManagedRunController {
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
                 environment: secretEnvironment,
+                mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment),
                 ...(attachments.length === 0
                     ? {}
                     : {

package/dist/runner/claude-code-runner.d.ts

@@ -17,6 +17,7 @@ export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
     available(capabilities: NodeCapabilities): boolean;
     protected profileForValidation(): RunnerProfile;
     defaultConfiguration(): RunnerDefaultConfiguration;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;

package/dist/runner/claude-code-runner.js

@@ -45,6 +45,20 @@ export class ClaudeCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    mcpConfiguration(raw, secrets) {
+        const servers = super.mcpConfiguration(raw, secrets);
+        return Object.fromEntries(servers.map((server) => [
+            server.name,
+            server.transport === 'STDIO'
+                ? {
+                    type: 'stdio',
+                    command: server.command,
+                    args: [...(server.args ?? [])],
+                    env: { ...(server.environment ?? {}) }
+                }
+                : { type: 'http', url: server.url, headers: { ...(server.headers ?? {}) } }
+        ]));
+    }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
             external.nativeControl !== 'EXTERNAL' ||

package/dist/runner/codex/managed-run-controller.js

@@ -35,7 +35,7 @@ export class CodexManagedRunController {
                     detail: '后续消息将以协作规划模式运行。',
                     closable: true,
                     closeInput: '/plan',
-                    continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                    continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
                 });
             return { command: command.id, states: this.host.commandStates(session.id) };
         }
@@ -325,7 +325,8 @@ export class CodexManagedRunController {
             effort: payload.effort,
             access: payload.access,
             collaborationMode: payload.collaborationMode,
-            serviceTier: payload.serviceTier
+            serviceTier: payload.serviceTier,
+            mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment)
         }, attachments);
     }
     async run(payload, attachments) {
@@ -340,7 +341,8 @@ export class CodexManagedRunController {
             const configuration = {
                 ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
-                ...(typeof payload.access === 'string' ? { access: payload.access } : {})
+                ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
+                ...(payload.mcpServers === undefined ? {} : { mcpServers: payload.mcpServers })
             };
             const threadResult = typeof payload.externalSessionId === 'string'
                 ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)

package/dist/runner/codex-runner.d.ts

@@ -5,17 +5,29 @@ import type { NodeAgentSession, NodeDatabase } from '../database.js';
 import type { NodeWorkspace } from '../database.js';
 export declare class CodexRunner extends AbstractRunner<'codex'> {
     private readonly client;
+    private readonly profileClientFactory;
     readonly name: "codex";
     readonly discoveryScope: "ALL_WORKSPACES";
     readonly execution: CodexExecutionState;
     private fastEnabled;
     private environmentFingerprint;
     private readonly environmentRuns;
-    constructor(client?: CodexAppServerClient);
+    private readonly profileCache;
+    private readonly profileRefreshes;
+    private readonly profileClients;
+    private readonly profileKeyByEnvironment;
+    private latestProfileCache;
+    private selectedProfileKey;
+    constructor(client?: CodexAppServerClient, profileClientFactory?: () => CodexAppServerClient);
     profile(capabilities: NodeCapabilities): RunnerProfile;
+    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
+    private refreshCodexProfile;
+    private selectCachedProfile;
+    private fetchCodexProfile;
     available(capabilities: NodeCapabilities): boolean;
     executeGlobalCommand(commandId: string, input: string): unknown;
     serviceTier(): 'fast' | undefined;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     usesRunnerTitleForRename(): boolean;
     renameNative(session: NodeAgentSession, input: {
         readonly title?: string | null;
@@ -35,7 +47,9 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     nativeImageRoot(session: NodeAgentSession): string | undefined;
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     protected profileForValidation(): RunnerProfile;
-    defaultConfiguration(): RunnerDefaultConfiguration;
+    defaultConfiguration(_workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, _workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
+    private profileCacheForEnvironment;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeCodexContextUsage | undefined>;