remote-codex 0.1.10 → 0.11.1

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

@@ -0,0 +1,169 @@
+import { EventEmitter } from 'node:events';
+
+import {
+  agentBackendMetadata,
+} from '../../shared/src/index';
+import type {
+  AgentBackendInstallationDto,
+} from '../../shared/src/index';
+import type {
+  AgentSessionDetail,
+  AgentTurn,
+  AgentProviderId,
+  AgentProviderCapabilities,
+  AgentRuntime,
+  AgentRuntimeManagementSchema,
+  AgentRuntimeStatus,
+  InterruptAgentTurnInput,
+  ReadAgentSessionOptions,
+  ResumeAgentSessionInput,
+  StartAgentSessionInput,
+  StartAgentSessionResult,
+  StartAgentTurnInput,
+} from './types';
+import { AgentRuntimeError } from './types';
+
+const unavailableCapabilities: AgentProviderCapabilities = {
+  sessions: {
+    list: false,
+    read: false,
+    resume: false,
+    importLocal: false,
+  },
+  turns: {
+    start: false,
+    streamInput: false,
+    steer: false,
+    interrupt: false,
+    compact: false,
+  },
+  branching: {
+    fork: false,
+    hardRollback: false,
+    resumeAt: false,
+    rewindFiles: false,
+  },
+  controls: {
+    planMode: false,
+    permissionRequests: false,
+    sandboxMode: false,
+    performanceMode: false,
+    goals: false,
+  },
+  management: {
+    models: false,
+    mcpStatus: false,
+    skills: false,
+    hooks: false,
+    hookTrust: false,
+    hostConfigFiles: false,
+    providerSettings: false,
+  },
+  usage: {
+    contextWindow: false,
+    tokenUsage: false,
+    costUsd: false,
+  },
+};
+
+const unavailableManagementSchema: AgentRuntimeManagementSchema = {
+  hostConfigFiles: [],
+  toolboxItems: [],
+  hookCommandTemplates: [],
+  providerConfigFormat: 'none',
+  mcpConfigFormat: 'none',
+  configArchives: false,
+  buildRestart: false,
+};
+
+export interface UnavailableRuntimeOptions {
+  provider: AgentProviderId;
+  reason: string;
+}
+
+export class UnavailableRuntimeAdapter extends EventEmitter implements AgentRuntime {
+  readonly provider: AgentProviderId;
+  readonly displayName: string;
+  readonly description: string;
+  readonly capabilities = unavailableCapabilities;
+  readonly managementSchema = unavailableManagementSchema;
+  readonly installation: AgentBackendInstallationDto;
+
+  private readonly status: AgentRuntimeStatus;
+
+  constructor(options: UnavailableRuntimeOptions) {
+    super();
+    const metadata = agentBackendMetadata[options.provider];
+    this.provider = options.provider;
+    this.displayName = metadata.displayName;
+    this.description = metadata.description;
+    this.installation = {
+      packageName: null,
+      installed: false,
+      installedVersion: null,
+      latestVersion: null,
+      installCommand: null,
+      updateCommand: null,
+      busy: false,
+      lastError: options.reason,
+    };
+    this.status = {
+      state: 'stopped',
+      transport: metadata.defaultTransport,
+      lastStartedAt: null,
+      lastError: options.reason,
+      restartCount: 0,
+    };
+  }
+
+  getStatus(): AgentRuntimeStatus {
+    return { ...this.status };
+  }
+
+  async start() {}
+
+  async stop() {}
+
+  async listModels() {
+    return [];
+  }
+
+  async listSessions() {
+    return [];
+  }
+
+  async listLoadedSessions() {
+    return [];
+  }
+
+  async readSession(
+    _providerSessionId: string,
+    _options?: ReadAgentSessionOptions,
+  ): Promise<AgentSessionDetail> {
+    throw this.unavailableError();
+  }
+
+  async startSession(_input: StartAgentSessionInput): Promise<StartAgentSessionResult> {
+    throw this.unavailableError();
+  }
+
+  async resumeSession(_input: ResumeAgentSessionInput): Promise<StartAgentSessionResult> {
+    throw this.unavailableError();
+  }
+
+  async startTurn(_input: StartAgentTurnInput): Promise<AgentTurn> {
+    throw this.unavailableError();
+  }
+
+  async interruptTurn(_input: InterruptAgentTurnInput): Promise<AgentTurn | null> {
+    throw this.unavailableError();
+  }
+
+  private unavailableError() {
+    return new AgentRuntimeError(
+      this.status.lastError ?? `${this.displayName} is not available.`,
+      this.provider,
+      'provider_unavailable',
+    );
+  }
+}

