remote-codex 0.1.6 → 0.1.7

package/packages/codex/src/hookHistory.ts

@@ -0,0 +1,224 @@
+import type { ThreadHistoryItemDto } from '../../shared/src/index';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function decodeXmlEntities(value: string) {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&gt;/g, '>')
+    .replace(/&lt;/g, '<')
+    .replace(/&amp;/g, '&');
+}
+
+function textFromUnknown(value: unknown): string | null {
+  if (typeof value === 'string') {
+    return value.trim() ? value : null;
+  }
+
+  if (Array.isArray(value)) {
+    const parts: string[] = value
+      .map((entry) => textFromUnknown(entry))
+      .filter((entry): entry is string => Boolean(entry));
+    return parts.length > 0 ? parts.join(' ') : null;
+  }
+
+  return null;
+}
+
+export function codexHookEventLabel(value: string) {
+  switch (value) {
+    case 'preToolUse':
+      return 'PreToolUse';
+    case 'permissionRequest':
+      return 'PermissionRequest';
+    case 'postToolUse':
+      return 'PostToolUse';
+    case 'preCompact':
+      return 'PreCompact';
+    case 'postCompact':
+      return 'PostCompact';
+    case 'sessionStart':
+      return 'SessionStart';
+    case 'userPromptSubmit':
+      return 'UserPromptSubmit';
+    case 'stop':
+      return 'Stop';
+    default:
+      return value;
+  }
+}
+
+function codexHookStatusLabel(value: string) {
+  switch (value) {
+    case 'running':
+      return 'Running';
+    case 'completed':
+      return 'Completed';
+    case 'failed':
+      return 'Failed';
+    case 'blocked':
+      return 'Blocked';
+    case 'stopped':
+      return 'Stopped';
+    default:
+      return value;
+  }
+}
+
+function hookRunOutputEntryText(entry: unknown) {
+  if (!isRecord(entry)) {
+    return textFromUnknown(entry);
+  }
+
+  return (
+    textFromUnknown(entry.text) ??
+    textFromUnknown(entry.message) ??
+    textFromUnknown(entry.systemMessage) ??
+    textFromUnknown(entry.stopReason) ??
+    textFromUnknown(entry.reason) ??
+    textFromUnknown(entry.output) ??
+    textFromUnknown(entry.stdout) ??
+    textFromUnknown(entry.stderr)
+  );
+}
+
+function normalizeHookRunOutputEntries(run: {
+  entries?: Array<{ kind?: string; text?: string }>;
+  outputEntries?: Array<{ kind?: string; text?: string }>;
+  output_entries?: Array<{ kind?: string; text?: string }>;
+  stdout?: unknown;
+  stderr?: unknown;
+  output?: unknown;
+  text?: unknown;
+  systemMessage?: unknown;
+  stopReason?: unknown;
+  reason?: unknown;
+}): Array<{ kind: string; text: string }> {
+  const rawEntries = Array.isArray(run.entries)
+    ? run.entries
+    : Array.isArray(run.outputEntries)
+      ? run.outputEntries
+      : Array.isArray(run.output_entries)
+        ? run.output_entries
+        : [];
+  const entries = rawEntries
+    .map((entry) => {
+      const text = hookRunOutputEntryText(entry)?.trim();
+      if (!text) {
+        return null;
+      }
+
+      return {
+        kind: typeof entry.kind === 'string' && entry.kind.trim() ? entry.kind : 'context',
+        text,
+      };
+    })
+    .filter((entry): entry is { kind: string; text: string } => Boolean(entry));
+  const seenTexts = new Set(entries.map((entry) => entry.text));
+
+  for (const [kind, value] of [
+    ['context', run.output],
+    ['context', run.text],
+    ['warning', run.systemMessage],
+    ['warning', run.stopReason],
+    ['warning', run.reason],
+    ['context', run.stdout],
+    ['warning', run.stderr],
+  ] as const) {
+    const text = textFromUnknown(value)?.trim();
+    if (text && !seenTexts.has(text)) {
+      entries.push({ kind, text });
+      seenTexts.add(text);
+    }
+  }
+
+  return entries;
+}
+
+export function parseCodexHookPromptText(text: string) {
+  const match = text
+    .trim()
+    .match(/^<hook_prompt(?:\s+hook_run_id="([^"]+)")?>([\s\S]*)<\/hook_prompt>$/);
+  if (!match) {
+    return null;
+  }
+
+  const hookRunId = match[1] ? decodeXmlEntities(match[1]) : null;
+  const output = decodeXmlEntities(match[2] ?? '').trim();
+  const eventName = hookRunId?.split(':')[0] ?? 'hook';
+  const eventLabel = codexHookEventLabel(eventName);
+  const sourcePath = hookRunId?.split(':').slice(2).join(':') || null;
+  const outputEntries = output ? [{ kind: 'warning', text: output }] : [];
+
+  return {
+    hookRunId,
+    output,
+    outputEntries,
+    eventName,
+    eventLabel,
+    sourcePath,
+  };
+}
+
+export function codexHookRunToHistoryItem(run: {
+  id: string;
+  eventName: string;
+  handlerType: string;
+  executionMode: string;
+  scope: string;
+  sourcePath: string;
+  source: string;
+  status: string;
+  statusMessage: string | null;
+  durationMs: number | null;
+  entries?: Array<{ kind: string; text: string }>;
+  outputEntries?: Array<{ kind?: string; text?: string }>;
+  output_entries?: Array<{ kind?: string; text?: string }>;
+  stdout?: unknown;
+  stderr?: unknown;
+  output?: unknown;
+  text?: unknown;
+  systemMessage?: unknown;
+  stopReason?: unknown;
+  reason?: unknown;
+}): ThreadHistoryItemDto {
+  const eventLabel = codexHookEventLabel(run.eventName);
+  const outputEntries = normalizeHookRunOutputEntries(run);
+  const entryPreview = outputEntries
+    .map((entry) => entry.text.trim())
+    .filter(Boolean)
+    .join('\n')
+    .trim();
+  const firstEntryLine = entryPreview.split('\n').find(Boolean) ?? null;
+  const detailLines = [
+    `Event: ${eventLabel}`,
+    `Status: ${codexHookStatusLabel(run.status)}`,
+    `Handler: ${run.handlerType}`,
+    `Scope: ${run.scope}`,
+    `Source: ${run.source}`,
+    `Path: ${run.sourcePath}`,
+    run.durationMs !== null ? `Duration: ${run.durationMs} ms` : null,
+    run.statusMessage ? `Message: ${run.statusMessage}` : null,
+    entryPreview ? `\n${entryPreview}` : null,
+  ].filter((line): line is string => Boolean(line));
+
+  return {
+    id: `hook:${run.id}`,
+    kind: 'hook',
+    text: `${eventLabel} hook`,
+    previewText: run.statusMessage ?? firstEntryLine ?? `${eventLabel} hook`,
+    detailText: detailLines.join('\n'),
+    status: codexHookStatusLabel(run.status),
+    hookEventName: run.eventName,
+    hookEventLabel: eventLabel,
+    hookHandlerType: run.handlerType,
+    hookScope: run.scope,
+    hookSource: run.source,
+    hookSourcePath: run.sourcePath,
+    hookStatusMessage: run.statusMessage,
+    hookOutputEntries: outputEntries,
+  };
+}

