@koreanhole/opencodex 2.95.10 → 2.96.0

package/src/adapters/cli-agent/cline/acp.ts

@@ -1,8 +1,7 @@
-import { execFileSync, spawn as nodeSpawn } from "node:child_process";
+import { spawn as nodeSpawn } from "node:child_process";
 import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
 import type { AdapterEvent, IncomingMeta } from "../../../types";
 import { commandInvocation } from "../../../lib/win-exec";
@@ -10,17 +9,15 @@ import { baseScopedEnv } from "../env";
 import { resolveClineBinary } from "./binary";
 import type { CliAgentStreamState, CliAgentTurnDeps } from "../types";
 import { createClineStreamState, ClineStreamProtocolError, mapClineToolIntent } from "./stream";
+import { AcpClient, AcpError, type AcpClientOptions } from "../acp-client";
 
 const DEFAULT_TIMEOUT_MS = 300_000;
-const DEFAULT_KILL_GRACE_MS = 2_000;
 const MAX_STDERR_BYTES = 8 * 1024;
 const MAX_MODEL_ID_CHARS = 512;
 const MAX_ACP_MODELS = 512;
 const MAX_ACP_CONFIG_OPTIONS = 128;
 const MAX_ACP_OPTION_VALUES = 512;
-const MAX_MCP_SERVERS = 32;
 
-const CLINE_ACP_ARGS = ["--acp"] as const;
 const OPENAI_CODEX_AUTH_IDS = new Set(["openai-codex", "openai-codex-oauth"]);
 const CLINE_AUTH_IDS = new Set(["cline", "cline-oauth"]);
 
@@ -65,7 +62,7 @@ export interface ClineAcpInitialize {
   agentVersion?: string;
 }
 
-export class ClineAcpError extends Error {
+export class ClineAcpError extends AcpError {
   constructor(
     message: string,
     readonly status: number,
@@ -75,7 +72,7 @@ export class ClineAcpError extends Error {
     readonly fallbackAllowed: boolean,
     readonly authRequired = false,
   ) {
-    super(message);
+    super(message, status, errorType, code, retryable, fallbackAllowed, authRequired);
     this.name = "ClineAcpError";
   }
 }
@@ -331,272 +328,9 @@ async function runClineHelp(
   });
 }
 