package/packages/claude/src/historyItems.ts

@@ -104,6 +104,40 @@ function readableToolName(toolName: string) {
   return toolName;
 }
 
+function projectRelativePathLabel(value: string | null | undefined) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+
+  const slashNormalized = normalized.replace(/\\/g, '/');
+  if (!slashNormalized.startsWith('/')) {
+    return slashNormalized.replace(/^\.\//, '');
+  }
+
+  const markers = [
+    '/apps/',
+    '/packages/',
+    '/src/',
+    '/test/',
+    '/tests/',
+    '/docs/',
+    '/config/',
+    '/scripts/',
+    '/e2e/',
+    '/.agents/',
+    '/.codex/',
+  ];
+  for (const marker of markers) {
+    const markerIndex = slashNormalized.indexOf(marker);
+    if (markerIndex >= 0) {
+      return slashNormalized.slice(markerIndex + 1);
+    }
+  }
+
+  return slashNormalized;
+}
+
 function commandFromInput(input: unknown) {
   if (!isRecord(input)) {
     return null;
@@ -115,11 +149,13 @@ function pathFromInput(input: unknown) {
   if (!isRecord(input)) {
     return null;
   }
-  return (
-    stringValue(input.file_path) ??
-    stringValue(input.filePath) ??
-    stringValue(input.path) ??
-    stringValue(input.notebook_path)
+  return projectRelativePathLabel(
+    stringValue(input.relative_path) ??
+      stringValue(input.relativePath) ??
+      stringValue(input.file_path) ??
+      stringValue(input.filePath) ??
+      stringValue(input.path) ??
+      stringValue(input.notebook_path),
   );
 }
 

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

@@ -2,17 +2,21 @@ import { describe, expect, it } from 'vitest';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import type {
-  Query,
-  SDKMessage,
-  SDKSessionInfo,
-  SessionMessage,
-} from '@anthropic-ai/claude-agent-sdk';
 
 import { ClaudeRuntimeAdapter } from './runtimeAdapter';
 import { hiddenInitPrompt } from './historyItems';
 import type { AgentRuntimeEvent } from '../../agent-runtime/src/index';
 
+type SDKMessage = Record<string, any>;
+type SDKSessionInfo = Record<string, any>;
+type SessionMessage = Record<string, any>;
+interface Query extends AsyncIterable<SDKMessage> {
+  close(): void;
+  interrupt(): Promise<void>;
+  supportedModels(): Promise<any[]>;
+  mcpServerStatus(): Promise<any[]>;
+}
+
 function wait(ms = 0) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -229,6 +233,23 @@ describe('ClaudeRuntimeAdapter', () => {
     expect(sdkOptions[0]?.pathToClaudeCodeExecutable).toBe('claude');
   });
 
+  it('does not pass an empty tool list to Claude session initialization', async () => {
+    const sdkOptions: Record<string, unknown>[] = [];
+    const adapter = makeAdapter((_prompt, options) => {
+      sdkOptions.push(options);
+      return [systemInit(), result()];
+    });
+
+    await adapter.startSession({
+      cwd: '/tmp/workspace',
+      model: 'sonnet',
+      approvalMode: 'guarded',
+      sandboxMode: 'workspace-write',
+    });
+
+    expect(sdkOptions[0]).not.toHaveProperty('tools');
+  });
+
   it('maps thread sandbox modes to Claude permission and sandbox settings', async () => {
     const turnOptions: Record<string, unknown>[] = [];
     const adapter = makeAdapter((_prompt, options) => {
@@ -436,6 +457,74 @@ describe('ClaudeRuntimeAdapter', () => {
     });
   });
 
+  it('keeps image blocks visible when reading Claude session history', async () => {
+    const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-history-image-'));
+    const adapter = new ClaudeRuntimeAdapter({
+      home: '/tmp/claude-home',
+      command: 'claude',
+      query: (() => new FakeQuery([systemInit(), result()])) as any,
+      listSessions: (async () => [] satisfies SDKSessionInfo[]) as any,
+      getSessionInfo: (async () => ({
+        sessionId: 'claude-session-1',
+        summary: 'Existing session',
+        lastModified: 1_772_000_000_000,
+        createdAt: 1_771_000_000_000,
+        cwd: workspace,
+      })) as any,
+      getSessionMessages: (async () => [
+        {
+          type: 'user',
+          uuid: '019e4657-bd3c-72d1-b59d-324ed8a4b1ec',
+          session_id: 'claude-session-1',
+          message: {
+            role: 'user',
+            content: [
+              { type: 'text', text: 'What number is in the screenshot? ' },
+              {
+                type: 'image',
+                source: {
+                  type: 'base64',
+                  media_type: 'image/png',
+                  data: 'ZmFrZS1wbmc=',
+                },
+              },
+            ],
+          },
+          parent_tool_use_id: null,
+        },
+        {
+          type: 'assistant',
+          uuid: '019e4657-bd3c-72d1-b59d-324ed8a4b1ed',
+          session_id: 'claude-session-1',
+          message: {
+            role: 'assistant',
+            content: [{ type: 'text', text: 'The number is 9.' }],
+          },
+          parent_tool_use_id: null,
+        },
+      ] satisfies SessionMessage[]) as any,
+    });
+
+    const session = await adapter.readSession('claude-session-1', {
+      localThreadId: 'thread-1',
+      workspacePath: workspace,
+    });
+
+    expect(session.turns[0]?.items[0]).toMatchObject({
+      kind: 'userMessage',
+      text: 'What number is in the screenshot? \n[PHOTO ./.temp/threads/thread-1/claude-history-019e4657-bd3c-72d1-b59d-324ed8a4b1ec-1.png]',
+    });
+    await expect(
+      fs.readFile(
+        path.join(
+          workspace,
+          '.temp/threads/thread-1/claude-history-019e4657-bd3c-72d1-b59d-324ed8a4b1ec-1.png',
+        ),
+        'utf8',
+      ),
+    ).resolves.toBe('fake-png');
+  });
+
   it('starts a session from the Claude init message and hides the synthetic prompt', async () => {
     const adapter = makeAdapter((prompt) => {
       expect(prompt).toBe(hiddenInitPrompt());
@@ -1933,6 +2022,16 @@ describe('ClaudeRuntimeAdapter', () => {
                   file_path: 'packages/claude/src/runtimeAdapter.ts',
                 },
               },
+              {
+                type: 'tool_use',
+                id: 'toolu_edit',
+                name: 'Edit',
+                input: {
+                  file_path: '/home/u/dev/remoteCodex/apps/supervisor-api/src/thread-service.ts',
+                  old_string: 'before',
+                  new_string: 'after',
+                },
+              },
               {
                 type: 'tool_use',
                 id: 'toolu_skill',
@@ -1980,6 +2079,11 @@ describe('ClaudeRuntimeAdapter', () => {
                 tool_use_id: 'toolu_read',
                 content: 'export class ClaudeRuntimeAdapter {}',
               },
+              {
+                type: 'tool_result',
+                tool_use_id: 'toolu_edit',
+                content: 'File updated.',
+              },
               {
                 type: 'tool_result',
                 tool_use_id: 'toolu_skill',
@@ -2025,6 +2129,13 @@ describe('ClaudeRuntimeAdapter', () => {
           text: 'Read file: packages/claude/src/runtimeAdapter.ts',
           status: 'completed',
         }),
+        expect.objectContaining({
+          id: 'toolu_edit',
+          kind: 'fileChange',
+          text: 'apps/supervisor-api/src/thread-service.ts',
+          previewText: 'Edit file: apps/supervisor-api/src/thread-service.ts',
+          status: 'completed',
+        }),
         expect.objectContaining({
           id: 'toolu_skill',
           kind: 'skillToolCall',