@myagentroam/node 0.1.7 → 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/config.d.ts

@@ -2,19 +2,17 @@ export interface NodeConfig {
     readonly serverUrl: string;
     /** Explicit roots or the platform default resolved while loading the config. */
     readonly allowedRoots: readonly string[];
-    /** Absolute or config-relative location of this Node's private runtime SQLite. */
-    readonly databasePath?: string;
+    /** Absolute or config-relative root for SQLite, upgrades and other private Node data. */
+    readonly dataDirectory?: string;
     readonly nodeId?: string;
     readonly credential?: string;
     readonly registrationToken?: string;
-    readonly upgrade?: {
-        readonly registryUrl?: string;
-    };
 }
 export declare function nodeConfigPath(): string;
 export declare function loadNodeConfig(path?: string): Promise<NodeConfig>;
 /** Uses the Node service account's scope when no Workspace roots are configured. */
 export declare function defaultAllowedRoots(platform?: NodeJS.Platform, homePath?: string, currentDirectory?: string): readonly string[];
 export declare function nodeDatabasePath(config: NodeConfig, configPath?: string): string;
+export declare function nodeDataDirectory(config: NodeConfig, configPath?: string): string;
 /** Credentials are always written with owner-only POSIX permissions where supported. */
 export declare function saveNodeConfig(config: NodeConfig, path?: string): Promise<void>;

package/dist/config.js

@@ -10,6 +10,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         parsed === null ||
         !('serverUrl' in parsed) ||
         typeof parsed.serverUrl !== 'string' ||
+        'databasePath' in parsed ||
         ('allowedRoots' in parsed &&
             (!Array.isArray(parsed.allowedRoots) ||
                 !parsed.allowedRoots.every((root) => typeof root === 'string')))) {
@@ -20,15 +21,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
     const nodeId = optionalString('nodeId');
     const credential = optionalString('credential');
     const registrationToken = optionalString('registrationToken');
-    const databasePath = optionalString('databasePath');
-    const upgradeInput = input['upgrade'];
-    if (upgradeInput !== undefined &&
-        (upgradeInput === null ||
-            typeof upgradeInput !== 'object' ||
-            Array.isArray(upgradeInput) ||
-            ('registryUrl' in upgradeInput &&
-                typeof upgradeInput['registryUrl'] !== 'string')))
-        throw new Error('NODE_CONFIG_INVALID');
+    const dataDirectory = optionalString('dataDirectory');
     const allowedRoots = Array.isArray(input['allowedRoots'])
         ? input['allowedRoots']
         : defaultAllowedRoots();
@@ -38,16 +31,7 @@ export async function loadNodeConfig(path = nodeConfigPath()) {
         ...(nodeId === undefined ? {} : { nodeId }),
         ...(credential === undefined ? {} : { credential }),
         ...(registrationToken === undefined ? {} : { registrationToken }),
-        ...(databasePath === undefined ? {} : { databasePath }),
-        ...(upgradeInput === undefined
-            ? {}
-            : {
-                upgrade: {
-                    ...(upgradeInput['registryUrl'] === undefined
-                        ? {}
-                        : { registryUrl: upgradeInput['registryUrl'] })
-                }
-            })
+        ...(dataDirectory === undefined ? {} : { dataDirectory })
     };
 }
 /** Uses the Node service account's scope when no Workspace roots are configured. */
