@myagentroam/node 0.1.4 → 0.1.6

package/dist/service/native-session-projection-service.d.ts

@@ -1,4 +1,4 @@
-import type { RunnerDefaultConfiguration } from '@myagentroam/protocol';
+import type { NodeCapabilities, RunnerDefaultConfiguration } from '@myagentroam/protocol';
 import type { CodexSessionControl } from '../codex-app-server.js';
 import type { NodeAgentSession, NodeDatabase } from '../database.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
@@ -11,6 +11,7 @@ interface NativeSessionProjectionServiceOptions {
     readonly nodeId: () => string;
     readonly runtime: NodeRuntimeState;
     readonly runners: RunnerRegistry;
+    readonly capabilities: () => NodeCapabilities;
     readonly state: SessionDomainState<NodeAgentSession, unknown>;
     readonly commands: CommandStateStore;
     readonly present: (session: NodeAgentSession) => NodeAgentSession & {

package/dist/service/native-session-projection-service.js

@@ -10,7 +10,7 @@ export class NativeSessionProjectionService {
         if (workspaceId !== undefined && workspace === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
         const runner = this.options.runners.product(runnerName);
-        if (runner === undefined)
+        if (runner === undefined || !runner.available(this.options.capabilities()))
             throw new Error('RUNNER_UNAVAILABLE');
         const sessions = await runner.discoverSessions({
             workspaces: database.listWorkspaces(),
@@ -27,6 +27,7 @@ export class NativeSessionProjectionService {
     async list() {
         const discovered = await Promise.all(this.options.runners
             .advertised()
+            .filter((runner) => runner.available(this.options.capabilities()))
             .map((runner) => this.discover(runner.name)));
         const sessions = deduplicateDirectSessions(discovered.flat());
         this.remember(sessions);
@@ -35,6 +36,7 @@ export class NativeSessionProjectionService {
     async discoverWorkspace(workspaceId) {
         const discovered = await Promise.all(this.options.runners
             .advertised()
+            .filter((runner) => runner.available(this.options.capabilities()))
             .map((runner) => this.discover(runner.name, workspaceId)));
         const sessions = deduplicateDirectSessions(discovered.flat());
         this.remember(sessions);
@@ -96,6 +98,7 @@ export class NativeSessionProjectionService {
         });
     }
     resumedConfiguration(session) {
+        const workspace = this.options.database()?.getWorkspace(session.workspaceId);
         const current = {
             runner: session.runner,
             model: session.model,
@@ -110,13 +113,14 @@ export class NativeSessionProjectionService {
                 model: current.model,
                 effort: current.effort,
                 access: current.access
-            }))
+            }, workspace))
             return current;
         const saved = this.options
             .database()
             ?.getRunnerDefaults()
-            .find((value) => value.runner === session.runner && this.options.runners.supportsConfiguration(value));
-        return saved ?? this.options.runners.require(session.runner).defaultConfiguration();
+            .find((value) => value.runner === session.runner &&
+            this.options.runners.supportsConfiguration(value, workspace));
+        return saved ?? this.options.runners.require(session.runner).defaultConfiguration(workspace);
     }
     ensureResumedConfiguration(session) {
         const configuration = this.resumedConfiguration(session);
@@ -265,4 +269,3 @@ export class NativeSessionProjectionService {
         return database;
     }
 }
-//# sourceMappingURL=native-session-projection-service.js.map

package/dist/service/native-session-watch-service.js

@@ -148,4 +148,3 @@ export class NativeSessionWatchService {
         }
     }
 }
-//# sourceMappingURL=native-session-watch-service.js.map

package/dist/service/node-connection-lifecycle-service.js

@@ -34,6 +34,7 @@ export class NodeConnectionLifecycleService {
             serverUrl: config.serverUrl,
             allowedRoots: config.allowedRoots,
             ...(config.databasePath === undefined ? {} : { databasePath: config.databasePath }),
+            ...(config.upgrade === undefined ? {} : { upgrade: config.upgrade }),
             nodeId,
             credential
         };
@@ -67,7 +68,8 @@ export class NodeConnectionLifecycleService {
                 next = {
                     ...this.options.capabilities(),
                     codex: { available: false },
-                    claudeCode: { available: false }
+                    claudeCode: { available: false },
+                    openCode: { available: false }
                 };
             }
             if (this.options.stopped() ||
@@ -81,4 +83,3 @@ export class NodeConnectionLifecycleService {
         }
     }
 }
-//# sourceMappingURL=node-connection-lifecycle-service.js.map

package/dist/service/node-control-channel.d.ts

@@ -10,7 +10,7 @@ interface NodeControlChannelOptions {
     readonly onConnecting: (attempt: number) => void;
     readonly onReconnectScheduled: () => void;
     readonly onMessage: (raw: string) => void;
-    readonly onClose: (code: number) => void;
+    readonly onClose: (code: number, reason: string) => void;
 }
 export declare class NodeControlChannel {
     private readonly options;

package/dist/service/node-control-channel.js

@@ -35,13 +35,15 @@ export class NodeControlChannel {
                 socket.close(4000, 'NODE_CREDENTIAL_MISSING');
         });
         socket.on('message', (raw) => this.options.onMessage(raw.toString()));
-        socket.once('close', (code) => {
+        socket.once('close', (code, reason) => {
             if (this.socket !== socket)
                 return;
             this.socket = undefined;
             this.outbound.reset();
-            this.options.onClose(code);
-            this.scheduleReconnect();
+            const reasonText = reason.toString();
+            this.options.onClose(code, reasonText);
+            if (!(code === 4000 && reasonText === 'NODE_CONNECTION_REPLACED'))
+                this.scheduleReconnect();
         });
         socket.once('error', () => undefined);
     }
@@ -81,4 +83,3 @@ export class NodeControlChannel {
         }, this.options.reconnectDelay(this.attempts++));
     }
 }
