remote-codex 0.11.45 → 0.11.49

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

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+
+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({
+      sessionId: 'session-1',
+      command: `"${process.execPath}" -e "process.stdout.write('ACP_TERMINAL_OK')"`,
+      args: [],
+      outputByteLimit: 1_000,
+    });
+    const exit = await service.waitForExit({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+    const output = service.output({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+
+    expect(exit.exitCode).toBe(0);
+    expect(output.output).toBe('ACP_TERMINAL_OK');
+    expect(output.truncated).toBe(false);
+    service.release({
+      sessionId: 'session-1',
+      terminalId: created.terminalId,
+    });
+  });
+});

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

@@ -0,0 +1,137 @@
+import type { ChildProcess } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+import type * as acp from '@agentclientprotocol/sdk';
+
+import {
+  parseCommandLine,
+  spawnProcess,
+} from '../../process-runtime/src/index';
+
+const DEFAULT_OUTPUT_BYTE_LIMIT = 1024 * 1024;
+
+interface AcpTerminalState {
+  child: ChildProcess;
+  chunks: Buffer[];
+  outputByteLimit: number;
+  exitStatus: acp.TerminalExitStatus | null;
+  exitPromise: Promise<acp.WaitForTerminalExitResponse>;
+  resolveExit: (status: acp.WaitForTerminalExitResponse) => void;
+}
+
+function retainedOutput(state: AcpTerminalState) {
+  const complete = Buffer.concat(state.chunks);
+  if (complete.byteLength <= state.outputByteLimit) {
+    return { output: complete.toString('utf8'), truncated: false };
+  }
+
+  let start = complete.byteLength - state.outputByteLimit;
+  while (start < complete.byteLength && (complete[start]! & 0xc0) === 0x80) {
+    start += 1;
+  }
+  return {
+    output: complete.subarray(start).toString('utf8'),
+    truncated: true,
+  };
+}
+
+export class AcpTerminalService {
+  private readonly terminals = new Map<string, AcpTerminalState>();
+
+  constructor(private readonly sessionCwd: (sessionId: string) => string | null) {}
+
+  create(params: acp.CreateTerminalRequest): acp.CreateTerminalResponse {
+    const terminalId = randomUUID();
+    const cwd = params.cwd ?? this.sessionCwd(params.sessionId) ?? process.cwd();
+    const parsed = params.args && params.args.length > 0
+      ? { command: params.command, args: params.args }
+      : parseCommandLine(params.command);
+    const child = spawnProcess({
+      command: parsed.command,
+      args: parsed.args,
+      cwd,
+      env: {
+        ...process.env,
+        ...Object.fromEntries((params.env ?? []).map((entry) => [entry.name, entry.value])),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let resolveExit!: (status: acp.WaitForTerminalExitResponse) => void;
+    const exitPromise = new Promise<acp.WaitForTerminalExitResponse>((resolve) => {
+      resolveExit = resolve;
+    });
+    const state: AcpTerminalState = {
+      child,
+      chunks: [],
+      outputByteLimit: Math.max(1, params.outputByteLimit ?? DEFAULT_OUTPUT_BYTE_LIMIT),
+      exitStatus: null,
+      exitPromise,
+      resolveExit,
+    };
+    this.terminals.set(terminalId, state);
+
+    const append = (chunk: Buffer | string) => {
+      state.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (error) => append(`${error.message}\n`));
+    child.on('close', (code, signal) => {
+      const exitStatus: acp.TerminalExitStatus = {
+        exitCode: code,
+        signal,
+      };
+      state.exitStatus = exitStatus;
+      state.resolveExit(exitStatus);
+    });
+
+    return { terminalId };
+  }
+
+  output(params: acp.TerminalOutputRequest): acp.TerminalOutputResponse {
+    const state = this.require(params.terminalId);
+    const output = retainedOutput(state);
+    return {
+      ...output,
+      ...(state.exitStatus ? { exitStatus: state.exitStatus } : {}),
+    };
+  }
+
+  waitForExit(params: acp.WaitForTerminalExitRequest) {
+    return this.require(params.terminalId).exitPromise;
+  }
+
+  kill(params: acp.KillTerminalRequest): acp.KillTerminalResponse {
+    const state = this.require(params.terminalId);
+    if (!state.exitStatus) {
+      state.child.kill('SIGTERM');
+    }
+    return {};
+  }
+
+  release(params: acp.ReleaseTerminalRequest): acp.ReleaseTerminalResponse {
+    const state = this.require(params.terminalId);
+    if (!state.exitStatus) {
+      state.child.kill('SIGTERM');
+    }
+    this.terminals.delete(params.terminalId);
+    return {};
+  }
+
+  stop() {
+    for (const state of this.terminals.values()) {
+      if (!state.exitStatus) {
+        state.child.kill('SIGTERM');
+      }
+    }
+    this.terminals.clear();
+  }
+
+  private require(terminalId: string) {
+    const state = this.terminals.get(terminalId);
+    if (!state) {
+      throw new Error(`ACP terminal not found: ${terminalId}`);
+    }
+    return state;
+  }
+}

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

@@ -73,6 +73,7 @@ export function isRemoteThreadBootstrapError(error: unknown) {
   }
 
   return (
+    (isRecord(error.details) && error.details.historyUnavailable === true) ||
     error.message.includes('includeTurns is unavailable before first user message') ||
     error.message.includes('is not materialized yet') ||
     error.message.includes('no rollout found for thread id') ||

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

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
 import type {
+  AcpAgentOptionMetadataDto,
   AgentBackendIdDto,
   AgentBackendInstallationDto,
   ThreadHistoryItemDto,
@@ -159,6 +160,8 @@ export interface AgentModel {
     description: string;
   }>;
   defaultReasoningEffort: string | null;
+  selectionKind?: 'model' | 'agent';
+  acpAgent?: AcpAgentOptionMetadataDto | null;
 }
 
 export type AgentSessionStatus =
@@ -228,6 +231,7 @@ export interface ReadAgentSessionOptions {
 
 export interface StartAgentSessionInput {
   cwd: string;
+  agentId?: string | null;
   model: string;
   reasoningEffort?: string | null;
   approvalMode: 'yolo' | 'guarded';
@@ -237,6 +241,7 @@ export interface StartAgentSessionInput {
 
 export interface StartAgentSessionResult {
   provider: AgentProviderId;
+  agentId?: string | null;
   providerSessionId: string;
   model: string | null;
   reasoningEffort?: string | null;
@@ -549,6 +554,8 @@ export interface AgentRuntime extends EventEmitter {
   stop(): Promise<void>;
 
   listModels(): Promise<AgentModel[]>;
+  listAgentOptions?(): Promise<AgentModel[]>;
+  listModelsForAgent?(agentId: string, cwd: string): Promise<AgentModel[]>;
   listSessions(): Promise<AgentSessionSummary[]>;
   listLoadedSessions(): Promise<string[]>;
   readSession(
@@ -582,6 +589,7 @@ export interface AgentRuntime extends EventEmitter {
   getGoal?(providerSessionId: string): Promise<AgentGoal | null>;
   setGoal?(input: SetAgentGoalInput): Promise<AgentGoal>;
   clearGoal?(providerSessionId: string): Promise<boolean>;
+  installModel?(modelId: string): Promise<void>;
   getSubscriptionUsage?(): Promise<{
     provider: 'codex' | 'claude';
     authKind: 'subscription' | 'apiKey' | 'unknown';

package/packages/db/migrations/0030_thread_agent_id.sql

@@ -0,0 +1,9 @@
+ALTER TABLE threads ADD COLUMN agent_id TEXT;
+
+UPDATE threads
+SET agent_id = model,
+    model = NULL
+WHERE provider = 'acp'
+  AND agent_id IS NULL
+  AND model IS NOT NULL
+  AND provider_session_id LIKE model || '::%';

package/packages/db/src/repositories.ts

@@ -29,6 +29,7 @@ export interface CreateThreadRecordInput {
   workspaceId: string;
   title: string;
   provider?: string;
+  agentId?: string | null;
   providerSessionId: string | null;
   providerTurnId?: string | null;
   model?: string | null;
@@ -47,6 +48,7 @@ export interface CreateThreadRecordInput {
 
 export interface UpdateThreadRecordInput {
   provider?: string;
+  agentId?: string | null;
   providerSessionId?: string | null;
   providerTurnId?: string | null;
   title?: string;
@@ -278,6 +280,7 @@ export function createThreadRecord(db: DatabaseClient, input: CreateThreadRecord
     id: randomUUID(),
     workspaceId: input.workspaceId,
     provider: input.provider ?? 'codex',
+    agentId: input.agentId ?? null,
     providerSessionId: input.providerSessionId,
     providerTurnId: input.providerTurnId ?? null,
     source: input.source ?? 'supervisor',

package/packages/db/src/schema.ts

@@ -23,6 +23,7 @@ export const threads = sqliteTable('threads', {
   id: text('id').primaryKey(),
   workspaceId: text('workspace_id').notNull(),
   provider: text('provider').notNull().default('codex'),
+  agentId: text('agent_id'),
   providerSessionId: text('provider_session_id'),
   providerTurnId: text('provider_turn_id'),
   source: text('source').notNull().default('supervisor'),

package/packages/shared/src/agent-providers.ts

@@ -1,4 +1,4 @@
-export const agentBackendIds = ['codex', 'claude', 'opencode'] as const;
+export const agentBackendIds = ['codex', 'claude', 'opencode', 'acp'] as const;
 
 export type AgentBackendIdDto = (typeof agentBackendIds)[number];
 
@@ -42,6 +42,15 @@ export const agentBackendMetadata: Record<AgentBackendIdDto, AgentBackendMetadat
     defaultHomeDir: '.opencode',
     defaultCommand: 'opencode',
   },
+  acp: {
+    displayName: 'ACP Agent',
+    description: 'Agent Client Protocol runtime over stdio.',
+    defaultTransport: 'stdio',
+    homeEnvVar: 'ACP_HOME',
+    commandEnvVar: 'ACP_COMMAND',
+    defaultHomeDir: '.acp',
+    defaultCommand: 'grok agent stdio',
+  },
 };
 
 export function isAgentBackendId(value: unknown): value is AgentBackendIdDto {

package/packages/shared/src/index.ts

@@ -716,6 +716,28 @@ export interface ModelOptionDto {
   supportsPerformanceMode?: boolean;
   supportedReasoningEfforts: ReasoningEffortOptionDto[];
   defaultReasoningEffort: ReasoningEffortDto | null;
+  selectionKind?: 'model' | 'agent';
+  acpAgent?: AcpAgentOptionMetadataDto | null;
+}
+
+export type AcpAgentAvailabilityDto =
+  | 'ready'
+  | 'base_missing'
+  | 'adapter_missing'
+  | 'server_unavailable';
+
+export interface AcpAgentOptionMetadataDto {
+  transport: 'native' | 'adapter' | 'custom';
+  availability: AcpAgentAvailabilityDto;
+  baseCommand: string;
+  baseProbeCommand: string;
+  serverCommand: string;
+  serverProbeCommand: string;
+  baseVersion: string | null;
+  serverVersion: string | null;
+  installCommand: string | null;
+  busy: boolean;
+  statusMessage: string;
 }
 
 export interface VersionDto {
@@ -929,6 +951,7 @@ export interface ThreadDto {
   id: string;
   workspaceId: string;
   provider: AgentBackendIdDto;
+  agentId?: string | null;
   providerSessionId: string | null;
   source: ThreadSourceDto;
   title: string;
@@ -1594,6 +1617,7 @@ export interface CreateThreadInput {
   workspaceId: string;
   title?: string;
   provider?: AgentBackendIdDto;
+  agentId?: string;
   model: string;
   reasoningEffort?: ReasoningEffortDto | null;
   approvalMode: ApprovalMode;

package/scripts/windows/build-device-manager.ps1

@@ -0,0 +1,64 @@
+[CmdletBinding()]
+param(
+  [string]$Configuration = 'Release',
+  [string]$Runtime = 'win-x64',
+  [string]$OutputPath = (Join-Path (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path 'artifacts\windows-device-manager\win-x64')
+)
+
+$ErrorActionPreference = 'Stop'
+$repositoryRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
+$projectPath = Join-Path $repositoryRoot 'apps\windows-device-manager\RemoteCodex.DeviceManager.csproj'
+$productManifestPath = Join-Path $repositoryRoot 'apps\windows-device-manager\ProductManifest.cs'
+$dotnet = (Get-Command dotnet.exe -ErrorAction SilentlyContinue)
+if (-not $dotnet) {
+  $dotnet = (Get-Command dotnet -ErrorAction Stop)
+}
+
+$packageVersion = (Get-Content -LiteralPath (Join-Path $repositoryRoot 'package.json') -Raw | ConvertFrom-Json).version
+$productManifest = Get-Content -LiteralPath $productManifestPath -Raw
+if ($productManifest -notmatch ('RemoteCodexVersion\s*=\s*"{0}"' -f [Regex]::Escape($packageVersion))) {
+  throw "ProductManifest.RemoteCodexVersion must match package.json version $packageVersion."
+}
+
+& $dotnet.Source publish $projectPath `
+  --configuration $Configuration `
+  --runtime $Runtime `
+  --self-contained true `
+  -p:PublishSingleFile=true `
+  --output $OutputPath
+if ($LASTEXITCODE -ne 0) {
+  throw "dotnet publish failed with exit code $LASTEXITCODE."
+}
+
+$executable = Join-Path $OutputPath 'RemoteCodex.DeviceManager.exe'
+if (-not (Test-Path -LiteralPath $executable -PathType Leaf)) {
+  throw "Published executable was not found: $executable"
+}
+
+$selfTest = Start-Process -FilePath $executable -ArgumentList '--self-test' -Wait -PassThru
+if ($selfTest.ExitCode -ne 0) {
+  $selfTestLog = Join-Path $env:LOCALAPPDATA 'RemoteCodex\logs\device-manager.log'
+  if (Test-Path -LiteralPath $selfTestLog -PathType Leaf) {
+    Write-Host 'Self-test diagnostics:'
+    Get-Content -LiteralPath $selfTestLog -Tail 50
+  }
+  throw "Remote Codex Device self-test failed with exit code $($selfTest.ExitCode)."
+}
+
+$previewPath = Join-Path $OutputPath 'RemoteCodex.DeviceManager.preview.png'
+$previewTest = Start-Process `
+  -FilePath $executable `
+  -ArgumentList @('--render-preview', ('"{0}"' -f $previewPath)) `
+  -Wait `
+  -PassThru
+if ($previewTest.ExitCode -ne 0 -or -not (Test-Path -LiteralPath $previewPath -PathType Leaf)) {
+  throw "Remote Codex Device preview render failed with exit code $($previewTest.ExitCode)."
+}
+
+$hash = Get-FileHash -LiteralPath $executable -Algorithm SHA256
+$hashLine = '{0}  {1}' -f $hash.Hash.ToLowerInvariant(), (Split-Path -Leaf $executable)
+$hashPath = Join-Path $OutputPath 'RemoteCodex.DeviceManager.exe.sha256'
+[IO.File]::WriteAllText($hashPath, "$hashLine`n", [Text.UTF8Encoding]::new($false))
+
+Write-Host "Built: $executable"
+Write-Host "SHA-256: $($hash.Hash.ToLowerInvariant())"