remote-codex 0.11.51 → 0.11.53

package/apps/supervisor-web/dist/index.html

@@ -10,13 +10,13 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
     <link rel="manifest" href="/site.webmanifest" />
     <title>Remote Codex</title>
-    <script type="module" crossorigin src="/assets/index-7LiZQ3aJ.js"></script>
+    <script type="module" crossorigin src="/assets/index-Bnury8uP.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-Dfg_6BLf.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CuR8GHb0.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVQUpZ8C.js">
     <link rel="modulepreload" crossorigin href="/assets/terminal-vendor-C5bTa-Ka.js">
     <link rel="modulepreload" crossorigin href="/assets/markdown-vendor-BG6PurxI.js">
-    <link rel="modulepreload" crossorigin href="/assets/thread-ui-BbtcUwps.js">
+    <link rel="modulepreload" crossorigin href="/assets/thread-ui-C5pxOmDJ.js">
     <link rel="stylesheet" crossorigin href="/assets/graph-vendor-C5ap-Sga.css">
     <link rel="stylesheet" crossorigin href="/assets/terminal-vendor-Beg8tuEN.css">
     <link rel="stylesheet" crossorigin href="/assets/index-Bg8FdhS1.css">

package/bin/remote-codex.mjs

@@ -238,7 +238,7 @@ async function runRelaySupervisor() {
     return;
   }
   if (action === 'start' && shouldStartRelaySupervisorInTmux()) {
-    startRelaySupervisorTmux();
+    await startRelaySupervisorTmux();
     return;
   }
   runRelaySupervisorForeground();
@@ -677,7 +677,7 @@ function shouldStartRelaySupervisorInTmux() {
   return commandExists('tmux');
 }
 
-function startRelaySupervisorTmux() {
+async function startRelaySupervisorTmux() {
   persistRelaySupervisorRuntimeConfig();
   if (tmuxSessionExists(relaySupervisorTmuxSession)) {
     console.log(`remote-codex relay-supervisor is already running in tmux session: ${relaySupervisorTmuxSession}`);
@@ -702,6 +702,17 @@ function startRelaySupervisorTmux() {
     return;
   }
 
+  const startupDeadline = Date.now() + 1_000;
+  while (Date.now() < startupDeadline) {
+    if (!tmuxSessionExists(relaySupervisorTmuxSession)) {
+      console.error('relay-supervisor exited immediately after tmux launched it.');
+      console.error('Restarting in foreground to show the startup error.');
+      runRelaySupervisorForeground();
+      return;
+    }
+    await sleep(100);
+  }
+
   console.log(`Started remote-codex relay-supervisor in tmux session: ${relaySupervisorTmuxSession}`);
   printRelaySupervisorTmuxCommands();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.51",
+  "version": "0.11.53",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

package/packages/acp/src/runtimeAdapter.test.ts

@@ -471,7 +471,7 @@ describe('AcpRuntimeAdapter', () => {
       env: {
         REMOTE_CODEX_FAKE_ACP_AGENT_KIND: 'codex',
         REMOTE_CODEX_FAKE_ACP_SKIP_PERMISSION: '1',
-        REMOTE_CODEX_FAKE_ACP_STREAM_DELAY_MS: '100',
+        REMOTE_CODEX_FAKE_ACP_STREAM_DELAY_MS: '1000',
       },
       startupTimeoutMs: 5_000,
     });
@@ -500,10 +500,23 @@ describe('AcpRuntimeAdapter', () => {
         });
       },
     );
+    const partialStarted = new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Steerable fixture partial timed out.')), 10_000);
+      const onEvent = (event: AgentRuntimeEvent) => {
+        if (event.type !== 'output.delta' || !event.delta.includes('FAKE_ACP_PARTIAL')) {
+          return;
+        }
+        clearTimeout(timer);
+        adapter.off('event', onEvent);
+        resolve();
+      };
+      adapter.on('event', onEvent);
+    });
     const running = await adapter.startTurn({
       providerSessionId: session.providerSessionId,
       prompt: 'Start a steerable fixture turn.',
     });