-//# sourceMappingURL=node-control-channel.js.map

package/dist/service/node-control-message-service.js

@@ -102,4 +102,3 @@ export class NodeControlMessageService {
         this.options.send('ack', { type: envelope.type }, envelope.id);
     }
 }
-//# sourceMappingURL=node-control-message-service.js.map

package/dist/service/node-request-service.js

@@ -48,4 +48,3 @@ export class NodeRequestService {
         }
     }
 }
-//# sourceMappingURL=node-request-service.js.map

package/dist/service/node-run-event-bridge.d.ts

@@ -2,6 +2,7 @@ import type { NodeEnvelope, WorkbenchEventCategory } from '@myagentroam/protocol
 import type { FakeRunnerStatus } from '../fake-runner.js';
 import type { CodexRunner } from '../runner/codex-runner.js';
 import type { ClaudeCodeRunner } from '../runner/claude-code-runner.js';
+import type { OpenCodeRunner } from '../runner/opencode-runner.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { RunDomainState } from './run-domain-state.js';
 import type { RunEventService } from './run-event-service.js';
@@ -17,6 +18,7 @@ interface NodeRunEventBridgeOptions {
     readonly queues: WorkspaceQueueWorkbenchService<RunnerImageAttachment>;
     readonly codex: CodexRunner;
     readonly claude: ClaudeCodeRunner;
+    readonly openCode: OpenCodeRunner;
     readonly send: (type: string, payload: unknown, replyTo?: string) => void;
 }
 /** Bridges process-local Run state to normalized control and Workbench events. */

package/dist/service/node-run-event-bridge.js

@@ -62,6 +62,10 @@ export class NodeRunEventBridge {
                     marSessionId: nativeSessionId
                 });
         }
+        for (const [runId, managed] of this.options.openCode.execution) {
+            if (managed.sessionId === sessionId)
+                this.options.openCode.execution.set(runId, { ...managed, sessionId: nativeSessionId });
+        }
     }
     reconcile(envelope) {
         const payload = envelope.payload;
@@ -77,4 +81,3 @@ export class NodeRunEventBridge {
         this.options.send('ack', { type: 'runs.reconcile' }, envelope.id);
     }
 }
-//# sourceMappingURL=node-run-event-bridge.js.map

package/dist/service/node-terminal-channel.js

@@ -120,18 +120,25 @@ export class NodeTerminalChannel {
             }
             const parsed = terminalDataFrameSchema.safeParse(message.frame);
             const attachment = this.state.attachments.get(message.ticket);
