remote-codex 0.11.49 → 0.11.51

package/packages/acp/src/session-hydrator.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest';
+
+import { AcpSessionHydrator } from './session-hydrator';
+
+describe('AcpSessionHydrator', () => {
+  it('reconstructs stable turns from replayed user-message boundaries', () => {
+    const hydrate = () => {
+      const hydrator = new AcpSessionHydrator('session-1');
+      hydrator.apply({
+        sessionUpdate: 'user_message_chunk',
+        messageId: 'user-1',
+        content: { type: 'text', text: 'First prompt' },
+      });
+      hydrator.apply({
+        sessionUpdate: 'agent_thought_chunk',
+        messageId: 'reasoning-1',
+        content: { type: 'text', text: 'First reasoning' },
+      });
+      hydrator.apply({
+        sessionUpdate: 'tool_call',
+        toolCallId: 'tool-1',
+        title: 'Optional check',
+        kind: 'execute',
+        status: 'failed',
+      });
+      hydrator.apply({
+        sessionUpdate: 'agent_message_chunk',
+        messageId: 'agent-1',
+        content: { type: 'text', text: 'First response' },
+      });
+      hydrator.apply({
+        sessionUpdate: 'user_message_chunk',
+        messageId: 'user-2',
+        content: { type: 'text', text: 'Second prompt' },
+      });
+      hydrator.apply({
+        sessionUpdate: 'agent_message_chunk',
+        messageId: 'agent-2',
+        content: { type: 'text', text: 'Second response' },
+      });
+      return hydrator.complete();
+    };
+
+    const first = hydrate();
+    const second = hydrate();
+    expect(first.map((turn) => turn.providerTurnId)).toEqual([
+      'acp-hydrated:user-1',
+      'acp-hydrated:user-2',
+    ]);
+    expect(second.map((turn) => turn.providerTurnId)).toEqual(
+      first.map((turn) => turn.providerTurnId),
+    );
+    expect(first[0]).toMatchObject({
+      status: 'completed',
+      items: [
+        { id: 'user-1', kind: 'userMessage', text: 'First prompt' },
+        { id: 'reasoning-1', kind: 'reasoning', text: 'First reasoning' },
+        { id: 'tool-1', kind: 'commandExecution', status: 'failed' },
+        { id: 'agent-1', kind: 'agentMessage', text: 'First response' },
+      ],
+    });
+    expect(first[1]?.items).toMatchObject([
+      { id: 'user-2', kind: 'userMessage' },
+      { id: 'agent-2', kind: 'agentMessage' },
+    ]);
+    const coverageHydrator = new AcpSessionHydrator('session-coverage');
+    coverageHydrator.apply({
+      sessionUpdate: 'user_message_chunk',
+      messageId: 'coverage-user',
+      content: { type: 'text', text: 'Coverage prompt' },
+    });
+    coverageHydrator.apply({
+      sessionUpdate: 'agent_message_chunk',
+      messageId: 'coverage-agent',
+      content: { type: 'text', text: 'Coverage response' },
+    });
+    expect(coverageHydrator.coverage()).toEqual({
+      source: 'providerReplay',
+      completeness: 'unknown',
+      replayedTurnCount: 1,
+      replayedItemCount: 2,
+      providerIdentifiedTurnCount: 1,
+    });
+  });
+
+  it('keeps consecutive anonymous user chunks in one turn', () => {
+    const hydrator = new AcpSessionHydrator('session-anonymous');
+    hydrator.apply({
+      sessionUpdate: 'user_message_chunk',
+      content: { type: 'text', text: 'First ' },
+    });
+    hydrator.apply({
+      sessionUpdate: 'user_message_chunk',
+      content: { type: 'text', text: 'prompt' },
+    });
+    hydrator.apply({
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'Response' },
+    });
+    expect(hydrator.complete()).toMatchObject([{
+      items: [
+        { kind: 'userMessage', text: 'First prompt' },
+        { kind: 'agentMessage', text: 'Response' },
+      ],
+    }]);
+  });
+
+  it('attaches leading replay updates to the first user turn', () => {
+    const hydrator = new AcpSessionHydrator('session-leading');
+    hydrator.apply({
+      sessionUpdate: 'agent_thought_chunk',
+      messageId: 'leading-reasoning',
+      content: { type: 'text', text: 'Recovered leading context' },
+    });
+    hydrator.apply({
+      sessionUpdate: 'user_message_chunk',
+      messageId: 'user-leading',
+      content: { type: 'text', text: 'Actual prompt' },
+    });
+    hydrator.apply({
+      sessionUpdate: 'agent_message_chunk',
+      messageId: 'agent-leading',
+      content: { type: 'text', text: 'Actual response' },
+    });
+
+    expect(hydrator.complete()).toMatchObject([{
+      providerTurnId: 'acp-hydrated:user-leading',
+      items: [
+        { id: 'user-leading', kind: 'userMessage' },
+        { id: 'leading-reasoning', kind: 'reasoning' },
+        { id: 'agent-leading', kind: 'agentMessage' },
+      ],
+    }]);
+  });
+});

