remote-codex 0.11.44 → 0.11.49

package/packages/acp/src/catalog-runtime.ts

@@ -0,0 +1,507 @@
+import { EventEmitter } from 'node:events';
+
+import {
+  AgentRuntimeError,
+  type AgentActionRequestResponseInput,
+  type AgentModel,
+  type AgentPendingProviderRequest,
+  type AgentProviderCapabilities,
+  type AgentProviderRequest,
+  type AgentProviderRequestMapping,
+  type AgentRuntime,
+  type AgentRuntimeEvent,
+  type AgentRuntimeManagementSchema,
+  type AgentRuntimeStatus,
+  type AgentSessionDetail,
+  type AgentSessionSummary,
+  type AgentTurn,
+  type InterruptAgentTurnInput,
+  type ReadAgentSessionOptions,
+  type ResumeAgentSessionInput,
+  type StartAgentSessionInput,
+  type StartAgentSessionResult,
+  type StartAgentTurnInput,
+} from '../../agent-runtime/src/index';
+import type { AgentBackendInstallationDto } from '../../shared/src/index';
+import {
+  AcpAgentCatalog,
+  acpAgentMetadata,
+  type AcpAgentCatalogEntry,
+} from './agent-catalog';
+import { AcpRuntimeAdapter } from './runtimeAdapter';
+import { loadCodexAcpEnvironment } from './codex-environment';
+
+interface AcpCatalogRuntimeOptions {
+  customCommand?: string | null;
+  codexHome?: string | null;
+  startupTimeoutMs?: number;
+  clientInfo?: {
+    name: string;
+    title?: string;
+    version?: string;
+  };
+  catalog?: AcpAgentCatalog;
+}
+
+const SESSION_DELIMITER = '::';
+
+const catalogCapabilities: AgentProviderCapabilities = {
+  sessions: {
+    list: true,
+    read: true,
+    resume: true,
+    importLocal: false,
+  },
+  turns: {
+    start: true,
+    streamInput: false,
+    steer: false,
+    interrupt: true,
+    compact: false,
+  },
+  branching: {
+    fork: false,
+    hardRollback: false,
+    resumeAt: false,
+    rewindFiles: false,
+  },
+  controls: {
+    planMode: true,
+    permissionRequests: true,
+    sandboxMode: true,
+    performanceMode: false,
+    goals: false,
+  },
+  management: {
+    models: false,
+    mcpStatus: false,
+    skills: false,
+    hooks: false,
+    hookTrust: false,
+    hostConfigFiles: false,
+    providerSettings: false,
+  },
+  usage: {
+    contextWindow: true,
+    tokenUsage: true,
+    costUsd: false,
+  },
+};
+
+const catalogManagementSchema: AgentRuntimeManagementSchema = {
+  hostConfigFiles: [],
+  toolboxItems: [],
+  hookCommandTemplates: [],
+  providerConfigFormat: 'none',
+  mcpConfigFormat: 'none',
+  configArchives: false,
+  buildRestart: false,
+};
+
+function encodeSessionId(agentId: string, providerSessionId: string) {
+  return `${agentId}${SESSION_DELIMITER}${providerSessionId}`;
+}
+
+function decodeScopedId(value: string | number) {
+  const normalized = String(value);
+  const delimiterIndex = normalized.indexOf(SESSION_DELIMITER);
+  if (delimiterIndex <= 0) {
+    return null;
+  }
+  return {
+    agentId: normalized.slice(0, delimiterIndex),
+    rawId: normalized.slice(delimiterIndex + SESSION_DELIMITER.length),
+  };
+}
+
+function scopedSession(agentId: string, session: AgentSessionDetail): AgentSessionDetail {
+  return {
+    ...session,
+    providerSessionId: encodeSessionId(agentId, session.providerSessionId),
+  };
+}
+
+function scopedSummary(agentId: string, session: AgentSessionSummary): AgentSessionSummary {
+  return {
+    ...session,
+    providerSessionId: encodeSessionId(agentId, session.providerSessionId),
+  };
+}
+
+function delegatedSessionInput(input: StartAgentSessionInput): StartAgentSessionInput {
+  const delegated = { ...input };
+  delete delegated.agentId;
+  return delegated;
+}
+
+export class AcpCatalogRuntimeAdapter extends EventEmitter implements AgentRuntime {
+  readonly provider = 'acp' as const;
+  readonly displayName = 'ACP Agent';
+  readonly description = 'Choose from installed ACP-native agents and ACP adapters.';
+  readonly capabilities = structuredClone(catalogCapabilities);
+  readonly managementSchema = catalogManagementSchema;
+  readonly installation: AgentBackendInstallationDto = {
+    packageName: null,
+    installed: false,
+    installedVersion: null,
+    latestVersion: null,
+    installCommand: null,
+    updateCommand: null,
+    busy: false,
+    lastError: null,
+  };
+
+  private readonly catalog: AcpAgentCatalog;
+  private readonly agents = new Map<string, AcpRuntimeAdapter>();
+  private readonly modelCache = new Map<string, { at: number; models: AgentModel[] }>();
+  private status: AgentRuntimeStatus = {
+    state: 'stopped',
+    transport: 'stdio',
+    lastStartedAt: null,
+    lastError: null,
+    restartCount: 0,
+  };
+
+  constructor(private readonly options: AcpCatalogRuntimeOptions = {}) {
+    super();
+    this.catalog = options.catalog ?? new AcpAgentCatalog(
+      options.customCommand !== undefined
+        ? { customCommand: options.customCommand }
+        : {},
+    );
+  }
+
+  getStatus() {
+    return { ...this.status };
+  }
+
+  async start() {
+    this.status = {
+      ...this.status,
+      state: 'starting',
+      lastError: null,
+      restartCount: this.status.lastStartedAt ? this.status.restartCount + 1 : 0,
+    };
+    this.emit('status', this.getStatus());
+    await this.refreshCatalog(true);
+  }
+
+  async stop() {
+    await Promise.allSettled([...this.agents.values()].map((agent) => agent.stop()));
+    this.agents.clear();
+    this.status = {
+      ...this.status,
+      state: 'stopped',
+      lastError: null,
+    };
+    this.emit('status', this.getStatus());
+  }
+
+  async listModels(): Promise<AgentModel[]> {
+    return this.listAgentOptions();
+  }
+
+  async listAgentOptions(): Promise<AgentModel[]> {
+    const entries = await this.refreshCatalog();
+    const defaultAgent = entries.find((entry) => entry.availability === 'ready')?.id ?? null;
+    return entries.map((entry) => ({
+      id: entry.id,
+      model: entry.id,
+      displayName: entry.displayName,
+      description: entry.description,
+      isDefault: entry.id === defaultAgent,
+      hidden: false,
+      supportedReasoningEfforts: [],
+      defaultReasoningEffort: null,
+      selectionKind: 'agent',
+      acpAgent: acpAgentMetadata(entry),
+    }));
+  }
+
+  async listModelsForAgent(agentId: string, cwd: string) {
+    const cacheKey = `${agentId}\0${cwd}`;
+    const cached = this.modelCache.get(cacheKey);
+    if (cached && Date.now() - cached.at < 30_000) {
+      return cached.models;
+    }
+    const agent = await this.agentFor(agentId);
+    let models = await agent.inspectModelOptions(cwd);
+    if (models.length === 1 && models[0]?.model === 'default') {
+      const commandModels = await this.catalog.listCommandModels(agentId);
+      if (commandModels.length > 0) {
+        models = commandModels;
+      }
+    }
+    this.modelCache.set(cacheKey, { at: Date.now(), models });
+    return models;
+  }
+
+  async installModel(modelId: string) {
+    await this.catalog.installAdapter(modelId);
+    await this.refreshCatalog(true);
+  }
+
+  async listSessions() {
+    const sessions = await Promise.all(
+      [...this.agents.entries()].map(async ([agentId, agent]) =>
+        (await agent.listSessions()).map((session) => scopedSummary(agentId, session)),
+      ),
+    );
+    return sessions.flat();
+  }
+
+  async listLoadedSessions() {
+    const sessions = await Promise.all(
+      [...this.agents.entries()].map(async ([agentId, agent]) =>
+        (await agent.listLoadedSessions()).map((sessionId) =>
+          encodeSessionId(agentId, sessionId),
+        ),
+      ),
+    );
+    return sessions.flat();
+  }
+
+  async readSession(
+    providerSessionId: string,
+    options?: ReadAgentSessionOptions,
+  ): Promise<AgentSessionDetail> {
+    void options;
+    const owner = this.requireSessionOwner(providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return scopedSession(
+      owner.agentId,
+      await agent.readSession(owner.rawId),
+    );
+  }
+
+  async startSession(input: StartAgentSessionInput): Promise<StartAgentSessionResult> {
+    const agentId = input.agentId;
+    if (!agentId) {
+      throw new AgentRuntimeError('Select an ACP agent before creating the thread.', 'acp');
+    }
+    const agent = await this.agentFor(agentId);
+    const response = await agent.startSession(delegatedSessionInput(input));
+    const session = scopedSession(agentId, response.session);
+    return {
+      ...response,
+      agentId,
+      providerSessionId: session.providerSessionId,
+      model: response.model ?? input.model,
+      reasoningEffort: response.reasoningEffort ?? input.reasoningEffort ?? null,
+      session,
+    };
+  }
+
+  async resumeSession(input: ResumeAgentSessionInput): Promise<StartAgentSessionResult> {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    const response = await agent.resumeSession({
+      ...input,
+      providerSessionId: owner.rawId,
+    });
+    const session = scopedSession(owner.agentId, response.session);
+    return {
+      ...response,
+      agentId: owner.agentId,
+      providerSessionId: session.providerSessionId,
+      model: response.model ?? input.model ?? null,
+      session,
+    };
+  }
+
+  async startTurn(input: StartAgentTurnInput): Promise<AgentTurn> {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.startTurn({
+      ...input,
+      providerSessionId: owner.rawId,
+    });
+  }
+
+  async interruptTurn(input: InterruptAgentTurnInput): Promise<AgentTurn | null> {
+    const owner = this.requireSessionOwner(input.providerSessionId);
+    const agent = await this.agentFor(owner.agentId);
+    return agent.interruptTurn({
+      ...input,
+      providerSessionId: owner.rawId,
+    });
+  }
+
+  mapProviderRequest(
+    request: AgentProviderRequest,
+    options: { approvalMode: 'yolo' | 'guarded' },
+  ): AgentProviderRequestMapping | null {
+    const owner = decodeScopedId(request.id);
+    const agent = owner ? this.agents.get(owner.agentId) : null;
+    if (!owner || !agent) {
+      return null;
+    }
+    const params = request.params && typeof request.params === 'object'
+      ? {
+          ...(request.params as Record<string, unknown>),
+          sessionId: owner.rawId,
+        }
+      : request.params;
+    const mapping = agent.mapProviderRequest({
+      ...request,
+      id: owner.rawId,
+      params,
+    }, options);
+    if (!mapping) {
+      return null;
+    }
+    const providerRequestId = encodeSessionId(owner.agentId, String(mapping.providerRequestId));
+    return {
+      ...mapping,
+      providerRequestId,
+      providerSessionId: encodeSessionId(owner.agentId, mapping.providerSessionId),
+      pendingRequest: mapping.pendingRequest
+        ? {
+            ...mapping.pendingRequest,
+            providerRequestId,
+            request: {
+              ...mapping.pendingRequest.request,
+              id: `acp-permission:${providerRequestId}`,
+            },
+          }
+        : null,
+    };
+  }
+
+  buildProviderRequestResponse(
+    pending: AgentPendingProviderRequest,
+    input: AgentActionRequestResponseInput,
+  ) {
+    const owner = decodeScopedId(pending.providerRequestId);
+    const agent = owner ? this.agents.get(owner.agentId) : null;
+    if (!owner || !agent) {
+      throw new Error('ACP permission request owner is no longer available.');
+    }
+    return agent.buildProviderRequestResponse({
+      ...pending,
+      providerRequestId: owner.rawId,
+    }, input);
+  }
+
+  respondToProviderRequest(id: string | number, result: unknown) {
+    const owner = decodeScopedId(id);
+    const agent = owner ? this.agents.get(owner.agentId) : null;
+    agent?.respondToProviderRequest(owner!.rawId, result);
+  }
+
+  private async refreshCatalog(force = false) {
+    const entries = await this.catalog.list({ force });
+    const ready = entries.filter((entry) => entry.availability === 'ready');
+    const baseInstalled = entries.filter((entry) => entry.availability !== 'base_missing');
+    this.installation.installed = baseInstalled.length > 0;
+    this.installation.installedVersion = ready.length > 0
+      ? `${ready.length} ACP agent${ready.length === 1 ? '' : 's'} ready`
+      : null;
+    this.installation.lastError = ready.length > 0
+      ? null
+      : baseInstalled.length > 0
+        ? 'ACP adapters or native ACP servers are not ready.'
+        : 'No supported base agent was detected.';
+    this.status = {
+      ...this.status,
+      state: ready.length > 0 ? 'ready' : 'degraded',
+      lastStartedAt: this.status.lastStartedAt ?? new Date().toISOString(),
+      lastError: this.installation.lastError,
+    };
+    this.emit('status', this.getStatus());
+    return entries;
+  }
+
+  private async agentFor(agentId: string) {
+    const existing = this.agents.get(agentId);
+    if (existing) {
+      await existing.start();
+      return existing;
+    }
+
+    const entry = (await this.catalog.list()).find((candidate) => candidate.id === agentId);
+    if (!entry) {
+      throw new AgentRuntimeError(`Unknown ACP agent: ${agentId}`, 'acp', 'request_failed');
+    }
+    if (entry.availability !== 'ready') {
+      throw new AgentRuntimeError(entry.statusMessage, 'acp', 'provider_unavailable', {
+        agentId,
+        availability: entry.availability,
+        baseProbeCommand: entry.baseProbeCommand,
+        serverProbeCommand: entry.serverProbeCommand,
+      });
+    }
+
+    const agent = await this.createAgent(entry);
+    this.agents.set(agentId, agent);
+    try {
+      await agent.start();
+      return agent;
+    } catch (error) {
+      this.agents.delete(agentId);
+      throw error;
+    }
+  }
+
+  private async createAgent(entry: AcpAgentCatalogEntry) {
+    const env = entry.id === 'codex'
+      ? await loadCodexAcpEnvironment(
+          this.options.codexHome,
+          process.env,
+          entry.baseCommand,
+        )
+      : undefined;
+    const agent = new AcpRuntimeAdapter({
+      command: entry.serverCommand,
+      ...(env ? { env } : {}),
+      ...(this.options.startupTimeoutMs !== undefined
+        ? { startupTimeoutMs: this.options.startupTimeoutMs }
+        : {}),
+      ...(this.options.clientInfo !== undefined
+        ? { clientInfo: this.options.clientInfo }
+        : {}),
+    });
+    agent.on('event', (event: AgentRuntimeEvent) => {
+      this.emit('event', {
+        ...event,
+        providerSessionId: encodeSessionId(entry.id, event.providerSessionId),
+      } satisfies AgentRuntimeEvent);
+    });
+    agent.on('provider-request', (request: AgentProviderRequest) => {
+      const params = request.params && typeof request.params === 'object'
+        ? {
+            ...(request.params as Record<string, unknown>),
+            sessionId: encodeSessionId(
+              entry.id,
+              String((request.params as Record<string, unknown>).sessionId ?? ''),
+            ),
+          }
+        : request.params;
+      this.emit('provider-request', {
+        ...request,
+        id: encodeSessionId(entry.id, String(request.id)),
+        params,
+      } satisfies AgentProviderRequest);
+    });
+    agent.on('stderr', (message) => this.emit('stderr', `[${entry.id}] ${String(message)}`));
+    agent.on('warning', (message) => this.emit('warning', `[${entry.id}] ${String(message)}`));
+    return agent;
+  }
+
+  private requireSessionOwner(providerSessionId: string) {
+    const owner = decodeScopedId(providerSessionId);
+    if (!owner || !this.catalog.definition(owner.agentId)) {
+      throw new AgentRuntimeError(
+        `ACP session is missing its agent scope: ${providerSessionId}`,
+        'acp',
+        'invalid_response',
+      );
+    }
+    return owner;
+  }
+}
+
+export const acpSessionId = {
+  encode: encodeSessionId,
+  decode: decodeScopedId,
+};

package/packages/acp/src/codex-environment.test.ts

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import { loadCodexAcpEnvironment } from './codex-environment';
+
+describe('loadCodexAcpEnvironment', () => {
+  it('passes the parsed user config to codex-acp without hard-coding context limits', async () => {
+    const codexHome = await fs.mkdtemp(path.join(os.tmpdir(), 'remote-codex-acp-home-'));
+    try {
+      await fs.writeFile(
+        path.join(codexHome, 'config.toml'),
+        [
+          'model = "gpt-5.6-sol"',
+          'model_context_window = 1000000',
+          'model_auto_compact_token_limit = 900000',
+          '',
+          '[features]',
+          'goals = true',
+        ].join('\n'),
+      );
+
+      const env = await loadCodexAcpEnvironment(codexHome, {});
+      expect(env?.CODEX_PATH).toBe('codex');
+      expect(env?.CODEX_HOME).toBe(codexHome);
+      expect(JSON.parse(env?.CODEX_CONFIG ?? '{}')).toEqual({
+        model: 'gpt-5.6-sol',
+        model_context_window: 1_000_000,
+        model_auto_compact_token_limit: 900_000,
+        features: { goals: true },
+      });
+    } finally {
+      await fs.rm(codexHome, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves an explicitly supplied CODEX_CONFIG', async () => {
+    const env = await loadCodexAcpEnvironment('/tmp/codex-home', {
+      CODEX_CONFIG: '{"model_context_window":516000}',
+    });
+
+    expect(env).toEqual({
+      CODEX_PATH: 'codex',
+      CODEX_HOME: '/tmp/codex-home',
+      CODEX_CONFIG: '{"model_context_window":516000}',
+    });
+  });
+
+  it('prefers an explicitly configured Codex executable', async () => {
+    const env = await loadCodexAcpEnvironment(null, {
+      CODEX_PATH: '/opt/codex/bin/codex',
+    });
+
+    expect(env).toEqual({ CODEX_PATH: '/opt/codex/bin/codex' });
+  });
+});

package/packages/acp/src/codex-environment.ts

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { parse } from 'smol-toml';
+
+export async function loadCodexAcpEnvironment(
+  codexHome: string | null | undefined,
+  inheritedEnv: NodeJS.ProcessEnv = process.env,
+  codexPath: string | null | undefined = 'codex',
+): Promise<NodeJS.ProcessEnv | undefined> {
+  const normalizedHome = codexHome?.trim();
+  const normalizedPath = inheritedEnv.CODEX_PATH?.trim() || codexPath?.trim();
+  const env: NodeJS.ProcessEnv = {};
+  if (normalizedPath) {
+    env.CODEX_PATH = normalizedPath;
+  }
+  if (!normalizedHome) {
+    return Object.keys(env).length > 0 ? env : undefined;
+  }
+  env.CODEX_HOME = normalizedHome;
+  if (inheritedEnv.CODEX_CONFIG) {
+    env.CODEX_CONFIG = inheritedEnv.CODEX_CONFIG;
+    return env;
+  }
+
+  try {
+    const source = await fs.readFile(path.join(normalizedHome, 'config.toml'), 'utf8');
+    env.CODEX_CONFIG = JSON.stringify(parse(source));
+  } catch {
+    // Codex can still start with its own defaults when config is absent or invalid.
+  }
+  return env;
+}

package/packages/acp/src/index.ts

@@ -0,0 +1,5 @@
+export * from './agent-catalog';
+export * from './catalog-runtime';
+export * from './item-mapper';
+export * from './runtimeAdapter';
+export * from './terminal-service';