@koreanhole/opencodex 2.95.10 → 2.96.0

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

@@ -0,0 +1,629 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import * as acp from "@agentclientprotocol/sdk";
+import type { AdapterEvent, IncomingMeta, OcxUsage } from "../../../types";
+import { commandInvocation } from "../../../lib/win-exec";
+import { baseScopedEnv } from "../env";
+import type { CliAgentStreamState, CliAgentTurnDeps } from "../types";
+import { mapToolIntent, ToolIntentError } from "../tool-intent";
+import {
+  AcpClient,
+  AcpError,
+  parseAcpInitialize,
+  parseAcpSession,
+  safeAcpMessage,
+  type AcpDeps,
+  type AcpHooks,
+  type AcpInitialize,
+  type AcpModel,
+  type AcpSessionInfo,
+} from "../acp-client";
+
+const DEFAULT_TIMEOUT_MS = 300_000;
+const MAX_STDERR_BYTES = 8 * 1024;
+const MAX_CAPTURE_FILE_BYTES = 4 * 1024 * 1024;
+const CAPTURE_POLL_MS = 25;
+const GEMINI_POLICY = [
+  "[[rule]]",
+  'toolName = "mcp_*"',
+  'decision = "allow"',
+  "priority = 999",
+  "",
+  "[[rule]]",
+  'toolName = "*"',
+  'decision = "deny"',
+  "priority = 998",
+  "",
+].join("\n");
+
+const GEMINI_SYSTEM_SETTINGS = JSON.stringify({
+  hooksConfig: { enabled: false },
+  skills: { enabled: false },
+  admin: {
+    secureModeEnabled: true,
+    extensions: { enabled: false },
+    skills: { enabled: false },
+  },
+}, null, 2) + "\n";
+
+const FORWARDED_ENV_KEYS = [
+  "XDG_CONFIG_HOME",
+  "XDG_CACHE_HOME",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_GENAI_USE_VERTEXAI",
+  "GOOGLE_GENAI_USE_GCA",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_LOCATION",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_GEMINI_BASE_URL",
+  "GEMINI_API_KEY_AUTH_MECHANISM",
+  "GOOGLE_GENAI_API_VERSION",
+  "GEMINI_SYSTEM_MD",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "ALL_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+] as const;
+
+export { AcpError as GeminiAcpError };
+export type GeminiAcpModel = AcpModel;
+export type GeminiAcpSessionInfo = AcpSessionInfo;
+export type GeminiAcpInitialize = AcpInitialize;
+export type GeminiAcpHooks = AcpHooks;
+export type GeminiAcpDeps = AcpDeps;
+
+export interface GeminiAcpMode {
+  acp: boolean;
+}
+const MODE_CACHE = new Map<string, { mtimeMs: number; size: number; acp: boolean }>();
+
+function nonEmpty(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+export function geminiAcpEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.OPENCODEX_GEMINI_ACP?.trim() !== "0";
+}
+
+export function parseGeminiAcpSession(response: unknown): GeminiAcpSessionInfo {
+  return parseAcpSession(response, "Gemini ACP", false);
+}
+
+export function parseGeminiAcpInitialize(value: unknown): GeminiAcpInitialize {
+  return parseAcpInitialize(value, "Gemini ACP", false);
+}
+
+export function geminiModelIds(session: GeminiAcpSessionInfo): string[] {
+  return session.availableModels.length > 0
+    ? [...new Set(session.availableModels.map(model => model.modelId))]
+    : ["default"];
+}
+
+/** Probe Gemini's documented ACP switch with a bounded help command. */
+export async function probeGeminiAcpSupport(
+  binary: string,
+  env: Record<string, string>,
+  deps: GeminiAcpDeps = {},
+): Promise<GeminiAcpMode> {
+  if (!geminiAcpEnabled(deps.env ?? process.env)) return { acp: false };
+  const key = resolve(binary);
+  let mtimeMs: number | undefined;
+  let size: number | undefined;
+  try {
+    const value = await stat(key);
+    mtimeMs = value.mtimeMs;
+    size = value.size;
+  } catch {
+    return { acp: false };
+  }
+  const cached = MODE_CACHE.get(key);
+  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) return { acp: cached.acp };
+  const help = await runGeminiHelp(binary, env, deps);
+  const supported = /(?:^|\s)--acp(?:\s|,|<|$)/.test(help);
+  MODE_CACHE.set(key, { mtimeMs, size, acp: supported });
+  return { acp: supported };
+}
+
+async function runGeminiHelp(binary: string, env: Record<string, string>, deps: GeminiAcpDeps): Promise<string> {
+  return await new Promise((resolvePromise, reject) => {
+    const invocation = commandInvocation(binary, ["--help"], deps.platform ?? process.platform, { env });
+    const spawnFn = deps.spawn ?? (nodeSpawn as unknown as NonNullable<CliAgentTurnDeps["spawn"]>);
+    const child = spawnFn(invocation.file, invocation.args, {
+      ...invocation.options,
+      cwd: homedir(),
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    const chunks: string[] = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (fn: () => void): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const timer = setTimeout(() => {
+      try { child.kill("SIGKILL"); } catch { /* ignore */ }
+      finish(() => reject(new Error("Gemini --help probe timed out.")));
+    }, deps.timeoutMs ?? 15_000);
+    const collect = (chunk: Buffer): void => {
+      if (bytes >= MAX_STDERR_BYTES) return;
+      const admitted = chunk.subarray(0, MAX_STDERR_BYTES - bytes);
+      chunks.push(admitted.toString("utf8"));
+      bytes += admitted.byteLength;
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    child.once("error", error => finish(() => reject(error)));
+    child.once("close", () => finish(() => resolvePromise(chunks.join(""))));
+  });
+}
+
+/** Build the Gemini ACP environment while leaving vendor auth in its real home. */
+export function buildGeminiAcpEnv(sourceEnv: NodeJS.ProcessEnv = process.env): Record<string, string> {
+  const env = baseScopedEnv();
+  const realHome = nonEmpty(sourceEnv.HOME) ?? nonEmpty(sourceEnv.USERPROFILE) ?? homedir();
+  env.HOME = realHome;
+  env.USERPROFILE = realHome;
+  for (const key of FORWARDED_ENV_KEYS) {
+    const value = nonEmpty(sourceEnv[key]);
+    if (value) env[key] = value;
+  }
+  Object.assign(env, {
+    GEMINI_CLI_NO_RELAUNCH: "1",
+    GEMINI_TELEMETRY_ENABLED: "false",
+    NO_UPDATE_NOTIFIER: "1",
+    NO_COLOR: "1",
+  });
+  return env;
+}
+
+export interface GeminiAcpWorkspace {
+  cwd: string;
+  policyPath: string;
+  settingsPath: string;
+  catalogPath: string;
+  capturePath?: string;
+  cleanup: () => Promise<void>;
+}
+
+export async function stageGeminiAcpWorkspace(
+  catalog: readonly Record<string, unknown>[] = [],
+): Promise<GeminiAcpWorkspace> {
+  const cwd = await mkdtemp(join(tmpdir(), "ocx-gemini-acp-"));
+  const policyPath = join(cwd, "policy.toml");
+  const settingsPath = join(cwd, "system-settings.json");
+  const catalogPath = join(cwd, "tool-catalog.json");
+  const capturePath = join(cwd, "tool-intents.ndjson");
+  await Promise.all([
+    writeFile(policyPath, GEMINI_POLICY, { encoding: "utf8", mode: 0o600, flag: "wx" }),
+    writeFile(settingsPath, GEMINI_SYSTEM_SETTINGS, { encoding: "utf8", mode: 0o600, flag: "wx" }),
+    writeFile(catalogPath, JSON.stringify(catalog), { encoding: "utf8", mode: 0o600, flag: "wx" }),
+    ...(catalog.length > 0
+      ? [writeFile(capturePath, "", { encoding: "utf8", mode: 0o600, flag: "wx" })]
+      : []),
+  ]);
+  return {
+    cwd,
+    policyPath,
+    settingsPath,
+    catalogPath,
+    ...(catalog.length > 0 ? { capturePath } : {}),
+    cleanup: async () => { await rm(cwd, { recursive: true, force: true }).catch(() => undefined); },
+  };
+}
+
+export function geminiAcpArgs(policyPath: string): string[] {
+  return [
+    "--acp",
+    "--skip-trust",
+    "--approval-mode",
+    "default",
+    "--policy",
+    policyPath,
+    "--allowed-mcp-server-names",
+    "opencodex",
+    "-e",
+    "none",
+  ];
+}
+
+export interface GeminiAcpTurnInput {
+  binary: string;
+  env: Record<string, string>;
+  cwd: string;
+  args: readonly string[];
+  modelId: string;
+  prompt: string;
+  toolNames: ReadonlyMap<string, string>;
+  mcpServers: readonly Record<string, unknown>[];
+  capturePath?: string;
+  maxToolCalls: number;
+  requireToolCall: boolean;
+  incoming: IncomingMeta;
+  deps?: GeminiAcpDeps;
+}
+
+function createGeminiStreamState(): CliAgentStreamState {
+  return {
+    sawText: false,
+    sawThinking: false,
+    terminal: false,
+    toolCalls: 0,
+    nextToolOrdinal: 0,
+  };
+}
+
+function usageFrom(value: unknown, observedModelId?: string): OcxUsage | undefined {
+  const record = asRecord(value);
+  if (!record) return undefined;
+  const count = (input: unknown): number =>
+    typeof input === "number" && Number.isFinite(input) && input >= 0 ? Math.floor(input) : 0;
+  const inputTokens = count(record.inputTokens);
+  const outputTokens = count(record.outputTokens);
+  const cacheRead = count(record.cachedReadTokens);
+  if (inputTokens === 0 && outputTokens === 0 && cacheRead === 0) return undefined;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    ...(cacheRead > 0 ? { cachedInputTokens: cacheRead, cacheReadInputTokens: cacheRead } : {}),
+    ...(observedModelId ? { modelId: observedModelId } : {}),
+  };
+}
+
+function observedModelId(response: acp.PromptResponse, expected: string): string | undefined {
+  const meta = asRecord(response._meta);
+  const quota = asRecord(meta?.quota);
+  const usage = Array.isArray(quota?.model_usage) ? quota.model_usage : [];
+  const ids = [...new Set(usage.flatMap(item => {
+    const model = nonEmpty(asRecord(item)?.model);
+    return model ? [model] : [];
+  }))];
+  return ids.includes(expected) ? expected : ids.length === 1 ? ids[0] : ids[0];
+}
+
+function unsupportedModel(modelId: string): AcpError {
+  return new AcpError(
+    `Gemini ACP cannot select model "${modelId}".`,
+    400,
+    "invalid_request_error",
+    "gemini_model_unsupported",
+    false,
+    false,
+  );
+}
+
+export async function applyGeminiModel(
+  client: AcpClient,
+  session: GeminiAcpSessionInfo,
+  modelId: string,
+): Promise<void> {
+  if (modelId === "default") return;
+  if (!session.availableModels.some(model => model.modelId === modelId)) throw unsupportedModel(modelId);
+  try {
+    await client.setModel(session.sessionId, modelId);
+  } catch (error) {
+    if (error instanceof AcpError && error.code === "timeout") throw error;
+    throw unsupportedModel(modelId);
+  }
+}
+
+async function readCapturedIntents(path: string): Promise<unknown[]> {
+  let bytes: Buffer;
+  try {
+    bytes = await readFile(path);
+  } catch {
+    return [];
+  }
+  if (bytes.byteLength > MAX_CAPTURE_FILE_BYTES) {
+    throw new ToolIntentError("Gemini tool-intent capture exceeded the byte limit.");
+  }
+  const text = bytes.toString("utf8");
+  if (!text.endsWith("\n")) return [];
+  return text.split("\n").filter(Boolean).flatMap(line => {
+    try {
+      const value = JSON.parse(line) as unknown;
+      return value && typeof value === "object" && !Array.isArray(value) ? [value] : [];
+    } catch {
+      throw new ToolIntentError("Gemini returned a malformed captured tool intent.");
+    }
+  });
+}
+
+/** Run one Gemini ACP turn and return any tool intent to the external client. */
+export async function runGeminiAcpTurn(
+  input: GeminiAcpTurnInput,
+  emit: (event: AdapterEvent) => void,
+): Promise<void> {
+  const deps = input.deps ?? {};
+  const state = createGeminiStreamState();
+  let client: AcpClient | undefined;
+  let session: GeminiAcpSessionInfo | undefined;
+  let terminalEmitted = false;
+  let aborted = false;
+  let timedOut = false;
+  let pollTimer: ReturnType<typeof setInterval> | undefined;
+  let turnTimer: ReturnType<typeof setTimeout> | undefined;
+  let captureResolve: ((records: unknown[]) => void) | undefined;
+  let captureReject: ((error: unknown) => void) | undefined;
+  let resolveAbort: (() => void) | undefined;
+
+  const deliver = (event: AdapterEvent): void => {
+    if (event.type === "done" || event.type === "error" || event.type === "incomplete") {
+      if (terminalEmitted) return;
+      terminalEmitted = true;
+    }
+    emit(event);
+  };
+
+  const capturePromise = input.capturePath
+    ? new Promise<unknown[]>((resolvePromise, reject) => {
+        captureResolve = resolvePromise;
+        captureReject = reject;
+      })
+    : new Promise<never>(() => undefined);
+
+  const hooks: GeminiAcpHooks = {
+    onSessionUpdate: notification => {
+      const update = notification.update;
+      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text" && update.content.text) {
+        state.sawText = true;
+        deliver({ type: "text_delta", text: update.content.text });
+      } else if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text" && update.content.text) {
+        state.sawThinking = true;
+        deliver({ type: "thinking_delta", thinking: update.content.text });
+      }
+    },
+    onPermission: () => {
+      if (session) void client?.cancel(session.sessionId).catch(() => undefined);
+    },
+  };
+
+  const onAbort = (): void => {
+    aborted = true;
+    resolveAbort?.();
+    if (session) void client?.cancel(session.sessionId).catch(() => undefined);
+  };
+
+  try {
+    client = await AcpClient.connect({
+      binary: input.binary,
+      env: input.env,
+      cwd: input.cwd,
+      args: input.args,
+      hooks,
+      label: "Gemini ACP",
+      fallbackAllowed: false,
+    }, deps);
+    session = await client.newSession({ cwd: input.cwd, mcpServers: input.mcpServers });
+    await applyGeminiModel(client, session, input.modelId);
+
+    if (input.incoming.abortSignal?.aborted) {
+      deliver({
+        type: "error",
+        message: "Gemini ACP turn was aborted before the prompt.",
+        status: 499,
+        errorType: "invalid_request_error",
+        code: "client_cancelled",
+        retryable: false,
+      });
+      return;
+    }
+
+    const abortOutcome = new Promise<{ kind: "abort" }>(resolvePromise => {
+      resolveAbort = () => resolvePromise({ kind: "abort" });
+      if (input.incoming.abortSignal?.aborted) resolveAbort();
+      else input.incoming.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    });
+    if (input.capturePath) {
+      let reading = false;
+      pollTimer = setInterval(() => {
+        if (reading || terminalEmitted) return;
+        reading = true;
+        void readCapturedIntents(input.capturePath!)
+          .then(records => {
+            if (records.length > 0 && captureResolve) {
+              clearInterval(pollTimer);
+              pollTimer = undefined;
+              captureResolve(records);
+            }
+          })
+          .catch(error => {
+            if (captureReject) {
+              clearInterval(pollTimer);
+              pollTimer = undefined;
+              captureReject(error);
+            }
+          })
+          .finally(() => { reading = false; });
+      }, CAPTURE_POLL_MS);
+    }
+
+    const promptOutcome = client.prompt(session.sessionId, input.prompt, input.incoming.abortSignal)
+      .then(response => ({ kind: "prompt" as const, response }))
+      .catch(error => ({ kind: "error" as const, error }));
+    const captureOutcome = capturePromise
+      .then(records => ({ kind: "capture" as const, records }))
+      .catch(error => ({ kind: "error" as const, error }));
+    const timeoutOutcome = new Promise<{ kind: "timeout" }>(resolvePromise => {
+      turnTimer = setTimeout(() => {
+        timedOut = true;
+        resolvePromise({ kind: "timeout" });
+      }, deps.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    });
+
+    const outcome = await Promise.race([promptOutcome, captureOutcome, abortOutcome, timeoutOutcome]);
+    if (pollTimer) clearInterval(pollTimer);
+    pollTimer = undefined;
+
+    if (outcome.kind === "capture") {
+      try {
+        for (const raw of outcome.records) {
+          const record = asRecord(raw);
+          const name = nonEmpty(record?.name);
+          const id = nonEmpty(record?.id);
+          if (!name || !id) throw new ToolIntentError("Gemini returned a malformed captured tool intent.");
+          const events = mapToolIntent("Gemini", name, id, record?.arguments, state, {
+            toolNames: input.toolNames,
+            maxToolCalls: input.maxToolCalls,
+          });
+          for (const event of events) deliver(event);
+        }
+        if (state.toolCalls > 0) {
+          deliver({ type: "done", stopReason: "tool_use", ...(state.usage ? { usage: state.usage } : {}) });
+        } else if (input.requireToolCall) {
+          deliver({
+            type: "error",
+            message: "Gemini ACP returned no tool call for a request that requires one.",
+            status: 502,
+            errorType: "upstream_error",
+            code: "tool_call_required",
+            retryable: false,
+          });
+        }
+      } catch (error) {
+        deliver({
+          type: "error",
+          message: safeAcpMessage(error, "Gemini returned an invalid tool call."),
+          status: 502,
+          errorType: "upstream_error",
+          code: "cli_protocol_error",
+          retryable: false,
+        });
+      }
+      if (session) void client.cancel(session.sessionId).catch(() => undefined);
+      return;
+    }
+
+    if (outcome.kind === "abort" || aborted) {
+      deliver({
+        type: "error",
+        message: timedOut ? "Gemini ACP turn timed out." : "Gemini ACP turn was cancelled.",
+        status: timedOut ? 504 : 499,
+        errorType: timedOut ? "upstream_error" : "invalid_request_error",
+        code: timedOut ? "timeout" : "client_cancelled",
+        retryable: timedOut,
+      });
+      return;
+    }
+
+    if (outcome.kind === "timeout") {
+      deliver({
+        type: "error",
+        message: "Gemini ACP turn timed out.",
+        status: 504,
+        errorType: "upstream_error",
+        code: "timeout",
+        retryable: true,
+      });
+      return;
+    }
+
+    if (outcome.kind === "error") {
+      const error = outcome.error;
+      const failure = error instanceof AcpError
+        ? error
+        : new AcpError(safeAcpMessage(error, "Gemini ACP failed."), 502, "upstream_error", "acp_transport_error", false, false);
+      deliver({
+        type: "error",
+        message: failure.message,
+        status: timedOut ? 504 : aborted ? 499 : failure.status,
+        errorType: timedOut || aborted ? (timedOut ? "upstream_error" : "invalid_request_error") : failure.errorType,
+        code: timedOut ? "timeout" : aborted ? "client_cancelled" : failure.code,
+        retryable: timedOut || failure.retryable,
+      });
+      return;
+    }
+
+    const response = outcome.response;
+    const actualModel = observedModelId(response, input.modelId);
+    const usage = usageFrom(response.usage, actualModel) ?? state.usage;
+    if (usage) state.usage = usage;
+    if (aborted) {
+      deliver({
+        type: "error",
+        message: "Gemini ACP turn was cancelled.",
+        status: 499,
+        errorType: "invalid_request_error",
+        code: "client_cancelled",
+        retryable: false,
+      });
+    } else if (timedOut) {
+      deliver({
+        type: "error",
+        message: "Gemini ACP turn timed out.",
+        status: 504,
+        errorType: "upstream_error",
+        code: "timeout",
+        retryable: true,
+      });
+    } else if (state.toolCalls > 0) {
+      deliver({ type: "done", stopReason: "tool_use", ...(usage ? { usage } : {}) });
+    } else if (input.requireToolCall) {
+      deliver({
+        type: "error",
+        message: "Gemini ACP returned no tool call for a request that requires one.",
+        status: 502,
+        errorType: "upstream_error",
+        code: "tool_call_required",
+        retryable: false,
+      });
+    } else if (response.stopReason === "end_turn") {
+      deliver({ type: "done", stopReason: "stop", ...(usage ? { usage } : {}) });
+    } else if (response.stopReason === "cancelled") {
+      deliver({
+        type: "error",
+        message: "Gemini ACP cancelled the turn.",
+        status: 502,
+        errorType: "upstream_error",
+        code: "acp_cancelled",
+        retryable: false,
+      });
+    } else {
+      deliver({
+        type: "error",
+        message: `Gemini ACP finished with ${response.stopReason}.`,
+        status: response.stopReason === "max_tokens" ? 400 : 502,
+        errorType: response.stopReason === "max_tokens" ? "invalid_request_error" : "upstream_error",
+        code: "cli_protocol_error",
+        retryable: false,
+      });
+    }
+  } catch (error) {
+    if (!terminalEmitted) {
+      const failure = error instanceof AcpError
+        ? error
+        : new AcpError(safeAcpMessage(error, "Gemini ACP failed."), 502, "upstream_error", "acp_transport_error", false, false);
+      deliver({
+        type: "error",
+        message: aborted && !timedOut ? "Gemini ACP turn was cancelled." : failure.message,
+        status: timedOut ? 504 : aborted ? 499 : failure.status,
+        errorType: timedOut || aborted ? (timedOut ? "upstream_error" : "invalid_request_error") : failure.errorType,
+        code: timedOut ? "timeout" : aborted ? "client_cancelled" : failure.code,
+        retryable: timedOut || failure.retryable,
+      });
+    }
+  } finally {
+    if (pollTimer) clearInterval(pollTimer);
+    if (turnTimer) clearTimeout(turnTimer);
+    input.incoming.abortSignal?.removeEventListener("abort", onAbort);
+    await client?.terminate();
+  }
+}