@@ -55,7 +39,12 @@ export function defaultAllowedRoots(platform = process.platform, homePath = home
     return platform === 'win32' ? [win32.parse(currentDirectory).root] : [homePath];
 }
 export function nodeDatabasePath(config, configPath = nodeConfigPath()) {
-    return config.databasePath ?? resolve(dirname(configPath), 'node-runtime.sqlite');
+    return resolve(nodeDataDirectory(config, configPath), 'node-runtime.sqlite');
+}
+export function nodeDataDirectory(config, configPath = nodeConfigPath()) {
+    if (config.dataDirectory !== undefined)
+        return resolve(dirname(configPath), config.dataDirectory);
+    return resolve(dirname(configPath));
 }
 /** Credentials are always written with owner-only POSIX permissions where supported. */
 export async function saveNodeConfig(config, path = nodeConfigPath()) {

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

@@ -18,6 +18,8 @@ import { RunnerRegistry } from './runner/runner-registry.js';
 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';
@@ -229,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,
@@ -313,9 +315,9 @@ export class NodeConnector {
             commandStates: (sessionId) => this.commandStates.list(sessionId)
         });
         this.runners = new RunnerRegistry([
+            this.openCodeClient,
             this.codexClient,
             this.claudeClient,
-            this.openCodeClient,
             ...(this.fakeRunner === undefined ? [] : [this.fakeRunner])
         ]);
         this.managedRunnerSessions = new ManagedRunnerSessionService(this.runtime, this.runners, (session) => this.emitWorkbenchEvent('session', {
@@ -403,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,
@@ -708,6 +711,12 @@ export class NodeConnector {
         this.operationRouter.registerAll(this.sessionCatalogService.operations());
         this.operationRouter.registerAll(this.sessionCommandService.operations());
         this.operationRouter.registerAll(this.workspaceQueueWorkbenchService.operations());
+        this.operationRouter.registerAll(new SkillNodeOperationService(requireDatabase, () => {
+            if (this.config === undefined)
+                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/main.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { dirname, resolve } from 'node:path';
 import { NodeConnector } from './connector.js';
-import { loadNodeConfig, nodeConfigPath, nodeDatabasePath } from './config.js';
+import { loadNodeConfig, nodeConfigPath, nodeDatabasePath, nodeDataDirectory } from './config.js';
 import { getNodeHealth } from './health.js';
 import { removeServiceDefinition, writeServiceDefinition } from './service.js';
 import { superviseNode } from './supervisor.js';
+import { configureNodeLog } from './rotating-log.js';
 const [command = 'status', ...args] = process.argv.slice(2);
 const config = readOption(args, '--config') ?? nodeConfigPath();
 const output = readOption(args, '--output') ?? defaultServicePath();
 if (command === 'run') {
+    configureNodeLog(nodeDataDirectory(await loadNodeConfig(config), config));
     const connector = new NodeConnector({ configPath: config });
     await connector.start();
     for (const signal of ['SIGINT', 'SIGTERM']) {
@@ -18,6 +20,7 @@ if (command === 'run') {
 else if (command === 'supervise') {
     if (process.argv[1] === undefined)
         throw new Error('NODE_ENTRYPOINT_UNAVAILABLE');
+    configureNodeLog(nodeDataDirectory(await loadNodeConfig(config), config));
     await superviseNode(config, process.argv[1]);
 }
 else if (command === 'install') {

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

@@ -1,7 +1,6 @@
 import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { createServer } from 'node:net';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2/client';
 import { minimalRunnerEnvironment, platformCliInvocation } from './operational.js';
 import { terminateProcessTree } from './process-tree.js';
 const START_TIMEOUT_MS = 10_000;
@@ -35,6 +34,7 @@ export class OpenCodeServerClient {
         }
     }
     async startServer() {
+        const { createOpencodeClient } = await import('@opencode-ai/sdk/v2/client');
         const port = await availablePort();
         const password = randomBytes(24).toString('base64url');
         const invocation = platformCliInvocation(this.options.command ?? 'opencode', [
@@ -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/operational.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { writeNodeLog } from './rotating-log.js';
 const secretKey = /(?:password|credential|token|cookie|authorization|secret|api[_-]?key)/i;
 export function runRunnerProbe(command, args, options) {
     return new Promise((resolve) => {
@@ -115,5 +116,7 @@ export function platformCliInvocation(command, args, platform = process.platform
 }
 export function nodeLog(event, fields = {}) {
     const safeFields = redactLogValue(fields);
-    process.stdout.write(`${JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component: 'mar-node', event, ...safeFields })}\n`);
+    const line = `${JSON.stringify({ timestamp: new Date().toISOString(), level: 'info', component: 'mar-node', event, ...safeFields })}\n`;
+    process.stdout.write(line);
+    writeNodeLog(line);
 }

package/dist/rotating-log.d.ts

@@ -0,0 +1,17 @@
+export declare function configureNodeLog(dataDirectory: string): void;
+export declare function writeNodeLog(content: string): void;
+export declare class RotatingNodeLog {
+    private readonly maxBytes;
+    private readonly retentionMs;
+    private readonly now;
+    private readonly activePath;
+    private bytes;
+    private day;
+    private rotation;
+    private lastCleanup;
+    constructor(directory: string, maxBytes?: number, retentionMs?: number, now?: () => number);
+    write(content: string): void;
+    private currentDay;
+    private rotate;
+    private cleanup;
+}

package/dist/rotating-log.js

@@ -0,0 +1,67 @@
+import { appendFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+const DAY_MS = 24 * 60 * 60 * 1_000;
+let sink;
+export function configureNodeLog(dataDirectory) {
+    sink = new RotatingNodeLog(resolve(dataDirectory, 'logs'));
+}
+export function writeNodeLog(content) {
+    sink?.write(content);
+}
+export class RotatingNodeLog {
+    maxBytes;
+    retentionMs;
+    now;
+    activePath;
+    bytes = 0;
+    day = '';
+    rotation = 0;
+    lastCleanup = 0;
+    constructor(directory, maxBytes = 100 * 1024 * 1024, retentionMs = 7 * DAY_MS, now = Date.now) {
+        this.maxBytes = maxBytes;
+        this.retentionMs = retentionMs;
+        this.now = now;
+        mkdirSync(directory, { recursive: true });
+        this.activePath = resolve(directory, 'node.log');
+        try {
+            const stat = statSync(this.activePath);
+            this.bytes = stat.size;
+            this.day = new Date(stat.mtimeMs).toISOString().slice(0, 10);
+        }
+        catch {
+            this.day = this.currentDay();
+        }
+        this.cleanup();
+    }
+    write(content) {
+        const length = Buffer.byteLength(content);
+        const day = this.currentDay();
+        if (this.bytes > 0 && (this.bytes + length > this.maxBytes || day !== this.day))
+            this.rotate();
+        appendFileSync(this.activePath, content, { encoding: 'utf8', mode: 0o600 });
+        this.bytes += length;
+        this.day = day;
+        if (this.now() - this.lastCleanup >= DAY_MS)
+            this.cleanup();
+    }
+    currentDay() {
+        return new Date(this.now()).toISOString().slice(0, 10);
+    }
+    rotate() {
+        const suffix = `${this.day}-${this.now()}-${String(this.rotation++).padStart(3, '0')}`;
+        renameSync(this.activePath, resolve(this.activePath, '..', `node-${suffix}.log`));
+        this.bytes = 0;
+    }
+    cleanup() {
+        const directory = resolve(this.activePath, '..');
+        const cutoff = this.now() - this.retentionMs;
+        for (const entry of readdirSync(directory)) {
+            if (!entry.startsWith('node-') || !entry.endsWith('.log'))
+                continue;
+            const path = resolve(directory, entry);
+            if (statSync(path).mtimeMs < cutoff)
+                unlinkSync(path);
+        }
+        this.lastCleanup = this.now();
+    }
+}