-            if (!parsed.success ||
-                attachment === undefined ||
-                parsed.data.terminalId !== attachment.terminalId ||
-                !['input', 'resize', 'close'].includes(parsed.data.type)) {
+            if (!parsed.success || !['input', 'resize', 'close'].includes(parsed.data.type)) {
                 this.invalid();
                 return;
             }
-            void this.options.manager.acceptFrame(attachment.attachmentId, parsed.data).catch(() => this.sendFrame(message.ticket, {
-                type: 'error',
-                terminalId: attachment.terminalId,
-                code: 'TERMINAL_FRAME_REJECTED'
-            }));
+            if (attachment === undefined)
+                return;
+            if (parsed.data.terminalId !== attachment.terminalId) {
+                this.invalid();
+                return;
+            }
+            void this.options.manager.acceptFrame(attachment.attachmentId, parsed.data).catch(() => {
+                this.state.attachments.delete(message.ticket);
+                this.options.manager.detach(attachment.attachmentId);
+                this.sendFrame(message.ticket, {
+                    type: 'error',
+                    terminalId: attachment.terminalId,
+                    code: 'TERMINAL_FRAME_REJECTED'
+                });
+            });
             return;
         }
         if (message.type === 'shutdown' && Object.keys(message).length === 1) {
@@ -173,4 +180,3 @@ export class NodeTerminalChannel {
         this.state.attachments.clear();
     }
 }
-//# sourceMappingURL=node-terminal-channel.js.map

package/dist/service/node-upgrade-coordinator.d.ts

@@ -0,0 +1,29 @@
+import type { NodeUpgradeStatus } from '@myagentroam/protocol';
+export declare class NodeUpgradeCoordinator {
+    private readonly requestPath;
+    private readonly activeRunCount;
+    private readonly onStatus;
+    private readonly onReady;
+    private readonly now;
+    private status;
+    private timer;
+    constructor(requestPath: () => string, activeRunCount: () => number, onStatus: (status: NodeUpgradeStatus) => void, onReady: () => void, now?: () => number);
+    snapshot(): NodeUpgradeStatus;
+    loadResult(resultPath: string): Promise<void>;
+    request(data: unknown): {
+        status: 'ACCEPTED' | 'ALREADY_PENDING';
+        targetVersion: string;
+        activeRunCount: number;
+    };
+    cancel(): {
+        cancelled: true;
+    };
+    blocks(operation: string): boolean;
+    pending(): boolean;
+    stop(): void;
+    private checkReady;
+    private checkReadySafely;
+    private update;
+    private clearTimer;
+}
+export declare function nodeUpgradeRequestPath(databasePath: string): string;

package/dist/service/node-upgrade-coordinator.js

@@ -0,0 +1,137 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+export class NodeUpgradeCoordinator {
+    requestPath;
+    activeRunCount;
+    onStatus;
+    onReady;
+    now;
+    status = { state: 'IDLE', updatedAt: Date.now() };
+    timer;
+    constructor(requestPath, activeRunCount, onStatus, onReady, now = Date.now) {
+        this.requestPath = requestPath;
+        this.activeRunCount = activeRunCount;
+        this.onStatus = onStatus;
+        this.onReady = onReady;
+        this.now = now;
+    }
+    snapshot() {
+        return this.status;
+    }
+    async loadResult(resultPath) {
+        try {
+            const result = JSON.parse(await readFile(resultPath, 'utf8'));
+            if (result['state'] === 'FAILED' && typeof result['errorCode'] === 'string')
+                this.update({
+                    state: 'FAILED',
+                    errorCode: result['errorCode'],
+                    updatedAt: typeof result['updatedAt'] === 'number' ? result['updatedAt'] : this.now()
+                });
+        }
+        catch {
+            // Missing or malformed historical result does not prevent Node startup.
+        }
+    }
+    request(data) {
+        const targetVersion = record(data).targetVersion;
+        if (typeof targetVersion !== 'string' || !STABLE_VERSION.test(targetVersion))
+            throw new Error('NODE_UPGRADE_VERSION_INVALID');
+        if (this.status.state !== 'IDLE' && this.status.state !== 'FAILED') {
+            if (this.status.targetVersion !== targetVersion)
+                throw new Error('NODE_UPGRADE_ALREADY_PENDING');
+            return { status: 'ALREADY_PENDING', targetVersion, activeRunCount: this.activeRunCount() };
+        }
+        this.update({
+            state: 'WAITING_FOR_RUNS',
+            targetVersion,
+            activeRunCount: this.activeRunCount(),
+            updatedAt: this.now()
+        });
+        this.timer = setInterval(() => void this.checkReadySafely(), 250);
+        void this.checkReadySafely();
+        return { status: 'ACCEPTED', targetVersion, activeRunCount: this.activeRunCount() };
+    }
+    cancel() {
+        if (this.status.state !== 'WAITING_FOR_RUNS')
+            throw new Error('NODE_UPGRADE_NOT_CANCELLABLE');
+        this.clearTimer();
+        this.update({ state: 'IDLE', updatedAt: this.now() });
+        return { cancelled: true };
+    }
+    blocks(operation) {
+        return (this.pending() &&
+            (operation === 'session.start' ||
+                operation === 'session.resume' ||
+                operation === 'session.message' ||
+                operation === 'session.command.execute' ||
+                operation === 'runner.command.execute' ||
+                operation === 'session.channel.message' ||
+                operation === 'workspace.queue.message.execute' ||
+                operation === 'terminal.open'));
+    }
+    pending() {
+        return this.status.state === 'WAITING_FOR_RUNS' || this.status.state === 'READY_TO_RESTART';
+    }
+    stop() {
+        this.clearTimer();
+    }
+    async checkReady() {
+        if (this.status.state !== 'WAITING_FOR_RUNS')
+            return;
+        const activeRunCount = this.activeRunCount();
+        if (activeRunCount > 0) {
+            if (this.status.activeRunCount !== activeRunCount)
+                this.update({ ...this.status, activeRunCount, updatedAt: this.now() });
+            return;
+        }
+        this.clearTimer();
+        const targetVersion = this.status.targetVersion;
+        this.update({
+            state: 'READY_TO_RESTART',
+            targetVersion,
+            activeRunCount: 0,
+            updatedAt: this.now()
+        });
+        const path = this.requestPath();
+        const temporary = `${path}.${process.pid}.tmp`;
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        await writeFile(temporary, `${JSON.stringify({ schemaVersion: 1, targetVersion, createdAt: this.now() })}\n`, { mode: 0o600 });
+        await rename(temporary, path).catch(async (error) => {
+            await rm(temporary, { force: true });
+            throw error;
+        });
+        this.onReady();
+    }
+    async checkReadySafely() {
+        try {
+            await this.checkReady();
+        }
+        catch {
+            this.clearTimer();
+            this.update({
+                state: 'FAILED',
+                targetVersion: this.status.targetVersion,
+                errorCode: 'NODE_UPGRADE_REQUEST_WRITE_FAILED',
+                updatedAt: this.now()
+            });
+        }
+    }
+    update(status) {
+        this.status = status;
+        this.onStatus(status);
+    }
+    clearTimer() {
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+}
+export function nodeUpgradeRequestPath(databasePath) {
+    return resolve(dirname(databasePath), 'upgrade-request.json');
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('NODE_UPGRADE_REQUEST_INVALID');
+    return value;
+}

package/dist/service/node-workspace-coordinator.js

@@ -78,4 +78,3 @@ export class NodeWorkspaceCoordinator {
         }
     }
 }
