remote-codex 0.11.10 → 0.11.12

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

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Remote Codex Supervisor</title>
-    <script type="module" crossorigin src="/assets/index-M5xKhovw.js"></script>
+    <script type="module" crossorigin src="/assets/index-Dsq8QmDr.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-vendor-CgLzZcV4.js">
     <link rel="modulepreload" crossorigin href="/assets/ui-vendor-CeKGesq3.js">
     <link rel="modulepreload" crossorigin href="/assets/graph-vendor-DVPtkh3h.js">

package/package.json

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

package/packages/agent-runtime/src/types.ts

@@ -269,6 +269,7 @@ export interface SendAgentInputInput {
   providerSessionId: string;
   providerTurnId: string;
   prompt: string;
+  workspacePath?: string | null;
 }
 
 export interface InterruptAgentTurnInput {

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

@@ -197,6 +197,58 @@ describe('CodexAppServerManager', () => {
     await manager.stop();
   });
 
+  it('forwards structured image input when starting a turn', async () => {
+    const expectedInput = [
+      { type: 'text', text: 'Inspect this ', text_elements: [] },
+      { type: 'localImage', path: '/tmp/workspace/photo.png' },
+      { type: 'text', text: ' and summarize.', text_elements: [] },
+    ];
+    const script = [
+      "const readline=require('node:readline');",
+      "const rl=readline.createInterface({input:process.stdin,crlfDelay:Infinity});",
+      `const expectedInput=${JSON.stringify(expectedInput)};`,
+      "rl.on('line',(line)=>{",
+      " const msg=JSON.parse(line);",
+      " if(msg.method==='initialize'){",
+      "  process.stdout.write(JSON.stringify({id:msg.id,result:{userAgent:'fake',codexHome:'/tmp',platformFamily:'unix',platformOs:'linux'}})+'\\n');",
+      " } else if(msg.method==='turn/start'){",
+      "  if(JSON.stringify(msg.params?.input)===JSON.stringify(expectedInput)){",
+      "   process.stdout.write(JSON.stringify({id:msg.id,result:{turn:{id:'turn-1',status:'completed',items:[]}}})+'\\n');",
+      "  } else {",
+      "   process.stdout.write(JSON.stringify({id:msg.id,error:{code:-32600,message:'bad start input',data:msg.params}})+'\\n');",
+      "  }",
+      " }",
+      "});"
+    ].join('');
+
+    const manager = new CodexAppServerManager({
+      command: process.execPath,
+      startupTimeoutMs: 1000,
+      clientInfo: {
+        name: 'test',
+        title: 'test',
+        version: '0.1.0'
+      },
+      spawnProcess: (command) => {
+        return spawn(command, ['-e', script], { stdio: 'pipe' });
+      }
+    });
+
+    await manager.start();
+    const turn = await manager.startTurn({
+      threadId: 'thread-1',
+      prompt: 'Inspect this [PHOTO photo.png] and summarize.',
+      input: expectedInput,
+    });
+
+    expect(turn).toMatchObject({
+      id: 'turn-1',
+      status: 'completed',
+    });
+
+    await manager.stop();
+  });
+
   it('writes hook trust state through config batch writes', async () => {
     const requests: any[] = [];
     const script = [

package/packages/codex/src/appServerManager.ts

@@ -72,6 +72,16 @@ function mapTurn(record: any): CodexTurnRecord {
   };
 }
 
+function textOnlyUserInput(prompt: string): NonNullable<TurnStartInput['input']> {
+  return [
+    {
+      type: 'text',
+      text: prompt,
+      text_elements: []
+    }
+  ];
+}
+
 function mapModel(record: any): CodexModelRecord {
   return {
     id: record.id,
@@ -452,13 +462,7 @@ export class CodexAppServerManager extends EventEmitter {
     await this.ensureReady();
     const response = await this.client!.request<{ turn: any }>('turn/start', {
       threadId: input.threadId,
-      input: [
-        {
-          type: 'text',
-          text: input.prompt,
-          text_elements: []
-        }
-      ],
+      input: input.input ?? textOnlyUserInput(input.prompt),
       model: input.model ?? null,
       serviceTier:
         input.serviceTier === undefined ? undefined : input.serviceTier,
@@ -483,13 +487,7 @@ export class CodexAppServerManager extends EventEmitter {
     const response = await this.client!.request<{ turn?: any }>('turn/steer', {
       threadId: input.threadId,
       expectedTurnId: input.turnId,
-      input: [
-        {
-          type: 'text',
-          text: input.prompt,
-          text_elements: []
-        }
-      ]
+      input: input.input ?? textOnlyUserInput(input.prompt)
     });
     return response.turn ? mapTurn(response.turn) : null;
   }

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

@@ -84,6 +84,39 @@ describe('codex history item persistence policy', () => {
     });
   });
 
+  it('preserves per-item timestamps when mapping Codex turn history', () => {
+    const turn = codexTurnToAgentTurn({
+      id: 'turn-1',
+      status: 'completed',
+      error: null,
+      items: [
+        {
+          id: 'user-1',
+          type: 'userMessage',
+          text: 'start',
+          createdAt: '2026-06-13T22:00:01.123Z',
+        },
+        {
+          id: 'agent-1',
+          type: 'agentMessage',
+          text: 'done',
+          completedAt: '2026-06-13T22:00:08.456Z',
+        },
+      ],
+    });
+
+    expect(turn.items).toMatchObject([
+      {
+        id: 'user-1',
+        createdAt: '2026-06-13T22:00:01.123Z',
+      },
+      {
+        id: 'agent-1',
+        createdAt: '2026-06-13T22:00:08.456Z',
+      },
+    ]);
+  });
+
   it('keeps MCP tool result text extractable for plugin artifacts', () => {
     const artifactText = [
       'Created a 3D molecule artifact for Methane.',

package/packages/codex/src/historyItems.ts

@@ -46,6 +46,51 @@ function stringOrNull(value: unknown) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function isoTimestampOrNull(value: unknown) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const epochMs = value < 10_000_000_000 ? value * 1000 : value;
+    return new Date(epochMs).toISOString();
+  }
+
+  const text = stringOrNull(value);
+  if (!text) {
+    return null;
+  }
+
+  const parsed = Date.parse(text);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
+
+function codexItemCreatedAt(item: CodexTurnItem) {
+  const candidates = [
+    item.createdAt,
+    item.created_at,
+    item.startedAt,
+    item.started_at,
+    item.completedAt,
+    item.completed_at,
+  ];
+
+  for (const candidate of candidates) {
+    const timestamp = isoTimestampOrNull(candidate);
+    if (timestamp) {
+      return timestamp;
+    }
+  }
+
+  return parseUuidV7Timestamp(item.id);
+}
+
+function withCodexItemTimestamp<T extends ThreadHistoryItemDto>(
+  item: CodexTurnItem,
+  historyItem: T,
+): T {
+  return {
+    ...historyItem,
+    createdAt: historyItem.createdAt ?? codexItemCreatedAt(item),
+  };
+}
+
 function numberOrNull(value: unknown) {
   if (typeof value === 'number' && Number.isFinite(value)) {
     return value;
@@ -1319,7 +1364,7 @@ export function liveCodexItemToHistoryItem(
   item: CodexTurnItem,
   phase: 'started' | 'completed',
 ): ThreadHistoryItemDto | null {
-  const historyItem = itemToHistoryItem(item);
+  const historyItem = withCodexItemTimestamp(item, itemToHistoryItem(item));
 
   if (
     historyItem.kind !== 'commandExecution' &&
@@ -1365,7 +1410,9 @@ export function codexTurnToAgentTurn(turn: CodexTurnRecord): AgentTurn {
     rawTurnId: turn.id,
     status: turn.status,
     error: turn.error,
-    items: turn.items.map((item) => itemToHistoryItem(item)),
+    items: turn.items.map((item) =>
+      withCodexItemTimestamp(item, itemToHistoryItem(item)),
+    ),
     rawTurn: turn,
   };
 }

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

@@ -0,0 +1,76 @@
+import { EventEmitter } from 'node:events';
+
+import { describe, expect, it } from 'vitest';
+
+import { CodexRuntimeAdapter } from './runtimeAdapter';
+import type { TurnStartInput } from './types';
+
+class FakeCodexManager extends EventEmitter {
+  startTurnInput: TurnStartInput | null = null;
+
+  getStatus() {
+    return {
+      state: 'ready' as const,
+      transport: 'stdio' as const,
+      lastStartedAt: null,
+      lastError: null,
+      restartCount: 0,
+    };
+  }
+
+  async startTurn(input: TurnStartInput) {
+    this.startTurnInput = input;
+    return {
+      id: 'turn-1',
+      status: 'completed' as const,
+      error: null,
+      items: [],
+    };
+  }
+}
+
+describe('CodexRuntimeAdapter', () => {
+  it('converts prompt photo tokens into structured local image input', async () => {
+    const manager = new FakeCodexManager();
+    const adapter = new CodexRuntimeAdapter(manager as never);
+
+    await adapter.startTurn({
+      providerSessionId: 'thread-1',
+      prompt: 'Inspect this [PHOTO ./.temp/threads/thread-1/photo.png] then summarize.',
+      workspacePath: '/tmp/workspace',
+    });
+
+    expect(manager.startTurnInput).toMatchObject({
+      threadId: 'thread-1',
+      prompt: 'Inspect this [PHOTO ./.temp/threads/thread-1/photo.png] then summarize.',
+      input: [
+        { type: 'text', text: 'Inspect this ', text_elements: [] },
+        {
+          type: 'localImage',
+          path: '/tmp/workspace/.temp/threads/thread-1/photo.png',
+        },
+        { type: 'text', text: ' then summarize.', text_elements: [] },
+      ],
+    });
+  });
+
+  it('keeps mobile photo extensions as structured local image input', async () => {
+    const manager = new FakeCodexManager();
+    const adapter = new CodexRuntimeAdapter(manager as never);
+
+    await adapter.startTurn({
+      providerSessionId: 'thread-1',
+      prompt: 'Inspect [PHOTO ./.temp/threads/thread-1/photo.heic].',
+      workspacePath: '/tmp/workspace',
+    });
+
+    expect(manager.startTurnInput?.input).toEqual([
+      { type: 'text', text: 'Inspect ', text_elements: [] },
+      {
+        type: 'localImage',
+        path: '/tmp/workspace/.temp/threads/thread-1/photo.heic',
+      },
+      { type: 'text', text: '.', text_elements: [] },
+    ]);
+  });
+});

package/packages/codex/src/runtimeAdapter.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import path from 'node:path';
 
 import type {
   AgentModel,
@@ -57,6 +58,62 @@ import {
   supportsFastMode,
 } from './index';
 
+const promptPhotoTokenPattern = /\[PHOTO\s+([^\]]+)\]/g;
+
+function resolvePromptAssetPath(assetPath: string, cwd: string | null | undefined) {
+  if (!assetPath) {
+    return null;
+  }
+  if (path.isAbsolute(assetPath)) {
+    return path.normalize(assetPath);
+  }
+  if (!cwd) {
+    return null;
+  }
+  return path.resolve(cwd, assetPath);
+}
+
+function codexUserInputFromPrompt(
+  prompt: string,
+  cwd: string | null | undefined,
+): TurnStartInput['input'] | undefined {
+  const matches = [...prompt.matchAll(promptPhotoTokenPattern)];
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  const input: NonNullable<TurnStartInput['input']> = [];
+  let cursor = 0;
+  let includedImage = false;
+
+  for (const match of matches) {
+    const token = match[0];
+    const assetPath = match[1]?.trim() ?? '';
+    const start = match.index ?? 0;
+    const precedingText = prompt.slice(cursor, start);
+    if (precedingText) {
+      input.push({ type: 'text', text: precedingText, text_elements: [] });
+    }
+
+    const resolvedPath = resolvePromptAssetPath(assetPath, cwd);
+    if (resolvedPath) {
+      input.push({ type: 'localImage', path: resolvedPath });
+      includedImage = true;
+    } else {
+      input.push({ type: 'text', text: token, text_elements: [] });
+    }
+
+    cursor = start + token.length;
+  }
+
+  const trailingText = prompt.slice(cursor);
+  if (trailingText) {
+    input.push({ type: 'text', text: trailingText, text_elements: [] });
+  }
+
+  return includedImage ? input : undefined;
+}
+
 export const codexCapabilities: AgentProviderCapabilities = {
   sessions: {
     list: true,
@@ -661,6 +718,13 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
       threadId: input.providerSessionId,
       prompt: input.prompt,
     };
+    const structuredInput = codexUserInputFromPrompt(
+      input.prompt,
+      input.workspacePath,
+    );
+    if (structuredInput) {
+      turnInput.input = structuredInput;
+    }
     if (input.developerInstructions !== undefined) {
       turnInput.developerInstructions = input.developerInstructions;
     }
@@ -689,11 +753,17 @@ export class CodexRuntimeAdapter extends EventEmitter implements AgentRuntime {
   }
 
   async sendInput(input: SendAgentInputInput): Promise<AgentTurn | null> {
-    const turn = await codexRuntimeCall(() => this.manager.steerTurn({
+    const structuredInput = codexUserInputFromPrompt(
+      input.prompt,
+      input.workspacePath,
+    );
+    const steerInput = {
       threadId: input.providerSessionId,
       turnId: input.providerTurnId,
       prompt: input.prompt,
-    }));
+      ...(structuredInput ? { input: structuredInput } : {}),
+    };
+    const turn = await codexRuntimeCall(() => this.manager.steerTurn(steerInput));
     return turn ? mapTurn(turn) : null;
   }
 

package/packages/codex/src/types.ts

@@ -318,6 +318,7 @@ export interface ThreadRollbackInput {
 export interface TurnStartInput {
   threadId: string;
   prompt: string;
+  input?: CodexUserInput[];
   developerInstructions?: string | null;
   model?: string | null;
   effort?: ReasoningEffort | null;
@@ -330,8 +331,20 @@ export interface TurnSteerInput {
   threadId: string;
   turnId: string;
   prompt: string;
+  input?: CodexUserInput[];
 }
 
+export type CodexUserInput =
+  | {
+      type: 'text';
+      text: string;
+      text_elements: [];
+    }
+  | {
+      type: 'localImage';
+      path: string;
+    };
+
 export interface ThreadCompactInput {
   threadId: string;
 }

package/packages/shared/src/index.ts

@@ -218,6 +218,7 @@ export interface RelayHttpResponsePayload {
   statusCode: number;
   headers: Record<string, string>;
   body: string;
+  bodyEncoding?: 'utf8' | 'base64';
 }
 
 export interface AgentRuntimeStatusDto {
@@ -563,6 +564,7 @@ export interface ThreadDto {
 
 export interface ThreadHistoryItemDto {
   id: string;
+  createdAt?: string | null;
   kind:
     | 'userMessage'
     | 'agentMessage'