+    await partialStarted;
     await expect(adapter.sendInput({
       providerSessionId: session.providerSessionId,
       providerTurnId: running.providerTurnId,

package/packages/codex/src/appServerManager.test.ts

@@ -315,7 +315,7 @@ describe('CodexAppServerManager', () => {
 
     const manager = new CodexAppServerManager({
       command: process.execPath,
-      startupTimeoutMs: 1000,
+      startupTimeoutMs: 5_000,
       clientInfo: {
         name: 'test',
         title: 'test',
@@ -388,7 +388,7 @@ describe('CodexAppServerManager', () => {
     ]);
 
     await manager.stop();
-  });
+  }, 15_000);
 
   it('does not let a stale child exit close the replacement app-server client during restart', async () => {
     const firstChild = new ScriptedChild({

package/packages/codex/src/historyItems.test.ts

@@ -102,6 +102,11 @@ describe('codex history item persistence policy', () => {
           text: 'done',
           completedAt: '2026-06-13T22:00:08.456Z',
         },
+        {
+          id: 'msg_019d70d5-9dc8-7000-8000-000000000000',
+          type: 'agentMessage',
+          text: 'inferred from id',
+        },
       ],
     });
 
@@ -114,6 +119,10 @@ describe('codex history item persistence policy', () => {
         id: 'agent-1',
         createdAt: '2026-06-13T22:00:08.456Z',
       },
+      {
+        id: 'msg_019d70d5-9dc8-7000-8000-000000000000',
+        createdAt: '2026-04-09T06:02:21.000Z',
+      },
     ]);
   });
 

package/packages/codex/src/historyItems.ts

@@ -25,17 +25,29 @@ interface WebSearchSourceRecord {
 }
 
 export function parseUuidV7Timestamp(id: string): string | null {
-  const normalized = id.replace(/-/g, '');
-  if (!/^[0-9a-f]{32}$/i.test(normalized) || normalized[12]?.toLowerCase() !== '7') {
-    return null;
-  }
+  const candidates = [
+    id,
+    ...(id.match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32}/gi,
+    ) ?? []),
+  ];
 
-  const millis = Number.parseInt(normalized.slice(0, 12), 16);
-  if (!Number.isFinite(millis)) {
-    return null;
+  for (const candidate of candidates) {
+    const normalized = candidate.replace(/-/g, '');
+    if (
+      !/^[0-9a-f]{32}$/i.test(normalized) ||
+      normalized[12]?.toLowerCase() !== '7'
+    ) {
+      continue;
+    }
+
+    const millis = Number.parseInt(normalized.slice(0, 12), 16);
+    if (Number.isFinite(millis)) {
+      return new Date(millis).toISOString();
+    }
   }
 
-  return new Date(millis).toISOString();
+  return null;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/packages/codex/src/local-session-store.test.ts

@@ -0,0 +1,455 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { LocalCodexSessionStore } from './local-session-store';
+
+describe('LocalCodexSessionStore', () => {
+  const tempDirectories: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tempDirectories.splice(0).map((directory) =>
+        fs.rm(directory, { recursive: true, force: true }),
+      ),
+    );
+  });
+
+  it('recovers current response-item rollouts when the state database is corrupt', async () => {
+    const codexHome = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex-local-session-'),
+    );
+    tempDirectories.push(codexHome);
+    const sessionId = '01a059bf-c303-79b1-8802-f922d3a81968';
+    const workspacePath = path.join(codexHome, 'workspace');
+    const sessionsDirectory = path.join(codexHome, 'sessions', '2026', '08', '31');
+    await fs.mkdir(sessionsDirectory, { recursive: true });
+    await fs.writeFile(
+      path.join(codexHome, 'state_5.sqlite'),
+      'this is not a valid sqlite database',
+    );
+    await fs.writeFile(
+      path.join(sessionsDirectory, `rollout-${sessionId}.jsonl`),
+      [
+        {
+          timestamp: '2026-08-31T21:36:17.000Z',
+          type: 'session_meta',
+          payload: { id: sessionId, cwd: workspacePath },
+        },
+        {
+          timestamp: '2026-08-31T21:36:18.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_started', turn_id: 'turn-1' },
+        },
+        {
+          timestamp: '2026-08-31T21:36:19.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'message-user-1',
+            type: 'message',
+            role: 'user',
+            content: [
+              { type: 'input_text', text: 'Recover this session.' },
+              { type: 'input_image', image_url: 'data:image/png;base64,ignored' },
+            ],
+          },
+        },
+        {
+          timestamp: '2026-08-31T21:36:24.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'message-agent-1',
+            type: 'message',
+            role: 'assistant',
+            phase: 'final_answer',
+            content: [{ type: 'output_text', text: 'Recovered.' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T21:36:25.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_complete', turn_id: 'turn-1' },
+        },
+      ]
+        .map((entry) => JSON.stringify(entry))
+        .join('\n'),
+    );
+
+    const session = await new LocalCodexSessionStore(codexHome).findSession(
+      sessionId,
+    );
+
+    expect(session).toMatchObject({
+      sessionId,
+      cwd: workspacePath,
+      title: 'Recover this se...',
+      turns: [
+        {
+          id: 'turn-1',
+          startedAt: '2026-08-31T21:36:18.000Z',
+          status: 'completed',
+          items: [
+            {
+              id: 'message-user-1',
+              kind: 'userMessage',
+              text: 'Recover this session.',
+              createdAt: '2026-08-31T21:36:19.000Z',
+            },
+            {
+              id: 'message-agent-1',
+              kind: 'agentMessage',
+              text: 'Recovered.',
+              createdAt: '2026-08-31T21:36:24.000Z',
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('parses legacy and response-item turns from a session that spans upgrades', async () => {
+    const codexHome = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex-mixed-session-'),
+    );
+    tempDirectories.push(codexHome);
+    const sessionId = '01a059bf-c303-79b1-8802-f922d3a81969';
+    const workspacePath = path.join(codexHome, 'workspace');
+    const sessionsDirectory = path.join(codexHome, 'sessions');
+    await fs.mkdir(sessionsDirectory, { recursive: true });
+    await fs.writeFile(
+      path.join(sessionsDirectory, `rollout-${sessionId}.jsonl`),
+      [
+        {
+          timestamp: '2026-08-30T00:00:00.000Z',
+          type: 'session_meta',
+          payload: { id: sessionId, cwd: workspacePath },
+        },
+        {
+          timestamp: '2026-08-30T00:00:01.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_started', turn_id: 'legacy-turn' },
+        },
+        {
+          timestamp: '2026-08-30T00:00:02.000Z',
+          type: 'event_msg',
+          payload: { type: 'user_message', message: 'Legacy prompt' },
+        },
+        {
+          timestamp: '2026-08-30T00:00:03.000Z',
+          type: 'event_msg',
+          payload: { type: 'agent_message', message: 'Legacy reply' },
+        },
+        {
+          timestamp: '2026-08-30T00:00:04.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_complete' },
+        },
+        {
+          timestamp: '2026-08-31T00:00:01.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_started', turn_id: 'modern-turn' },
+        },
+        {
+          timestamp: '2026-08-31T00:00:02.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'modern-user',
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: 'Modern prompt' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:00:03.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'modern-agent',
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'Modern reply' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:00:04.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_complete' },
+        },
+      ]
+        .map((entry) => JSON.stringify(entry))
+        .join('\n'),
+    );
+
+    const session = await new LocalCodexSessionStore(codexHome).findSession(
+      sessionId,
+    );
+
+    expect(session?.turns.map((turn) => turn.items.map((item) => item.text))).toEqual([
+      ['Legacy prompt', 'Legacy reply'],
+      ['Modern prompt', 'Modern reply'],
+    ]);
+  });
+
+  it('merges complete paginated tool history with newer rollout-only turns', async () => {
+    const codexHome = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex-paginated-session-'),
+    );
+    tempDirectories.push(codexHome);
+    const sessionId = '01a059bf-c303-79b1-8802-f922d3a81970';
+    const workspacePath = path.join(codexHome, 'workspace');
+    const sessionsDirectory = path.join(codexHome, 'sessions');
+    await fs.mkdir(sessionsDirectory, { recursive: true });
+    await fs.writeFile(
+      path.join(sessionsDirectory, `rollout-${sessionId}.jsonl`),
+      [
+        {
+          timestamp: '2026-08-31T00:00:00.000Z',
+          type: 'session_meta',
+          payload: { id: sessionId, cwd: workspacePath },
+        },
+        {
+          timestamp: '2026-08-31T00:00:01.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_started', turn_id: 'turn-rich' },
+        },
+        {
+          timestamp: '2026-08-31T00:00:02.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'user-rich',
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: 'Inspect.' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:00:03.500Z',
+          type: 'response_item',
+          payload: {
+            id: 'agent-commentary',
+            type: 'message',
+            role: 'assistant',
+            phase: 'commentary',
+            content: [{ type: 'output_text', text: 'Running checks.' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:00:05.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'agent-rich',
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'Done.' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:00:06.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_complete' },
+        },
+        {
+          timestamp: '2026-08-31T00:01:00.000Z',
+          type: 'event_msg',
+          payload: { type: 'task_started', turn_id: 'turn-new' },
+        },
+        {
+          timestamp: '2026-08-31T00:01:01.000Z',
+          type: 'response_item',
+          payload: {
+            id: 'user-new',
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: 'Continue.' }],
+          },
+        },
+        {
+          timestamp: '2026-08-31T00:01:02.000Z',
+          type: 'event_msg',
+          payload: {
+            type: 'item_completed',
+            turn_id: 'turn-new',
+            started_at_ms: 1_788_134_462_000,
+            item: {
+              id: 'command-new',
+              type: 'CommandExecution',
+              command: 'git status --short',
+              aggregated_output: '',
+              status: 'completed',
+              exit_code: 0,
+            },
+          },
+        },
+      ].map((entry) => JSON.stringify(entry)).join('\n'),
+    );
+
+    const sqlite = new Database(path.join(codexHome, 'thread_history_1.sqlite'));
+    sqlite.exec(`
+      CREATE TABLE thread_turns (
+        thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        rollout_ordinal INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        error_json TEXT,
+        started_at INTEGER,
+        PRIMARY KEY (thread_id, turn_id)
+      );
+      CREATE TABLE thread_items (
+        thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        item_id TEXT NOT NULL,
+        rollout_ordinal INTEGER NOT NULL,
+        created_at_ms INTEGER NOT NULL,
+        item_type TEXT NOT NULL,
+        item_json TEXT NOT NULL,
+        PRIMARY KEY (thread_id, turn_id, item_id)
+      );
+    `);
+    sqlite.prepare(
+      'INSERT INTO thread_turns VALUES (?, ?, ?, ?, ?, ?)',
+    ).run(sessionId, 'turn-rich', 1, 'completed', null, 1_788_134_401);
+    const insertItem = sqlite.prepare(
+      'INSERT INTO thread_items VALUES (?, ?, ?, ?, ?, ?, ?)',
+    );
+    const rawItems = [
+      {
+        ordinal: 2,
+        createdAtMs: 1_788_134_402_000,
+        type: 'userMessage',
+        item: {
+          id: 'user-rich',
+          type: 'userMessage',
+          content: [{ type: 'text', text: 'Inspect.' }],
+        },
+      },
+      {
+        ordinal: 3,
+        createdAtMs: 1_788_134_403_000,
+        type: 'reasoning',
+        item: {
+          id: 'reason-rich',
+          type: 'reasoning',
+          summary: ['Checking the workspace.'],
+        },
+      },
+      {
+        ordinal: 4,
+        createdAtMs: 1_788_134_404_000,
+        type: 'commandExecution',
+        item: {
+          id: 'command-rich',
+          type: 'commandExecution',
+          command: 'pwd',
+          aggregatedOutput: workspacePath,
+          status: 'completed',
+          exitCode: 0,
+        },
+      },
+      {
+        ordinal: 5,
+        createdAtMs: 1_788_134_405_000,
+        type: 'agentMessage',
+        item: {
+          id: 'agent-rich',
+          type: 'agentMessage',
+          text: 'Done.',
+        },
+      },
+    ];
+    for (const raw of rawItems) {
+      insertItem.run(
+        sessionId,
+        'turn-rich',
+        raw.item.id,
+        raw.ordinal,
+        raw.createdAtMs,
+        raw.type,
+        JSON.stringify(raw.item),
+      );
+    }
+    sqlite.close();
+
+    const session = await new LocalCodexSessionStore(codexHome).findSession(
+      sessionId,
+    );
+
+    expect(session?.turns).toHaveLength(2);
+    expect(session?.turns[0]).toMatchObject({
+      id: 'turn-rich',
+      status: 'completed',
+      items: [
+        { id: 'user-rich', kind: 'userMessage' },
+        { id: 'reason-rich', kind: 'reasoning' },
+        { id: 'agent-commentary', kind: 'agentMessage' },
+        { id: 'command-rich', kind: 'commandExecution' },
+        { id: 'agent-rich', kind: 'agentMessage' },
+      ],
+    });
+    expect(session?.turns[1]).toMatchObject({
+      id: 'turn-new',
+      status: 'inProgress',
+      items: [
+        { id: 'user-new', kind: 'userMessage' },
+        { id: 'command-new', kind: 'commandExecution' },
+      ],
+    });
+  });
+
+  it('watches rollout changes for externally running imported sessions', async () => {
+    const codexHome = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'remote-codex-watched-session-'),
+    );
+    tempDirectories.push(codexHome);
+    const sessionId = '01a059bf-c303-79b1-8802-f922d3a81971';
+    const sessionsDirectory = path.join(codexHome, 'sessions');
+    const transcriptPath = path.join(
+      sessionsDirectory,
+      `rollout-${sessionId}.jsonl`,
+    );
+    await fs.mkdir(sessionsDirectory, { recursive: true });
+    await fs.writeFile(
+      transcriptPath,
+      `${JSON.stringify({
+        timestamp: '2026-08-31T00:00:00.000Z',
+        type: 'session_meta',
+        payload: { id: sessionId, cwd: codexHome },
+      })}\n`,
+    );
+    const store = new LocalCodexSessionStore(codexHome, {
+      watchIntervalMs: 20,
+      watchThrottleMs: 25,
+    });
+    let changes = 0;
+    let resolveChange: (() => void) | null = null;
+    const changed = new Promise<void>((resolve) => {
+      resolveChange = resolve;
+    });
+    const stop = await store.watchSession(sessionId, () => {
+      changes += 1;
+      resolveChange?.();
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 40));
+    await fs.appendFile(
+      transcriptPath,
+      `${JSON.stringify({
+        timestamp: '2026-08-31T00:00:01.000Z',
+        type: 'event_msg',
+        payload: { type: 'task_started', turn_id: 'turn-1' },
+      })}\n`,
+    );
+    await Promise.race([
+      changed,
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('watcher timed out')), 2_000),
+      ),
+    ]);
+
+    stop();
+    await fs.appendFile(transcriptPath, '{}\n');
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(changes).toBe(1);
+  });
+});