package/packages/acp/src/session-hydrator.ts

@@ -0,0 +1,147 @@
+import type * as acp from '@agentclientprotocol/sdk';
+
+import type {
+  AgentSessionHistoryCoverage,
+  AgentTurn,
+} from '../../agent-runtime/src/types';
+import { AcpTurnItemMapper } from './item-mapper';
+
+interface HydratedTurnBuilder {
+  userMessageId: string | null;
+  mapper: AcpTurnItemMapper;
+  startedAt: string;
+  sawNonUserUpdate: boolean;
+}
+
+function updateMessageId(update: { messageId?: unknown }) {
+  return typeof update.messageId === 'string' && update.messageId.trim()
+    ? update.messageId.trim()
+    : null;
+}
+
+export class AcpSessionHydrator {
+  private readonly turns: AgentTurn[] = [];
+  private readonly leadingUpdates: acp.SessionUpdate[] = [];
+  private current: HydratedTurnBuilder | null = null;
+  private turnIndex = 0;
+  private providerIdentifiedTurnCount = 0;
+  private readonly receivedAt = Date.now();
+
+  constructor(private readonly providerSessionId: string) {}
+
+  apply(update: acp.SessionUpdate) {
+    if (update.sessionUpdate === 'user_message_chunk') {
+      this.applyUserMessage(update);
+      return;
+    }
+    if (
+      update.sessionUpdate === 'config_option_update' ||
+      update.sessionUpdate === 'current_mode_update' ||
+      update.sessionUpdate === 'available_commands_update' ||
+      update.sessionUpdate === 'session_info_update' ||
+      update.sessionUpdate === 'usage_update'
+    ) {
+      return;
+    }
+    if (!this.current) {
+      this.leadingUpdates.push(update);
+      return;
+    }
+    const current = this.current;
+    this.flushLeadingUpdates(current);
+    current.sawNonUserUpdate = true;
+    current.mapper.apply(update);
+  }
+
+  complete() {
+    this.finishCurrent();
+    return [...this.turns];
+  }
+
+  coverage(): AgentSessionHistoryCoverage {
+    this.finishCurrent();
+    return {
+      source: 'providerReplay',
+      // ACP v1 has no authoritative history total; absence cannot prove completeness.
+      completeness: 'unknown',
+      replayedTurnCount: this.turns.length,
+      replayedItemCount: this.turns.reduce(
+        (count, turn) => count + turn.items.length,
+        0,
+      ),
+      providerIdentifiedTurnCount: this.providerIdentifiedTurnCount,
+    };
+  }
+
+  private applyUserMessage(
+    update: Extract<acp.SessionUpdate, { sessionUpdate: 'user_message_chunk' }>,
+  ) {
+    const messageId = updateMessageId(update);
+    const shouldStartTurn =
+      !this.current ||
+      this.current.sawNonUserUpdate ||
+      Boolean(
+        messageId &&
+        this.current.userMessageId &&
+        messageId !== this.current.userMessageId,
+      );
+    if (shouldStartTurn) {
+      if (this.current) {
+        this.finishCurrent();
+      }
+      this.startTurn(messageId);
+    }
+    const current = this.current!;
+    if (messageId && !current.userMessageId) {
+      current.userMessageId = messageId;
+    }
+    current.mapper.appendUserMessage(
+      update.content,
+      current.userMessageId ?? `${current.mapper.turnId}:user`,
+    );
+  }
+
+  private startTurn(userMessageId: string | null) {
+    const index = this.turnIndex++;
+    const stableSource = userMessageId ?? `${this.providerSessionId}:${index}`;
+    const builder: HydratedTurnBuilder = {
+      userMessageId,
+      mapper: new AcpTurnItemMapper(
+        `acp-hydrated:${stableSource}`,
+        [],
+        'hydrate',
+      ),
+      startedAt: new Date(this.receivedAt + index).toISOString(),
+      sawNonUserUpdate: false,
+    };
+    if (userMessageId) {
+      this.providerIdentifiedTurnCount += 1;
+    }
+    this.current = builder;
+    return builder;
+  }
+
+  private finishCurrent() {
+    if (!this.current && this.leadingUpdates.length > 0) {
+      this.startTurn(null);
+    }
+    if (!this.current) {
+      return;
+    }
+    this.flushLeadingUpdates(this.current);
+    const completed = this.current.mapper.complete('completed').turn;
+    if (completed.items.length > 0) {
+      this.turns.push({
+        ...completed,
+        startedAt: this.current.startedAt,
+      });
+    }
+    this.current = null;
+  }
+
+  private flushLeadingUpdates(current: HydratedTurnBuilder) {
+    for (const update of this.leadingUpdates.splice(0)) {
+      current.mapper.apply(update);
+    }
+  }
+}