-//# sourceMappingURL=node-workspace-coordinator.js.map

package/dist/service/run-attachment-service.js

@@ -158,4 +158,3 @@ export class RunAttachmentService {
         this.state.nativeHistoryImages.clear();
     }
 }
-//# sourceMappingURL=run-attachment-service.js.map

package/dist/service/run-domain-state.js

@@ -2,4 +2,3 @@ export class RunDomainState {
     active = new Set();
     interruptRequested = new Set();
 }
-//# sourceMappingURL=run-domain-state.js.map

package/dist/service/run-event-service.js

@@ -100,4 +100,3 @@ export class RunEventService {
         }
     }
 }
-//# sourceMappingURL=run-event-service.js.map

package/dist/service/run-workbench-service.js

@@ -111,4 +111,3 @@ export class RunWorkbenchService {
 function record(value) {
     return isPlainRecord(value) ? value : {};
 }
-//# sourceMappingURL=run-workbench-service.js.map

package/dist/service/runner-channel-message-service.js

@@ -18,4 +18,3 @@ export class RunnerChannelMessageService {
         this.options.send('ack', { type: envelope.type, delivery }, envelope.id);
     }
 }
-//# sourceMappingURL=runner-channel-message-service.js.map

package/dist/service/runner-interaction-service.js

@@ -166,6 +166,8 @@ export class RunnerInteractionService {
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
+        if (this.options.runners.respondUserInput(runId, requestId, rawAnswers))
+            return;
         if (this.options.codex().execution.userInputs.has(requestId)) {
             this.respondCodexUserInput(runId, requestId, rawAnswers);
             return;
@@ -242,4 +244,3 @@ export class RunnerInteractionService {
         });
     }
 }
-//# sourceMappingURL=runner-interaction-service.js.map

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