package/packages/codex/src/index.ts

@@ -0,0 +1,6 @@
+export * from './appServerManager';
+export * from './historyItems';
+export * from './hookHistory';
+export * from './jsonrpc';
+export * from './runtimeAdapter';
+export * from './types';

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

@@ -0,0 +1,58 @@
+import { PassThrough } from 'node:stream';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { JsonRpcClient, JsonRpcClientError } from './jsonrpc';
+
+describe('JsonRpcClient', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('resolves requests from line-delimited responses', async () => {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    const client = new JsonRpcClient(input, output);
+
+    const promise = client.request<{ ok: boolean }>('ping', { hello: 'world' }, 1000);
+    const outbound = output.read()?.toString() ?? '';
+    const parsed = JSON.parse(outbound.trim());
+
+    expect(parsed.method).toBe('ping');
+
+    input.write(`${JSON.stringify({ id: parsed.id, result: { ok: true } })}\n`);
+
+    await expect(promise).resolves.toEqual({ ok: true });
+  });
+
+  it('emits notifications', async () => {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    const client = new JsonRpcClient(input, output);
+    const onNotification = vi.fn();
+
+    client.on('notification', onNotification);
+    input.write(`${JSON.stringify({ method: 'turn/started', params: { threadId: 't1' } })}\n`);
+
+    expect(onNotification).toHaveBeenCalledWith({
+      method: 'turn/started',
+      params: { threadId: 't1' }
+    });
+  });
+
+  it('times out pending requests', async () => {
+    vi.useFakeTimers();
+
+    const input = new PassThrough();
+    const output = new PassThrough();
+    const client = new JsonRpcClient(input, output);
+    const promise = client.request('slow', undefined, 50);
+    const assertion = expect(promise).rejects.toMatchObject({
+      code: 'request_timeout'
+    } satisfies Partial<JsonRpcClientError>);
+
+    await vi.advanceTimersByTimeAsync(60);
+
+    await assertion;
+  });
+});