package/packages/acp/src/terminal-service.test.ts

@@ -4,8 +4,12 @@ import { AcpTerminalService } from './terminal-service';
 
 describe('AcpTerminalService', () => {
   it('parses agents that send command and argv as one ACP command string', async () => {
-    const service = new AcpTerminalService(() => process.cwd());
-    const created = service.create({
+    const operations: Array<{ operation: string; sessionId: string; path: string }> = [];
+    const service = new AcpTerminalService(
+      () => process.cwd(),
+      (operation) => operations.push(operation),
+    );
+    const created = await service.create({
       sessionId: 'session-1',
       command: `"${process.execPath}" -e "process.stdout.write('ACP_TERMINAL_OK')"`,
       args: [],
@@ -23,9 +27,24 @@ describe('AcpTerminalService', () => {
     expect(exit.exitCode).toBe(0);
     expect(output.output).toBe('ACP_TERMINAL_OK');
     expect(output.truncated).toBe(false);
+    expect(operations).toMatchObject([{
+      operation: 'terminal.create',
+      sessionId: 'session-1',
+      path: await import('node:fs/promises').then((fs) => fs.realpath(process.cwd())),
+    }]);
     service.release({
       sessionId: 'session-1',
       terminalId: created.terminalId,
     });
   });
+
+  it('rejects terminal working directories outside the session workspace', async () => {
+    const service = new AcpTerminalService(() => process.cwd());
+    await expect(service.create({
+      sessionId: 'session-1',
+      command: process.execPath,
+      args: ['--version'],
+      cwd: '/tmp',
+    })).rejects.toThrow(/must stay inside the session workspace/);
+  });
 });

package/packages/acp/src/terminal-service.ts

@@ -7,6 +7,7 @@ import {
   parseCommandLine,
   spawnProcess,
 } from '../../process-runtime/src/index';
+import { resolveAcpWorkspacePath } from './workspace-boundary';
 
 const DEFAULT_OUTPUT_BYTE_LIMIT = 1024 * 1024;
 
@@ -38,11 +39,30 @@ function retainedOutput(state: AcpTerminalState) {
 export class AcpTerminalService {
   private readonly terminals = new Map<string, AcpTerminalState>();
 
-  constructor(private readonly sessionCwd: (sessionId: string) => string | null) {}
+  constructor(
+    private readonly sessionCwd: (sessionId: string) => string | null,
+    private readonly onOperation: (input: {
+      operation: 'terminal.create';
+      sessionId: string;
+      path: string;
+    }) => void = () => undefined,
+  ) {}
 
-  create(params: acp.CreateTerminalRequest): acp.CreateTerminalResponse {
+  async create(params: acp.CreateTerminalRequest): Promise<acp.CreateTerminalResponse> {
     const terminalId = randomUUID();
-    const cwd = params.cwd ?? this.sessionCwd(params.sessionId) ?? process.cwd();
+    const sessionCwd = this.sessionCwd(params.sessionId);
+    if (!sessionCwd) {
+      throw new Error(`ACP session workspace not found: ${params.sessionId}`);
+    }
+    const cwd = await resolveAcpWorkspacePath(
+      sessionCwd,
+      params.cwd ?? sessionCwd,
+    );
+    this.onOperation({
+      operation: 'terminal.create',
+      sessionId: params.sessionId,
+      path: cwd,
+    });
     const parsed = params.args && params.args.length > 0
       ? { command: params.command, args: params.args }
       : parseCommandLine(params.command);