-function isAuthError(error: unknown): boolean {
-  const message = safeMessage(error);
-  return /auth(?:entication)?\s*(?:required|failed)|not\s+(?:logged|signed)\s+in|sign[ -]?in|login required|unauthorized/i.test(message);
-}
-
-function acpError(error: unknown, fallbackAllowed: boolean): ClineAcpError {
-  const authRequired = isAuthError(error);
-  return new ClineAcpError(
-    safeMessage(error),
-    authRequired ? 401 : 502,
-    authRequired ? "authentication_error" : "upstream_error",
-    authRequired ? "acp_auth_required" : "acp_transport_error",
-    false,
-    fallbackAllowed,
-    authRequired,
-  );
-}
-
-function killWindowsProcessTree(pid: number): void {
-  const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
-  execFileSync(taskkill, ["/PID", String(pid), "/T", "/F"], { stdio: "pipe", windowsHide: true });
-}
-
-export interface ClineAcpClientOptions {
-  binary: string;
-  env: Record<string, string>;
-  cwd: string;
-  args?: readonly string[];
-  hooks?: ClineAcpHooks;
-}
-
-/** One request-scoped ACP child. Cleanup is idempotent and always reaps the process. */
-export class ClineAcpClient {
-  private readonly child: ReturnType<typeof nodeSpawn>;
-  private readonly connection: acp.ClientSideConnection;
-  private readonly processLifecycle: Promise<void>;
-  private readonly stderrChunks: string[] = [];
-  private stderrBytes = 0;
-  private readonly terminateOnce: () => Promise<void>;
-  private terminated = false;
-  private exited = false;
-  sessionId?: string;
-  initializeResult?: ClineAcpInitialize;
-
-  private constructor(
-    child: ReturnType<typeof nodeSpawn>,
-    connection: acp.ClientSideConnection,
-    processLifecycle: Promise<void>,
-    private readonly hooks: ClineAcpHooks,
-    private readonly deps: ClineAcpDeps,
-  ) {
-    this.child = child;
-    this.connection = connection;
-    this.processLifecycle = processLifecycle;
-    this.terminateOnce = async () => {
-      if (this.terminated) return;
-      this.terminated = true;
-      try { this.child.stdin?.end(); } catch { /* already closed */ }
-      if (this.deps.platform === "win32" && this.child.pid !== undefined) {
-        try { (this.deps.killWindowsProcessTree ?? killWindowsProcessTree)(this.child.pid); } catch { /* direct fallback */ }
-      }
-      try { this.child.kill("SIGTERM"); } catch { /* already gone */ }
-      await Promise.race([
-        this.processLifecycle,
-        new Promise<void>(resolve => setTimeout(resolve, this.deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS)),
-      ]);
-      if (this.child.exitCode === null) {
-        try { this.child.kill("SIGKILL"); } catch { /* already gone */ }
-        await Promise.race([
-          this.processLifecycle,
-          new Promise<void>(resolve => setTimeout(resolve, (this.deps.reapTimeoutMs ?? (this.deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS) * 2 + 250))),
-        ]);
-      }
-    };
-  }
-
-  static async connect(
-    options: ClineAcpClientOptions,
-    deps: ClineAcpDeps = {},
-  ): Promise<ClineAcpClient> {
-    const hooks = options.hooks ?? {};
-    const spawnFn = deps.spawn ?? (nodeSpawn as unknown as NonNullable<CliAgentTurnDeps["spawn"]>);
-    const invocation = commandInvocation(options.binary, [...(options.args ?? CLINE_ACP_ARGS)], deps.platform ?? process.platform, { env: options.env });
-    let child: ReturnType<typeof nodeSpawn>;
-    try {
-      child = spawnFn(invocation.file, invocation.args, {
-        ...invocation.options,
-        cwd: options.cwd,
-        env: options.env,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-      });
-    } catch (error) {
-      throw acpError(error, true);
-    }
-    if (!child.stdin || !child.stdout) {
-      try { child.kill("SIGKILL"); } catch { /* ignore */ }
-      throw new ClineAcpError("Cline ACP process did not expose stdio.", 500, "upstream_error", "acp_spawn_failed", false, true);
-    }
-    const processLifecycle = new Promise<void>(resolvePromise => {
-      let settled = false;
-      const settle = (): void => {
-        if (settled) return;
-        settled = true;
-        resolvePromise();
-      };
-      child.once("error", settle);
-      child.once("close", settle);
-      if (child.exitCode !== null) settle();
-    });
-    let instance: ClineAcpClient;
-    const client: acp.Client = {
-      requestPermission: async params => {
-        hooks.onPermission?.(params);
-        if (instance?.sessionId) void instance.cancel(instance.sessionId).catch(() => undefined);
-        return { outcome: { outcome: "cancelled" } };
-      },
-      sessionUpdate: async notification => {
-        if (notification.sessionId === instance?.sessionId) hooks.onSessionUpdate?.(notification);
-      },
-    };
-    const stream = acp.ndJsonStream(
-      Writable.toWeb(child.stdin) as WritableStream<Uint8Array>,
-      Readable.toWeb(child.stdout) as unknown as ReadableStream<Uint8Array>,
-    );
-    const connection = new acp.ClientSideConnection(() => client, stream);
-    instance = new ClineAcpClient(child, connection, processLifecycle, hooks, deps);
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk: string) => {
-      if (instance.stderrBytes >= MAX_STDERR_BYTES) return;
-      const remaining = MAX_STDERR_BYTES - instance.stderrBytes;
-      const admitted = chunk.slice(0, remaining);
-      instance.stderrChunks.push(admitted);
-      instance.stderrBytes += admitted.length;
-      hooks.onStderr?.(admitted);
-    });
-    child.once("close", () => { instance.exited = true; });
-    try {
-      const initialize = await deadline(
-        connection.initialize({
-          protocolVersion: acp.PROTOCOL_VERSION,
-          clientCapabilities: {},
-          clientInfo: { name: "opencodex", version: "1.0.0" },
-        }),
-        deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        () => instance.terminate(),
-      );
-      instance.initializeResult = parseClineAcpInitialize(initialize);
-      return instance;
-    } catch (error) {
-      await instance.terminate();
-      if (error instanceof ClineAcpError) {
-        if (error.code === "timeout") {
-          throw new ClineAcpError(error.message, error.status, error.errorType, error.code, error.retryable, true);
-        }
-        throw error;
-      }
-      throw acpError(error, true);
-    }
-  }
-
-  stderrText(): string {
-    return this.stderrChunks.join("");
-  }
-
-  async newSession(params: {
-    cwd: string;
-    mcpServers: readonly Record<string, unknown>[];
-  }): Promise<ClineAcpSessionInfo> {
-    try {
-      const response = await deadline(
-        this.connection.request<unknown>(acp.AGENT_METHODS.session_new, {
-          cwd: params.cwd,
-          mcpServers: params.mcpServers.slice(0, MAX_MCP_SERVERS),
-        }),
-        this.deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        () => this.terminate(),
-      );
-      const session = parseClineAcpSession(response);
-      this.sessionId = session.sessionId;
-      return session;
-    } catch (error) {
-      if (error instanceof ClineAcpError) {
-        if (error.code === "timeout") {
-          throw new ClineAcpError(error.message, error.status, error.errorType, error.code, error.retryable, true);
-        }
-        throw error;
-      }
-      throw acpError(error, true);
-    }
-  }
-
-  async setModel(sessionId: string, modelId: string): Promise<void> {
-    await deadline(
-      this.connection.request("session/set_model", { sessionId, modelId }),
-      this.deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      () => this.terminate(),
-    ).catch(error => {
-      if (error instanceof ClineAcpError) throw error;
-      throw new ClineAcpError("Cline ACP rejected session/set_model.", 502, "upstream_error", "acp_transport_error", false, false);
-    });
-  }
-
-  async setConfigOption(sessionId: string, configId: string, value: string): Promise<void> {
-    await deadline(
-      this.connection.request(acp.AGENT_METHODS.session_set_config_option, {
-        sessionId,
-        configId,
-        value,
-      }),
-      this.deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      () => this.terminate(),
-    ).catch(error => {
-      if (error instanceof ClineAcpError) throw error;
-      throw new ClineAcpError("Cline ACP rejected session/set_config_option.", 502, "upstream_error", "acp_transport_error", false, false);
-    });
-  }
-
-  async authenticate(methodId: string): Promise<void> {
-    await deadline(
-      this.connection.authenticate({ methodId }),
-      this.deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      () => this.terminate(),
-    ).catch(error => {
-      if (error instanceof ClineAcpError) throw error;
-      throw acpError(error, false);
-    });
-  }
-
-  async prompt(sessionId: string, text: string, cancellationSignal?: AbortSignal): Promise<acp.PromptResponse> {
-    return await deadline(
-      this.connection.request(
-        acp.AGENT_METHODS.session_prompt,
-        { sessionId, prompt: [{ type: "text" as const, text }] },
-        { ...(cancellationSignal ? { cancellationSignal } : {}) },
-      ),
-      this.deps.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      () => this.terminate(),
-    );
-  }
-
-  async cancel(sessionId: string): Promise<void> {
-    if (this.exited) return;
-    await this.connection.cancel({ sessionId });
-  }
-
-  async terminate(): Promise<void> {
-    await this.terminateOnce();
-  }
-}
-
-async function deadline<T>(promise: Promise<T>, ms: number, onTimeout: () => Promise<void>): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => {
-      void onTimeout().catch(() => undefined);
-      reject(new ClineAcpError("Cline ACP request timed out.", 504, "upstream_error", "timeout", true, false));
-    }, ms);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
+export type ClineAcpClientOptions = AcpClientOptions;
 
