@koreanhole/opencodex 2.97.0 → 2.98.0

package/src/adapters/cli-agent/turn.ts

@@ -1,307 +0,0 @@
-import { execFileSync, spawn as nodeSpawn, type ChildProcess } from "node:child_process";
-import { closeSync, openSync } from "node:fs";
-import type { AdapterEvent, IncomingMeta } from "../../types";
-import { commandInvocation } from "../../lib/win-exec";
-import { readJsonLines } from "./protocol";
-import type { CliAgentTurnDeps, CliAgentTurnPlan } from "./types";
-
-const DEFAULT_TIMEOUT_MS = 300_000;
-const DEFAULT_KILL_GRACE_MS = 2_000;
-const DEFAULT_TOOL_BATCH_IDLE_MS = 250;
-const MAX_STDERR_BYTES = 8 * 1024;
-const MAX_TOOL_CALLS = 16;
-
-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,
-  });
-}
-
-/** Run one bounded local-CLI turn. The driver's parser and cleanup stay outside this lifecycle. */
-export async function runCliAgentTurn(
-  plan: CliAgentTurnPlan,
-  incoming: IncomingMeta,
-  emit: (event: AdapterEvent) => void,
-  deps: CliAgentTurnDeps = {},
-): Promise<void> {
-  const spawnFn = deps.spawn ?? nodeSpawn;
-  const platform = deps.platform ?? process.platform;
-  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const killGraceMs = deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
-  const reapTimeoutMs = deps.reapTimeoutMs ?? killGraceMs * 2 + 250;
-  const toolBatchIdleMs = plan.toolBatchIdleMs ?? DEFAULT_TOOL_BATCH_IDLE_MS;
-
-  if (incoming.abortSignal?.aborted) {
-    await plan.cleanup();
-    emit({ type: "error", message: `${plan.label} turn was aborted before start.`, status: 499, errorType: "invalid_request_error", code: "client_cancelled", retryable: false });
-    return;
-  }
-
-  let child: ChildProcess | undefined;
-  let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
-  let killTimer: ReturnType<typeof setTimeout> | undefined;
-  let toolIdleTimer: ReturnType<typeof setTimeout> | undefined;
-  let terminalEmitted = false;
-  let aborted = false;
-  let timedOut = false;
-  let toolBatchStopped = false;
-  let childProcessError: Error | undefined;
-  let processLifecycle: Promise<void> | undefined;
-  const stderrChunks: string[] = [];
-
-  const emitOnce = (event: AdapterEvent): void => {
-    const terminal = event.type === "done" && plan.requireToolCall && plan.state.toolCalls === 0
-      ? {
-          type: "error" as const,
-          message: `${plan.label} returned no tool call for a request that requires one.`,
-          status: 502,
-          errorType: "upstream_error",
-          code: "tool_call_required",
-          retryable: false,
-        }
-      : event;
-    if (terminal.type === "done" || terminal.type === "error" || terminal.type === "incomplete") {
-      if (terminalEmitted) return;
-      terminalEmitted = true;
-    }
-    emit(terminal);
-  };
-
-  const kill = (): void => {
-    if (!child || child.killed) return;
-    if (platform === "win32" && child.pid !== undefined) {
-      try {
-        (deps.killWindowsProcessTree ?? killWindowsProcessTree)(child.pid);
-        return;
-      } catch {
-        // Fall through to the direct-child termination ladder.
-      }
-    }
-    try { child.kill("SIGTERM"); } catch { /* already gone */ }
-    killTimer = setTimeout(() => {
-      try { child?.kill("SIGKILL"); } catch { /* already gone */ }
-    }, killGraceMs);
-  };
-
-  const stopStream = (): void => {
-    try { child?.stdout?.destroy(); } catch { /* already closed */ }
-  };
-
-  const onAbort = (): void => {
-    aborted = true;
-    kill();
-    stopStream();
-  };
-
-  const armToolIdle = (): void => {
-    if (terminalEmitted || toolBatchStopped || plan.state.toolCalls === 0) return;
-    if (toolIdleTimer) clearTimeout(toolIdleTimer);
-    toolIdleTimer = setTimeout(() => {
-      toolBatchStopped = true;
-      kill();
-      stopStream();
-    }, toolBatchIdleMs);
-  };
-
-  try {
-    const invocation = commandInvocation(plan.binary, [...plan.args], platform, { env: plan.env });
-    let stdinDescriptor: number | undefined;
-    if (plan.stdinFile) {
-      try {
-        stdinDescriptor = openSync(plan.stdinFile, "r");
-      } catch (error) {
-        emitOnce({
-          type: "error",
-          message: `${plan.label} prompt could not be opened: ${error instanceof Error ? error.message : String(error)}`,
-          status: 500,
-          errorType: "upstream_error",
-          code: "cli_prompt_staging_failed",
-          retryable: false,
-        });
-        return;
-      }
-    }
-    try {
-      child = spawnFn(invocation.file, invocation.args, {
-        ...invocation.options,
-        cwd: plan.cwd,
-        env: plan.env,
-        stdio: [stdinDescriptor ?? "pipe", "pipe", "pipe"],
-        windowsHide: true,
-      });
-    } catch (error) {
-      if (stdinDescriptor !== undefined) closeSync(stdinDescriptor);
-      emitOnce({
-        type: "error",
-        message: `${plan.label} could not start: ${error instanceof Error ? error.message : String(error)}`,
-        status: 500,
-        errorType: "upstream_error",
-        code: "cli_spawn_failed",
-        retryable: false,
-      });
-      return;
-    }
-    if (stdinDescriptor !== undefined) closeSync(stdinDescriptor);
-
-    processLifecycle = new Promise<void>((resolve) => {
-      let settled = false;
-      const settle = (): void => {
-        if (settled) return;
-        settled = true;
-        resolve();
-      };
-      child?.once("error", (error) => {
-        childProcessError = error;
-        if (child?.pid === undefined) settle();
-      });
-      child?.once("close", settle);
-      if (child?.exitCode !== null) settle();
-    });
-
-    incoming.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    timeoutTimer = setTimeout(() => {
-      timedOut = true;
-      kill();
-      stopStream();
-      emitOnce({
-        type: "error",
-        message: `${plan.label} turn timed out.`,
-        status: 504,
-        errorType: "upstream_error",
-        code: "timeout",
-        retryable: true,
-      });
-    }, timeoutMs);
-
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk: string) => {
-      if (stderrChunks.join("").length < MAX_STDERR_BYTES) stderrChunks.push(chunk);
-    });
-
-    if (!child.stdout) throw new Error(`${plan.label} produced no stdout stream`);
-    if (!plan.stdinFile) {
-      if (!child.stdin) throw new Error(`${plan.label} produced no stdin stream`);
-      child.stdin.on("error", () => { /* EPIPE when the CLI exits early */ });
-      child.stdin.end(plan.stdin);
-    }
-
-    for await (const message of readJsonLines(child.stdout)) {
-      if (aborted || terminalEmitted) break;
-      const events = plan.parseLine(message, plan.state);
-      for (const event of events) emitOnce(event);
-      if (!terminalEmitted) armToolIdle();
-    }
-
-    if (plan.state.toolCalls > MAX_TOOL_CALLS && !terminalEmitted) {
-      emitOnce({
-        type: "error",
-        message: `${plan.label} exceeded the local-CLI tool-call limit.`,
-        status: 502,
-        errorType: "upstream_error",
-        code: "tool_call_limit_exceeded",
-        retryable: false,
-      });
-    }
-
-    if (!terminalEmitted && !aborted) {
-      if (plan.state.toolCalls > 0) {
-        const exitedCleanly = !childProcessError && !timedOut && child.exitCode === 0;
-        if (toolBatchStopped || exitedCleanly) {
-          emitOnce({
-            type: "done",
-            stopReason: "tool_use",
-            ...(plan.state.usage ? { usage: plan.state.usage } : {}),
-          });
-        } else {
-          const failure = plan.classifyFailure?.({
-            exitCode: child.exitCode ?? 1,
-            stderr: stderrChunks.join("").slice(0, MAX_STDERR_BYTES),
-          }) ?? {
-            type: "error" as const,
-            message: `${plan.label} ended after emitting a tool call.`,
-            status: 502,
-            errorType: "upstream_error",
-            code: "cli_process_failed",
-            retryable: false,
-          };
-          emitOnce(failure);
-        }
-      } else if (plan.requireToolCall) {
-        emitOnce({
-          type: "error",
-          message: `${plan.label} returned no tool call for a request that requires one.`,
-          status: 502,
-          errorType: "upstream_error",
-          code: "tool_call_required",
-          retryable: false,
-        });
-      } else if (childProcessError) {
-        emitOnce({
-          type: "error",
-          message: `${plan.label} failed to start: ${childProcessError.message}`,
-          status: 500,
-          errorType: "upstream_error",
-          code: "cli_spawn_failed",
-          retryable: false,
-        });
-      } else {
-        const exitCode = child.exitCode ?? 1;
-        const stderr = stderrChunks.join("").slice(0, MAX_STDERR_BYTES);
-        const failure = plan.classifyFailure?.({ exitCode, stderr }) ?? {
-          type: "error" as const,
-          message: `${plan.label} ended without a terminal frame.`,
-          status: exitCode === 0 ? 502 : 500,
-          errorType: "upstream_error",
-          code: exitCode === 0 ? "cli_protocol_error" : "cli_process_failed",
-          retryable: false,
-        };
-        emitOnce(failure);
-      }
-    }
-  } catch (error) {
-    if (toolBatchStopped && plan.state.toolCalls > 0) {
-      emitOnce({
-        type: "done",
-        stopReason: "tool_use",
-        ...(plan.state.usage ? { usage: plan.state.usage } : {}),
-      });
-    } else if (!terminalEmitted && !aborted) {
-      emitOnce({
-        type: "error",
-        message: `${plan.label} failed: ${error instanceof Error ? error.message : String(error)}`,
-        status: 502,
-        errorType: "upstream_error",
-        code: "cli_protocol_error",
-        retryable: false,
-      });
-    }
-  } finally {
-    if (timeoutTimer) clearTimeout(timeoutTimer);
-    if (toolIdleTimer) clearTimeout(toolIdleTimer);
-    incoming.abortSignal?.removeEventListener("abort", onAbort);
-    try { child?.stdin?.destroy(); } catch { /* ignore */ }
-
-    if (child && child.exitCode === null && !child.killed) kill();
-    if (child && child.exitCode === null) {
-      await Promise.race([
-        processLifecycle ?? new Promise<void>((resolve) => child?.once("close", () => resolve())),
-        new Promise<void>((resolve) => setTimeout(resolve, reapTimeoutMs)),
-      ]);
-    }
-    if (killTimer) clearTimeout(killTimer);
-    await plan.cleanup();
-  }
-
-  if (aborted && !terminalEmitted && !timedOut) {
-    emitOnce({
-      type: "error",
-      message: `${plan.label} turn was cancelled.`,
-      status: 499,
-      errorType: "invalid_request_error",
-      code: "client_cancelled",
-      retryable: false,
-    });
-  }
-}