package/packages/codex/src/jsonrpc.ts

@@ -0,0 +1,198 @@
+import { EventEmitter } from 'node:events';
+import readline from 'node:readline';
+import { Readable, Writable } from 'node:stream';
+
+import {
+  JsonRpcFailure,
+  JsonRpcId,
+  JsonRpcNotification,
+  JsonRpcRequest,
+  JsonRpcSuccess
+} from './types';
+
+export class JsonRpcClientError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly details?: Record<string, unknown>
+  ) {
+    super(message);
+  }
+}
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (reason?: unknown) => void;
+  timer: NodeJS.Timeout;
+}
+
+export class JsonRpcClient extends EventEmitter {
+  private readonly reader: readline.Interface;
+  private readonly pending = new Map<JsonRpcId, PendingRequest>();
+  private nextRequestId = 1;
+  private closed = false;
+
+  constructor(
+    private readonly input: Readable,
+    private readonly output: Writable
+  ) {
+    super();
+
+    this.reader = readline.createInterface({
+      input: this.input,
+      crlfDelay: Infinity
+    });
+
+    this.reader.on('line', (line) => {
+      if (!line.trim()) {
+        return;
+      }
+
+      this.handleMessage(line);
+    });
+
+    this.reader.on('close', () => {
+      this.close();
+    });
+  }
+
+  async request<TResult = unknown, TParams = unknown>(
+    method: string,
+    params?: TParams,
+    timeoutMs = 20_000
+  ): Promise<TResult> {
+    if (this.closed) {
+      throw new JsonRpcClientError('JSON-RPC client is closed.', 'client_closed');
+    }
+
+    const id = this.nextRequestId++;
+    const payload: JsonRpcRequest<TParams> = {
+      jsonrpc: '2.0',
+      id,
+      method
+    };
+
+    if (params !== undefined) {
+      payload.params = params;
+    }
+
+    return new Promise<TResult>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new JsonRpcClientError(`JSON-RPC request timed out for ${method}.`, 'request_timeout', {
+            method,
+            timeoutMs
+          })
+        );
+      }, timeoutMs);
+
+      this.pending.set(id, {
+        resolve: (value) => resolve(value as TResult),
+        reject,
+        timer
+      });
+
+      this.output.write(`${JSON.stringify(payload)}\n`);
+    });
+  }
+
+  close() {
+    if (this.closed) {
+      return;
+    }
+
+    this.closed = true;
+    this.reader.close();
+
+    for (const [id, request] of this.pending.entries()) {
+      clearTimeout(request.timer);
+      request.reject(
+        new JsonRpcClientError('JSON-RPC client closed before response was received.', 'client_closed', {
+          id
+        })
+      );
+    }
+
+    this.pending.clear();
+    this.emit('closed');
+  }
+
+  private handleMessage(raw: string) {
+    let parsed: Record<string, unknown>;
+
+    try {
+      parsed = JSON.parse(raw) as Record<string, unknown>;
+    } catch (error) {
+      this.emit(
+        'warning',
+        new JsonRpcClientError('Failed to parse JSON-RPC payload.', 'invalid_json', {
+          raw,
+          error: error instanceof Error ? error.message : String(error)
+        })
+      );
+      return;
+    }
+
+    if (typeof parsed.method === 'string' && !('id' in parsed)) {
+      this.emit('notification', parsed as unknown as JsonRpcNotification);
+      return;
+    }
+
+    if (typeof parsed.method === 'string' && typeof parsed.id === 'number') {
+      this.emit('request', parsed as unknown as JsonRpcRequest);
+      return;
+    }
+
+    if (typeof parsed.id !== 'number') {
+      return;
+    }
+
+    const request = this.pending.get(parsed.id);
+    if (!request) {
+      return;
+    }
+
+    clearTimeout(request.timer);
+    this.pending.delete(parsed.id);
+
+    if ('error' in parsed && parsed.error && typeof parsed.error === 'object') {
+      const error = parsed.error as JsonRpcFailure['error'];
+      request.reject(
+        new JsonRpcClientError(error.message, 'remote_error', {
+          code: error.code,
+          data: error.data
+        })
+      );
+      return;
+    }
+
+    request.resolve((parsed as unknown as JsonRpcSuccess).result);
+  }
+
+  respond(id: JsonRpcId, result: unknown) {
+    if (this.closed) {
+      throw new JsonRpcClientError('JSON-RPC client is closed.', 'client_closed');
+    }
+
+    this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`);
+  }
+
+  respondError(id: JsonRpcId, message: string, code = -32000, data?: unknown) {
+    if (this.closed) {
+      throw new JsonRpcClientError('JSON-RPC client is closed.', 'client_closed');
+    }
+
+    this.output.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code,
+          message,
+          data
+        }
+      })}\n`
+    );
+  }
+}

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

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+
+import type { AgentProviderRequest } from '../../agent-runtime/src/index';
+
+import {
+  buildCodexProviderRequestResponse,
+  mapCodexProviderRequest,
+} from './requestMapper';
+
+describe('Codex provider request mapping', () => {
+  it('auto-approves command approval requests in yolo mode', () => {
+    const request: AgentProviderRequest = {
+      provider: 'codex',
+      id: 7,
+      method: 'item/commandExecution/requestApproval',
+      params: {
+        threadId: 'thread-1',
+        turnId: 'turn-1',
+        command: 'pnpm test',
+      },
+    };
+
+    expect(mapCodexProviderRequest(request, 'yolo')).toEqual({
+      providerRequestId: 7,
+      providerSessionId: 'thread-1',
+      autoApprovedResult: { decision: 'accept' },
+      pendingRequest: null,
+    });
+  });
+
+  it('maps guarded command approval requests to pending action requests', () => {
+    const request: AgentProviderRequest = {
+      provider: 'codex',
+      id: 8,
+      method: 'item/commandExecution/requestApproval',
+      params: {
+        threadId: 'thread-2',
+        turnId: 'turn-2',
+        itemId: 'item-1',
+        command: ['pnpm', 'test'],
+        cwd: '/repo',
+        reason: 'Needs to verify changes.',
+      },
+    };
+
+    const mapped = mapCodexProviderRequest(request, 'guarded');
+
+    expect(mapped?.providerSessionId).toBe('thread-2');
+    expect(mapped?.autoApprovedResult).toBeNull();
+    expect(mapped?.pendingRequest?.providerRequestId).toBe(8);
+    expect(mapped?.pendingRequest?.responseKind).toBe('commandExecutionApproval');
+    expect(mapped?.pendingRequest?.request).toMatchObject({
+      id: '8',
+      kind: 'requestUserInput',
+      title: 'Command approval required',
+      turnId: 'turn-2',
+      itemId: 'item-1',
+    });
+    expect(mapped?.pendingRequest?.request.description).toContain('Needs to verify changes.');
+    expect(mapped?.pendingRequest?.request.description).toContain('Command: pnpm test');
+    expect(mapped?.pendingRequest?.request.description).toContain('CWD: /repo');
+  });
+
+  it('maps generic user-input requests and auto-approves recommended allow answers in yolo mode', () => {
+    const request: AgentProviderRequest = {
+      provider: 'codex',
+      id: 9,
+      method: 'requestUserInput',
+      params: {
+        threadId: 'thread-3',
+        turnId: 'turn-3',
+        questions: [
+          {
+            id: 'approval',
+            header: 'Tool approval',
+            question: 'Allow tool use?',
+            isOther: false,
+            isSecret: false,
+            options: [
+              { label: 'Allow (Recommended)', description: 'Continue.' },
+              { label: 'Deny', description: 'Stop.' },
+            ],
+          },
+        ],
+      },
+    };
+
+    expect(mapCodexProviderRequest(request, 'yolo')).toEqual({
+      providerRequestId: 9,
+      providerSessionId: 'thread-3',
+      autoApprovedResult: {
+        answers: {
+          approval: {
+            answers: ['Allow (Recommended)'],
+          },
+        },
+      },
+      pendingRequest: null,
+    });
+  });
+
+  it('builds interactive approval responses from pending request answers', () => {
+    const pending = mapCodexProviderRequest(
+      {
+        provider: 'codex',
+        id: 10,
+        method: 'item/fileChange/requestApproval',
+        params: {
+          threadId: 'thread-4',
+          turnId: 'turn-4',
+        },
+      },
+      'guarded',
+    )?.pendingRequest;
+
+    expect(pending).toBeTruthy();
+    expect(
+      buildCodexProviderRequestResponse(pending!, {
+        answers: {
+          approval: {
+            answers: ['Deny'],
+          },
+        },
+      }),
+    ).toEqual({ decision: 'decline' });
+  });
+});