@myagentroam/node 0.9.3 → 0.9.4

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

@@ -51,6 +51,18 @@ export interface CodexRunConfiguration {
     readonly collaborationMode?: 'default' | 'plan';
     readonly mcpServers?: unknown;
 }
+interface CodexRpcErrorPayload {
+    readonly code?: unknown;
+    readonly message?: unknown;
+    readonly data?: unknown;
+}
+export declare class CodexAppServerRpcError extends Error {
+    readonly code: unknown;
+    readonly rpcMessage: string;
+    readonly data: unknown;
+    constructor(payload: CodexRpcErrorPayload);
+}
+export declare function isCodexRolloutMissingError(error: unknown): boolean;
 /** Public App Server turn inputs supported by the Workbench Composer. */
 export type CodexComposerInput = {
     readonly type: 'text';
@@ -71,15 +83,26 @@ export declare class CodexAppServerClient {
     private socketPath;
     private nextId;
     private readonly pending;
+    private readonly pendingDrainWaiters;
     private readonly notifications;
     private environment;
+    private starting;
+    private restarting;
+    private lifecycleRevision;
     constructor(options?: CodexAppServerOptions);
     configureEnvironment(environment: Readonly<Record<string, string>>): void;
     clearEnvironment(): void;
     start(): Promise<void>;
+    restart(): Promise<void>;
+    private startManaged;
+    private restartManaged;
     stop(): void;
+    private stopManaged;
     onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
     request(method: string, params: unknown): Promise<unknown>;
+    private requestDirect;
+    private waitForPendingRequests;
+    private resolvePendingDrain;
     notify(method: string, params: unknown): void;
     respond(requestId: string | number, result: unknown): void;
     startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
@@ -106,3 +129,4 @@ export declare class CodexAppServerClient {
 export declare function probeCodex(command?: string): CodexProbe;
 export declare function probeCodexAsync(command?: string): Promise<CodexProbe>;
 export declare function isSupportedCodexVersion(version: string): boolean;
+export {};

package/dist/codex-app-server.js

@@ -36,6 +36,25 @@ export function codexSessionControl(input) {
         capabilities: ['history.read', 'turn.start']
     };
 }
+export class CodexAppServerRpcError extends Error {
+    code;
+    rpcMessage;
+    data;
+    constructor(payload) {
+        const rpcMessage = typeof payload.message === 'string' ? payload.message : 'Codex App Server request failed';
+        super(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(payload)}`);
+        this.name = 'CodexAppServerRpcError';
+        this.code = payload.code;
+        this.rpcMessage = rpcMessage;
+        this.data = payload.data;
+    }
+}
+export function isCodexRolloutMissingError(error) {
+    return (error instanceof CodexAppServerRpcError &&
+        error.code === -32600 &&
+        (/^no rollout found for thread id\b/i.test(error.rpcMessage) ||
+            /^thread not loaded:\s*/i.test(error.rpcMessage)));
+}
 /**
  * Local JSON-RPC client for a Node-supervised Codex App Server. Linux uses a
  * private Unix socket by default; Windows uses stdio. Neither is exposed to
@@ -48,8 +67,12 @@ export class CodexAppServerClient {
     socketPath;
     nextId = 1;
     pending = new Map();
+    pendingDrainWaiters = new Set();
     notifications = new Set();
     environment = {};
+    starting;
+    restarting;
+    lifecycleRevision = 0;
     constructor(options = {}) {
         this.options = options;
     }
@@ -63,9 +86,35 @@ export class CodexAppServerClient {
             throw new Error('CODEX_APP_SERVER_ALREADY_STARTED');
         this.environment = {};
     }
-    async start() {
+    start() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        if (this.starting !== undefined)
+            return this.starting;
         if (this.child !== undefined)
-            return;
+            return Promise.resolve();
+        const starting = this.startManaged();
+        this.starting = starting;
+        const clearStarting = () => {
+            if (this.starting === starting)
+                this.starting = undefined;
+        };
+        void starting.then(clearStarting, clearStarting);
+        return starting;
+    }
+    restart() {
+        if (this.restarting !== undefined)
+            return this.restarting;
+        const restarting = this.restartManaged(this.lifecycleRevision);
+        this.restarting = restarting;
+        const clearRestarting = () => {
+            if (this.restarting === restarting)
+                this.restarting = undefined;
+        };
+        void restarting.then(clearRestarting, clearRestarting);
+        return restarting;
+    }
+    async startManaged() {
         const command = this.options.command ?? 'codex';
         const mode = this.transportMode();
         this.socketPath =
@@ -105,18 +154,39 @@ export class CodexAppServerClient {
         this.transport = socket ?? stdioTransport(child);
         const lines = createInterface({ input: socket ?? child.stdout });
         lines.on('line', (line) => this.handleLine(line));
-        child.once('error', (error) => this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`)));
+        const managedChild = child;
+        child.once('error', (error) => {
+            if (this.child !== managedChild)
+                return;
+            this.failAll(new Error(`CODEX_APP_SERVER_START_FAILED:${error.message}`));
+        });
         child.once('exit', () => {
+            if (this.child !== managedChild)
+                return;
             this.child = undefined;
             this.failAll(new Error('CODEX_APP_SERVER_EXITED'));
         });
-        await this.request('initialize', {
+        await this.requestDirect('initialize', {
             clientInfo: { name: 'codex_vscode', title: 'MyAgentRoam', version: '0.1.4' },
             capabilities: { experimentalApi: true }
         });
         this.notify('initialized', {});
     }
+    async restartManaged(lifecycleRevision) {
+        await Promise.resolve();
+        if (this.starting !== undefined)
+            await this.starting;
+        await this.waitForPendingRequests();
+        if (this.lifecycleRevision !== lifecycleRevision)
+            throw new Error('CODEX_APP_SERVER_STOPPED');
+        this.stopManaged();
+        await this.startManaged();
+    }
     stop() {
+        this.lifecycleRevision += 1;
+        this.stopManaged();
+    }
+    stopManaged() {
         this.transport?.destroy();
         this.transport = undefined;
         this.child?.kill();
@@ -131,6 +201,13 @@ export class CodexAppServerClient {
         return () => this.notifications.delete(listener);
     }
     async request(method, params) {
+        if (this.restarting !== undefined)
+            await this.restarting;
+        else if (this.starting !== undefined)
+            await this.starting;
+        return this.requestDirect(method, params);
+    }
+    requestDirect(method, params) {
         const transport = this.transport;
         if (transport === undefined || !transport.writable)
             throw new Error('CODEX_APP_SERVER_UNAVAILABLE');
@@ -139,6 +216,7 @@ export class CodexAppServerClient {
         const result = new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
+                this.resolvePendingDrain();
                 reject(new Error('CODEX_APP_SERVER_TIMEOUT'));
             }, timeoutMs);
             this.pending.set(id, { resolve, reject, timer });
@@ -146,6 +224,18 @@ export class CodexAppServerClient {
         transport.write(`${JSON.stringify({ method, id, params })}\n`);
         return result;
     }
+    waitForPendingRequests() {
+        if (this.pending.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.pendingDrainWaiters.add(resolve));
+    }
+    resolvePendingDrain() {
+        if (this.pending.size !== 0)
+            return;
+        for (const resolve of this.pendingDrainWaiters)
+            resolve();
+        this.pendingDrainWaiters.clear();
+    }
     notify(method, params) {
         const transport = this.transport;
         if (transport === undefined || !transport.writable)
@@ -233,8 +323,9 @@ export class CodexAppServerClient {
                 return;
             clearTimeout(pending.timer);
             this.pending.delete(message.id);
+            this.resolvePendingDrain();
             if (message.error !== undefined) {
-                pending.reject(new Error(`CODEX_APP_SERVER_RPC_ERROR:${JSON.stringify(message.error)}`));
+                pending.reject(new CodexAppServerRpcError(isRecord(message.error) ? message.error : { message: String(message.error) }));
             }
             else {
                 pending.resolve(message.result);
@@ -252,6 +343,7 @@ export class CodexAppServerClient {
             pending.reject(error);
             this.pending.delete(id);
         }
+        this.resolvePendingDrain();
     }
     transportMode() {
         const requested = this.options.transport ?? 'auto';
@@ -371,6 +463,9 @@ function defaultSpawn(command, args, options) {
         ...(options.env === undefined ? {} : { env: options.env })
     });
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function stdioTransport(child) {
     return {
         get writable() {

package/dist/connector.js

@@ -43,7 +43,7 @@ import { SessionQueryService } from './service/session-query-service.js';
 import { WorkspaceQueueWorkbenchService } from './service/workspace-queue-workbench-service.js';
 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 { ConversationHistoryService, convergeConversationWatchPage, 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';
@@ -197,9 +197,13 @@ export class NodeConnector {
         refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
         present: (session) => this.sessionPresentationService.present(session),
         readPage: (session, limit) => this.conversationHistoryService.read(session, { limit }),
+        convergePage: convergeConversationWatchPage,
         projectInitialPage: (session, page, _unit, limit) => this.conversationSegmentService.projectInitial(session, page, limit),
         emitSession: (session) => this.emitWorkbenchEvent('session', { session }),
-        emitTurn: (turn) => this.emitConversationTurn(turn)
+        emitPage: (session, page) => this.emitWorkbenchEvent('conversation', {
+            sessionId: session.id,
+            snapshot: this.conversationSegmentService.projectInitial(session, page, 10)
+        })
     });
     constructor(options = {}) {
         this.config = options.config;

package/dist/database.d.ts

@@ -67,6 +67,8 @@ export interface NodeAgentRun {
     readonly recoveryState: RunRecoveryState;
     readonly version: number;
     readonly clientMessageId: string;
+    /** Server-authenticated user that submitted this Run. Internal lifecycle metadata only. */
+    readonly initiatedByUserId?: number;
     readonly createdAt: number;
     readonly updatedAt: number;
 }

package/dist/runner/codex/managed-run-controller.d.ts

@@ -6,6 +6,15 @@ import { CodexRunner } from '../codex-runner.js';
 type CodexImageInput = Extract<CodexComposerInput, {
     readonly type: 'localImage';
 }>;
+interface CodexNotificationRun {
+    readonly threadId: string;
+    readonly turnId?: string;
+}
+export declare function resolveCodexNotificationRun<T extends CodexNotificationRun>(runs: ReadonlyMap<string, T>, input: {
+    readonly threadId?: string;
+    readonly turnId?: string;
+    readonly allowUnboundFallback?: boolean;
+}): readonly [string, T] | undefined;
 export interface CodexManagedRunHost<TAttachment> {
     readonly available: () => boolean;
     readonly intercepted: () => boolean;

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

@@ -3,6 +3,25 @@ import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+export function resolveCodexNotificationRun(runs, input) {
+    const entries = [...runs.entries()];
+    if (input.turnId !== undefined) {
+        const exact = entries.find(([, value]) => value.turnId === input.turnId &&
+            (input.threadId === undefined || value.threadId === input.threadId));
+        if (exact !== undefined)
+            return exact;
+        if (input.allowUnboundFallback !== true)
+            return undefined;
+        // `turn/started` can arrive before the `turn/start` response binds its native Turn ID. Only
+        // an unbound Run on the same thread is a valid fallback; an older bound Run is never valid.
+        return entries
+            .reverse()
+            .find(([, value]) => value.threadId === input.threadId && value.turnId === undefined);
+    }
+    if (input.threadId === undefined)
+        return undefined;
+    return entries.reverse().find(([, value]) => value.threadId === input.threadId);
+}
 export class CodexManagedRunController {
     runner;
     host;
@@ -104,8 +123,11 @@ export class CodexManagedRunController {
         const threadId = typeof params.threadId === 'string' ? params.threadId : undefined;
         if (turnId === undefined && threadId === undefined)
             return;
-        const run = [...this.runner.execution.runs.entries()].find(([, value]) => (turnId !== undefined && value.turnId === turnId) ||
-            (threadId !== undefined && value.threadId === threadId));
+        const run = resolveCodexNotificationRun(this.runner.execution.runs, {
+            ...(turnId === undefined ? {} : { turnId }),
+            ...(threadId === undefined ? {} : { threadId }),
+            ...(notification.method === 'turn/started' ? { allowUnboundFallback: true } : {})
+        });
         if (run === undefined)
             return;
         const [runId] = run;
@@ -350,28 +372,46 @@ export class CodexManagedRunController {
                 ...(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)
-                : await this.runner.startThread(cwd, configuration);
-            if (this.host.completeCancelled(runId, cwd)) {
-                this.runner.releaseEnvironment(runId);
-                return;
+            const collaborationMode = payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
+                ? payload.collaborationMode
+                : undefined;
+            const turnConfiguration = {
+                ...configuration,
+                ...(collaborationMode === undefined ? {} : { collaborationMode }),
+                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
+            };
+            const materializedAttachments = await this.host.materialize(runId, attachments);
+            let threadId;
+            let turnResult;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                try {
+                    const threadResult = typeof payload.externalSessionId === 'string'
+                        ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
+                        : await this.runner.startThread(cwd, configuration);
+                    if (this.host.completeCancelled(runId, cwd)) {
+                        this.runner.releaseEnvironment(runId);
+                        return;
+                    }
+                    threadId = extractId(threadResult, 'thread');
+                    this.runner.execution.runs.set(runId, { sessionId, threadId, cwd });
+                    turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments);
+                    break;
+                }
+                catch (error) {
+                    this.runner.execution.runs.delete(runId);
+                    if (attempt === 0 && (await this.runner.recoverMissingRollout(runId, error)))
+                        continue;
+                    throw error;
+                }
             }
-            const threadId = extractId(threadResult, 'thread');
+            if (threadId === undefined || turnResult === undefined)
+                throw new Error('CODEX_RUN_FAILED');
             let publicSessionId = sessionId;
             if (typeof payload.externalSessionId !== 'string') {
                 this.host.promoteSession(sessionId, threadId);
                 publicSessionId = threadId;
                 this.host.send('session.external-id', { sessionId, externalSessionId: threadId });
             }
-            this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, cwd });
-            const turnResult = await this.runner.startTurn(threadId, input, cwd, {
-                ...configuration,
-                ...(payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
-                    ? { collaborationMode: payload.collaborationMode }
-                    : {}),
-                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
-            }, await this.host.materialize(runId, attachments));
             const turnId = extractId(turnResult, 'turn');
             this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, turnId, cwd });
             this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });

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

@@ -58,6 +58,7 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
     start(): Promise<void>;
+    recoverMissingRollout(runId: string, error: unknown): Promise<boolean>;
     prepareEnvironment(environment: Readonly<Record<string, string>>, runId: string): void;
     releaseEnvironment(runId: string): void;
     stop(): void;

package/dist/runner/codex-runner.js

@@ -1,4 +1,4 @@
-import { CodexAppServerClient } from '../codex-app-server.js';
+import { CodexAppServerClient, isCodexRolloutMissingError } from '../codex-app-server.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
@@ -451,6 +451,17 @@ export class CodexRunner extends AbstractRunner {
     start() {
         return this.client.start();
     }
+    async recoverMissingRollout(runId, error) {
+        if (!isCodexRolloutMissingError(error))
+            return false;
+        if ([...this.environmentRuns].some((activeRunId) => activeRunId !== runId))
+            return false;
+        if ([...this.execution.runs.keys()].some((activeRunId) => activeRunId !== runId))
+            return false;
+        nodeLog('runner.codex.rollout.recovering', { runId });
+        await this.client.restart();
+        return true;
+    }
     prepareEnvironment(environment, runId) {
         if (Object.keys(environment).length === 0 && this.environmentFingerprint === undefined) {
             this.environmentRuns.add(runId);

package/dist/runtime-state.d.ts

@@ -86,9 +86,11 @@ export declare class NodeRuntimeState {
      */
     setRunnerTitleFromNative(id: string, title: string): NodeAgentSession;
     createMessageRun(input: {
+        readonly runId?: string;
         readonly sessionId: string;
         readonly clientMessageId: string;
         readonly content: string;
+        readonly initiatedByUserId?: number;
         readonly attachments?: readonly NodeMessageAttachmentInput[];
     }): {
         readonly run: NodeAgentRun;

package/dist/runtime-state.js

@@ -255,7 +255,7 @@ export class NodeRuntimeState {
         const session = this.requireSession(input.sessionId);
         const now = this.now();
         const run = {
-            id: randomUUID(),
+            id: input.runId ?? randomUUID(),
             sessionId: session.id,
             nodeId: this.nodeId(),
             workspaceId: session.workspaceId,
@@ -264,6 +264,9 @@ export class NodeRuntimeState {
             recoveryState: 'ACTIVE',
             version: 0,
             clientMessageId: input.clientMessageId,
+            ...(input.initiatedByUserId === undefined
+                ? {}
+                : { initiatedByUserId: input.initiatedByUserId }),
             createdAt: now,
             updatedAt: now
         };
@@ -471,15 +474,16 @@ export class NodeRuntimeState {
     }
     listConversationTurns(input) {
         this.requireSession(input.sessionId);
-        // Queued turns have not received `run.started` yet. Their user item still
-        // has the acceptance timestamp, so use it rather than sorting every
-        // queued turn as time zero. The insertion index makes same-millisecond
-        // sends deterministic; callers receive every page from oldest to newest.
+        // A managed Turn keeps the user's acceptance time as its stable timeline
+        // position. Runner start/completion timestamps must not move it behind a
+        // message that was accepted later. Native Turns without a user timestamp
+        // fall back to their own lifecycle time.
         const all = [...(this.turns.get(input.sessionId) ?? [])]
             .map((turn, index) => ({ turn, index }))
             .sort((a, b) => {
-            const timestamp = (value) => value.startedAt ??
-                value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+            const timestamp = (value) => value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+                value.startedAt ??
+                value.completedAt ??
                 0;
             return timestamp(a.turn) - timestamp(b.turn) || a.index - b.index;
         })

package/dist/service/conversation-history-service.d.ts

@@ -5,6 +5,10 @@ import type { RunnerRegistry } from '../runner/runner-registry.js';
 import { type ConversationHistoryPage } from '../util/runner-native-session-parsers.js';
 import type { RunAttachmentService } from './run-attachment-service.js';
 export declare function hasManagedActiveRun(runtime: NodeRuntimeState, session: NodeAgentSession): boolean;
+export declare function convergeConversationWatchPage(previous: ConversationHistoryPage | undefined, previousObserved: ConversationHistoryPage | undefined, next: ConversationHistoryPage, previousAuthority: unknown): {
+    readonly page: ConversationHistoryPage;
+    readonly authority: ConversationHistoryPage['source'];
+};
 interface ConversationHistoryServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly runners: RunnerRegistry;
@@ -16,11 +20,15 @@ interface ConversationHistoryServiceOptions {
 }
 export declare class ConversationHistoryService {
     private readonly options;
+    private readonly activeOfficialReads;
     constructor(options: ConversationHistoryServiceOptions);
     read(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
     }): Promise<ConversationHistoryPage>;
+    private readManagedActive;
+    private prefetchActiveOfficial;
+    private takeActiveOfficialRead;
     refreshExternalActivity(session: NodeAgentSession): Promise<void>;
     readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
     private attachNativeImages;