+export const ClineAcpClient = AcpClient;
 export function selectClineAuthMethod(methods: readonly ClineAcpAuthMethod[]): ClineAcpAuthMethod | undefined {
   const byId = new Map(methods.map(method => [method.id.toLowerCase(), method]));
   for (const id of ["cline", "cline-oauth", "openai-codex", "openai-codex-oauth"]) {
@@ -635,13 +369,15 @@ export async function loginClineAcp(options: ClineAcpLoginOptions = {}): Promise
   }
   const workspace = await stageClineAcpWorkspace();
   let instructions = "";
-  let client: ClineAcpClient | undefined;
+  let client: AcpClient | undefined;
   try {
-    client = await ClineAcpClient.connect({
+    client = await AcpClient.connect({
       binary,
       env,
       cwd: workspace.cwd,
       args: mode.autoApproveFlag ? ["--acp", "--auto-approve", "false"] : ["--acp"],
+      label: "Cline ACP",
+      fallbackAllowed: true,
       hooks: {
         onStderr: text => {
           instructions = (instructions + text).slice(0, MAX_STDERR_BYTES);
@@ -751,7 +487,7 @@ function unsupportedModel(modelId: string): ClineAcpError {
   );
 }
 
-export async function applyClineAcpModel(client: ClineAcpClient, session: ClineAcpSessionInfo, modelId: string): Promise<void> {
+export async function applyClineAcpModel(client: AcpClient, session: ClineAcpSessionInfo, modelId: string): Promise<void> {
   if (modelId === "default") return;
   if (session.availableModels.length > 0) {
     if (!session.availableModels.some(model => model.modelId === modelId)) throw unsupportedModel(modelId);
@@ -783,7 +519,7 @@ export async function runClineAcpTurn(
 ): Promise<void> {
   const deps = input.deps ?? {};
   const state = createClineStreamState();
-  let client: ClineAcpClient | undefined;
+  let client: AcpClient | undefined;
   let session: ClineAcpSessionInfo | undefined;
   let terminalEmitted = false;
   let sawOutput = false;
@@ -857,7 +593,7 @@ export async function runClineAcpTurn(
   };
 
   try {
-    client = await ClineAcpClient.connect({ binary: input.binary, env: input.env, cwd: input.cwd, hooks, ...(input.args ? { args: input.args } : {}) }, deps);
+    client = await AcpClient.connect({ binary: input.binary, env: input.env, cwd: input.cwd, hooks, label: "Cline ACP", fallbackAllowed: true, ...(input.args ? { args: input.args } : {}) }, deps);
     session = await client.newSession({ cwd: input.cwd, mcpServers: input.mcpServers });
     await applyClineAcpModel(client, session, input.modelId);
 
@@ -941,13 +677,13 @@ export async function runClineAcpTurn(
       });
     }
   } catch (error) {
-    if (error instanceof ClineAcpError && error.fallbackAllowed && !sawOutput) throw error;
+    if (error instanceof AcpError && error.fallbackAllowed && !sawOutput) throw error;
     if (!terminalEmitted) {
       const failure = timedOut
         ? new ClineAcpError("Cline ACP turn timed out.", 504, "upstream_error", "timeout", true, false)
         : aborted
           ? new ClineAcpError("Cline ACP turn was cancelled.", 499, "invalid_request_error", "client_cancelled", false, false)
-          : error instanceof ClineAcpError
+          : error instanceof AcpError
         ? error
         : new ClineAcpError(
             safeMessage(error),

package/src/adapters/cli-agent/cline/adapter.ts

@@ -21,7 +21,6 @@ import {
 import { resolveClineBinary } from "./binary";
 import {
   buildClineAcpEnv,
-  ClineAcpError,
   probeClineAcpSupport,
   runClineAcpTurn,
   stageClineAcpWorkspace,
@@ -30,6 +29,7 @@ import {
   type ClineAcpTurnInput,
 } from "./acp";
 import { classifyClineFailure, createClineStreamState, mapClineMessage } from "./stream";
+import { AcpError } from "../acp-client";
 
 export const CLINE_CLI_BASE_URL = "https://api.cline.bot";
 export const CLINE_CLI_MODEL_ID = "default";
@@ -140,7 +140,7 @@ function settingsError(error: unknown): Extract<AdapterEvent, { type: "error" }>
 }
 
 function acpFailure(error: unknown): Extract<AdapterEvent, { type: "error" }> {
-  if (error instanceof ClineAcpError) {
+  if (error instanceof AcpError) {
     return {
       type: "error",
       message: error.message,
@@ -254,7 +254,7 @@ export async function runClineTurn(
         }, acpEmit, acpDeps);
         return;
       } catch (error) {
-        if (!(error instanceof ClineAcpError && error.fallbackAllowed && !acpOutput && requestedModel === "default")) {
+        if (!(error instanceof AcpError && error.fallbackAllowed && !acpOutput && requestedModel === "default")) {
           emit(acpFailure(error));
           return;
         }

package/src/adapters/cli-agent/cline/live-models.ts

@@ -1,6 +1,4 @@
 import {
-  ClineAcpClient,
-  ClineAcpError,
   buildClineAcpEnv,
   clineAcpEnabled,
   clineModelSource,
@@ -9,6 +7,7 @@ import {
   type ClineAcpDeps,
 } from "./acp";
 import { clineBinaryFingerprintSync, resolveClineBinary } from "./binary";
+import { AcpClient, AcpError } from "../acp-client";
 
 export type ClineLiveModelsFailure = "not_found" | "unsupported" | "auth_required" | "backoff" | "transport";
 
@@ -94,13 +93,15 @@ export async function discoverClineLiveModels(options: ClineLiveModelsOptions =
       ?? { ok: false, reason: "unsupported", detail: "Cline --help does not advertise --acp.", fingerprint };
   }
   const workspace = await stageClineAcpWorkspace();
-  let client: ClineAcpClient | undefined;
+  let client: AcpClient | undefined;
   try {
-    client = await ClineAcpClient.connect({
+    client = await AcpClient.connect({
       binary,
       env,
       cwd: workspace.cwd,
       args: mode.autoApproveFlag ? ["--acp", "--auto-approve", "false"] : ["--acp"],
+      label: "Cline ACP",
+      fallbackAllowed: true,
     }, options.deps);
     const session = await client.newSession({ cwd: workspace.cwd, mcpServers: [] });
     const discovered = clineModelSource(session);
@@ -111,7 +112,7 @@ export async function discoverClineLiveModels(options: ClineLiveModelsOptions =
     failureCache.set(fingerprint, timestamp);
     if (current) current.lastFailureAt = timestamp;
     const stale = staleResult(fingerprint, current);
-    if (error instanceof ClineAcpError && error.authRequired) {
+    if (error instanceof AcpError && error.authRequired) {
       return stale ?? { ok: false, reason: "auth_required", detail: error.message, fingerprint };
     }
     return stale ?? {

package/src/adapters/cli-agent/cline/stream.ts

@@ -1,8 +1,7 @@
-import { Buffer } from "node:buffer";
 import type { AdapterEvent, OcxUsage } from "../../../types";
 import type { CliAgentStreamState } from "../types";
+import { mapToolIntent, ToolIntentError } from "../tool-intent";
 
-const MAX_TOOL_ARGUMENT_BYTES = 2 * 1024 * 1024;
 const MAX_ERROR_CHARS = 2_048;
 
 export class ClineStreamProtocolError extends Error {
@@ -86,24 +85,6 @@ function usageFrom(value: unknown): OcxUsage | undefined {
   };
 }
 
-function toolArguments(input: unknown): string {
-  let value = input;
-  if (typeof value === "string") {
-    try {
-      value = JSON.parse(value);
-    } catch {
-      throw new ClineStreamProtocolError("Cline returned a tool call with invalid JSON arguments.");
-    }
-  }
-  const record = asRecord(value ?? {});
-  if (!record) throw new ClineStreamProtocolError("Cline returned non-object tool arguments.");
-  const serialized = JSON.stringify(record);
-  if (Buffer.byteLength(serialized) > MAX_TOOL_ARGUMENT_BYTES) {
-    throw new ClineStreamProtocolError("Cline returned tool arguments above the byte limit.");
-  }
-  return serialized;
-}
-
 /** Map a validated tool intent from either Cline's NDJSON or ACP event shape. */
 export function mapClineToolIntent(
   vendorName: string,
@@ -112,24 +93,12 @@ export function mapClineToolIntent(
   state: CliAgentStreamState,
   options: ClineStreamOptions,
 ): AdapterEvent[] {
-  if (!vendorName) throw new ClineStreamProtocolError("Cline returned a tool call without a name.");
-  const wireName = options.toolNames.get(vendorName);
-  if (!wireName) {
-    throw new ClineStreamProtocolError(`Cline returned an undeclared tool: ${vendorName.slice(0, 128)}`);
-  }
-  const maxToolCalls = options.maxToolCalls ?? 16;
-  if (state.toolCalls >= maxToolCalls) {
-    throw new ClineStreamProtocolError("Cline exceeded the per-turn tool-call limit.");
+  try {
+    return mapToolIntent("Cline", vendorName, toolCallId, input, state, options);
+  } catch (error) {
+    if (error instanceof ToolIntentError) throw new ClineStreamProtocolError(error.message);
+    throw error;
   }
-  const ordinal = ++state.nextToolOrdinal;
-  const id = toolCallId?.trim() || `cline-tool-${ordinal}`;
-  const argumentsJson = toolArguments(input);
-  state.toolCalls++;
-  return [
-    { type: "tool_call_start", id, name: wireName },
-    { type: "tool_call_delta", arguments: argumentsJson },
-    { type: "tool_call_end" },
-  ];
 }
 
 function mapToolCall(