@@ -11,7 +11,7 @@ export declare class RunnerService {
     constructor(database: () => NodeDatabase, capabilities: () => NodeCapabilities, runners: RunnerRegistry, usage: RunnerUsageReader);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     profiles(): readonly {
-        runner: "codex" | "claude-code";
+        runner: "codex" | "claude-code" | "opencode";
         capabilities: string[];
         models: {
             id: string;
@@ -24,18 +24,19 @@ export declare class RunnerService {
             description: string;
         }[];
         commands: {
+            id: string;
             available: boolean;
-            runner: "codex" | "claude-code";
+            runner: "codex" | "claude-code" | "opencode";
             reasonCode: string | null;
-            id: string;
             label: string;
             description: string;
             inputHint: string;
-            source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK";
+            source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
             interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";
             stateLabel?: string | undefined;
         }[];
     }[];
+    private refreshProfiles;
     private usageStatuses;
     private readUsage;
     private listProfiles;

package/dist/service/runner-service.js

@@ -1,4 +1,5 @@
 import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
+import { parseSecretEnvironment } from '../util/secret-environment.js';
 export class RunnerService {
     database;
     capabilities;
@@ -14,30 +15,43 @@ export class RunnerService {
         return {
             'runner.usage.status': () => this.usageStatuses(),
             'runner.usage.read': (data) => this.readUsage(data),
-            'runner.profiles.list': () => this.listProfiles(),
+            'runner.profiles.list': (data) => this.listProfiles(data),
             'runner.defaults.save': (data) => this.saveDefaults(data)
         };
     }
     profiles() {
         return this.runners.profiles(this.capabilities());
     }
+    refreshProfiles(workspaceId, environment = {}) {
+        const workspace = workspaceId === undefined ? undefined : this.database().getWorkspace(workspaceId);
+        if (workspaceId !== undefined && workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return this.runners.refreshProfiles(this.capabilities(), workspace, environment);
+    }
     async usageStatuses() {
         return {
             statuses: await Promise.all(this.runners
                 .advertised()
-                .map((runner) => this.usage.status(runner.name)))
+                .flatMap((runner) => runner.name === 'codex' || runner.name === 'claude-code'
+                ? [this.usage.status(runner.name)]
+                : []))
         };
     }
     async readUsage(data) {
         const input = data;
         const runner = this.runners.product(input.runner);
-        if (runner === undefined)
+        if (runner === undefined || runner.name === 'opencode')
             throw new Error('RUNNER_USAGE_INVALID');
         return { usage: await this.usage.read(runner.name) };
     }
-    listProfiles() {
+    async listProfiles(data) {
+        const input = data;
+        const workspaceId = typeof input.workspaceId === 'string' && input.workspaceId.length > 0
+            ? input.workspaceId
+            : undefined;
+        const environment = parseSecretEnvironment(input.secretEnvironment);
         return {
-            profiles: this.profiles(),
+            profiles: await this.refreshProfiles(workspaceId, environment),
             defaults: this.database()
                 .getRunnerDefaults()
                 .filter((value) => this.runners.supportsConfiguration(value))
@@ -52,4 +66,3 @@ export class RunnerService {
         return { defaults: this.database().saveRunnerDefaults(parsed.data) };
     }
 }
-//# sourceMappingURL=runner-service.js.map

package/dist/service/session-catalog-service.d.ts

@@ -1,12 +1,14 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeAgentSession, NodeDatabase } from '../database.js';
+import type { NodeAgentSession, NodeConversationTurn, NodeDatabase } from '../database.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { ExternalSessionResumeService } from './external-session-resume-service.js';
 import type { NativeSessionProjectionService } from './native-session-projection-service.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
 interface SessionCatalogServiceOptions {
     readonly database: () => NodeDatabase;
     readonly nodeId: () => string;
     readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
     readonly projection: NativeSessionProjectionService;
     readonly resume: ExternalSessionResumeService;
     readonly cachedNative: () => readonly NodeAgentSession[];
@@ -17,14 +19,27 @@ interface SessionCatalogServiceOptions {
     readonly forget: (session: NodeAgentSession, nativeIds: ReadonlySet<string>) => void;
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly externalActivity: (sessionId: string) => unknown;
+    readonly history: (session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }) => Promise<{
+        readonly turns: readonly NodeConversationTurn[];
+        readonly nextCursor: string | null;
+    }>;
+    readonly emitSession: (session: NodeAgentSession) => void;
 }
 export declare class SessionCatalogService {
     private readonly options;
+    private rewindQueue;
     constructor(options: SessionCatalogServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
     private list;
     private mergePersisted;
     private resume;
+    private enqueueRewind;
+    private rewind;
+    private findTurn;
     private remove;
 }
+export declare function rewindTitle(sourceTitle: string, existingTitles?: readonly string[]): string;
 export {};