pi-orchestrator-config 4.1.5

package/extensions/cli-provider/runner.ts

@@ -0,0 +1,225 @@
+/**
+ * Spawn CLI agent processes — buffered or live stream-json.
+ */
+
+import { spawn } from "node:child_process";
+import type { CliAgentName } from "./providers.js";
+import { buildCliCommand } from "./providers.js";
+import {
+  parseCliOutput,
+  StreamJsonAccumulator,
+  type CliParseResult,
+  type CliStreamEvent,
+} from "./parsers.js";
+
+export interface CliRunOptions {
+  agent: CliAgentName;
+  model: string;
+  cwd: string;
+  prompt: string;
+  sessionId?: string | null;
+  continueSession?: boolean;
+  signal?: AbortSignal;
+  /** Override the default agent binary (from driver config). */
+  binary?: string;
+  /** Optional only — no default. Omit for unlimited turn duration. */
+  timeoutMs?: number;
+  /** When set, stream NDJSON events as they arrive (stream-json agents). */
+  onEvent?: (event: CliStreamEvent) => void;
+}
+
+export interface CliRunResult extends CliParseResult {
+  exitCode: number | null;
+  stderr: string;
+}
+
+/**
+ * Resolve turn timeout for CLI agents.
+ *
+ * Intentional product policy (issue #647): **no default wall-clock timeout**.
+ * Long turns (e.g. autoqodo) must not be SIGKILL'd after N minutes.
+ * Cancellation: pass `AbortSignal`, or an explicit positive `timeoutMs`.
+ */
+export function resolveCliTimeoutMs(
+  timeoutMs: number | undefined,
+): number | undefined {
+  return typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : undefined;
+}
+
+/** Env keys that cause nested-session / ACP re-entry in some CLIs. */
+const STRIP_ENV = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CURSOR_AGENT",
+  "CURSOR_TRACE_ID",
+];
+
+function childEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  for (const k of STRIP_ENV) delete env[k];
+  return env;
+}
+
+export function runCliAgent(opts: CliRunOptions): Promise<CliRunResult> {
+  const { binary, args, promptOnStdin } = buildCliCommand({
+    agent: opts.agent,
+    model: opts.model,
+    cwd: opts.cwd,
+    sessionId: opts.sessionId,
+    continueSession: opts.continueSession,
+    binary: opts.binary,
+  });
+
+  const argv = promptOnStdin ? args : [...args, opts.prompt];
+  const timeoutMs = resolveCliTimeoutMs(opts.timeoutMs);
+  const stream = typeof opts.onEvent === "function";
+
+  return new Promise((resolve, reject) => {
+    if (opts.signal?.aborted) {
+      reject(new Error("CLI call aborted"));
+      return;
+    }
+
+    const child = spawn(binary, argv, {
+      cwd: opts.cwd,
+      env: childEnv(),
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const acc = new StreamJsonAccumulator();
+    const lineBuf = { value: "" };
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    if (timeoutMs !== undefined) {
+      timer = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+              /* ignore */
+            }
+          }, 2000).unref?.();
+        } catch {
+          /* ignore */
+        }
+        if (!settled) {
+          settled = true;
+          reject(new Error(`CLI ${binary} timed out after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+      timer.unref?.();
+    }
+    const onAbort = () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        /* ignore */
+      }
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (d: string) => {
+      if (stream) {
+        for (const ev of acc.feedChunk(d, lineBuf)) {
+          opts.onEvent!(ev);
+        }
+      } else {
+        stdout += d;
+      }
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d;
+    });
+
+    // Attach before any write/end — child may exit immediately (EPIPE).
+    child.stdin?.on("error", () => {
+      /* ignore broken pipe */
+    });
+
+    if (promptOnStdin) {
+      try {
+        child.stdin?.write(opts.prompt);
+        child.stdin?.end();
+      } catch {
+        /* EPIPE if child exits before stdin write */
+      }
+    } else {
+      try {
+        child.stdin?.end();
+      } catch {
+        /* ignore */
+      }
+    }
+
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      if (settled) return;
+      settled = true;
+
+      if (stream) {
+        for (const ev of acc.flush(lineBuf)) {
+          opts.onEvent!(ev);
+        }
+        if (code !== 0 && !acc.text.trim()) {
+          reject(
+            new Error(
+              `CLI ${binary} exited ${code}: ${stderr.trim().slice(0, 500) || "no output"}`,
+            ),
+          );
+          return;
+        }
+        resolve({
+          text: acc.text,
+          sessionId: acc.sessionId,
+          thinking: acc.thinking || undefined,
+          usage: acc.usage,
+          exitCode: code,
+          stderr,
+        });
+        return;
+      }
+
+      if (code !== 0 && !stdout.trim()) {
+        reject(
+          new Error(
+            `CLI ${binary} exited ${code}: ${stderr.trim().slice(0, 500) || "no output"}`,
+          ),
+        );
+        return;
+      }
+      try {
+        const parsed = parseCliOutput(opts.agent, stdout);
+        resolve({
+          ...parsed,
+          exitCode: code,
+          stderr,
+        });
+      } catch (e: any) {
+        reject(
+          new Error(
+            `Failed to parse ${opts.agent} CLI output: ${e?.message || e}\n` +
+              `stdout head: ${stdout.slice(0, 200)}`,
+          ),
+        );
+      }
+    });
+  });
+}

package/extensions/cli-provider/runtime-models.ts

@@ -0,0 +1,32 @@
+/**
+ * Map CLI discovery results → full createProvider Model[].
+ * Kept separate from index.ts so unit tests do not load stream/session code.
+ */
+
+import { buildRuntimeModel } from "../shared/create-runtime-provider.js";
+import type { DiscoveredCliModel } from "./discover.js";
+
+export function mapCliDiscoveredModels(
+  agent: string,
+  discovered: readonly DiscoveredCliModel[],
+): ReturnType<typeof buildRuntimeModel>[] {
+  const provider = `cli-${agent}`;
+  if (discovered.length === 0) {
+    return [
+      buildRuntimeModel({
+        id: `${agent}:default`,
+        name: `${agent} (default)`,
+        api: "cli",
+        provider,
+      }),
+    ];
+  }
+  return discovered.map((m) =>
+    buildRuntimeModel({
+      id: `${agent}:${m.id}`,
+      name: `${m.name} (${agent})`,
+      api: "cli",
+      provider,
+    }),
+  );
+}

package/extensions/cli-provider/session-reaper.ts

@@ -0,0 +1,122 @@
+/**
+ * Reap stale CLI session markers (t3 ProviderSessionReaper pattern).
+ * Deletes idle *stopped* bindings only — never status=running, so concurrent
+ * pi sessions in the same cwd keep CLI --resume continuity.
+ */
+
+import { unlinkSync } from "node:fs";
+import { cliProviderLog } from "../shared/file-logger.js";
+import { listCliSessions } from "./sessions.js";
+
+export const DEFAULT_INACTIVITY_THRESHOLD_MS = 30 * 60 * 1000;
+export const DEFAULT_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+
+export interface ReapOptions {
+  inactivityThresholdMs?: number;
+  /** Only reap sessions matching this cwd (optional). */
+  cwd?: string;
+  /**
+   * Current pi session UUID (informational / future scoping).
+   * Running markers are never reaped regardless of this value — concurrent
+   * sessions in the same cwd must keep --resume (issue #661).
+   */
+  activePiSessionId?: string | null;
+}
+
+/**
+ * Remove idle *stopped* session files only.
+ * Never deletes status=running (own or other piSessionId) so two pi processes
+ * on the same project both keep CLI --resume after idle timeouts.
+ */
+export function reapStaleCliSessions(options?: ReapOptions): number {
+  const threshold = Math.max(
+    1,
+    options?.inactivityThresholdMs ?? DEFAULT_INACTIVITY_THRESHOLD_MS,
+  );
+  const now = Date.now();
+  let reaped = 0;
+
+  for (const { path, record } of listCliSessions()) {
+    if (options?.cwd && record.cwd !== options.cwd) continue;
+
+    // Concurrent pi sessions share ~/.pi/cli-sessions for the same cwd.
+    // Deleting another session's running marker breaks its --resume.
+    if (record.status === "running") continue;
+
+    const lastSeenMs = Date.parse(record.lastSeenAt);
+    const idle =
+      Number.isNaN(lastSeenMs) || now - lastSeenMs >= threshold;
+    if (!idle) continue;
+
+    try {
+      unlinkSync(path);
+      reaped += 1;
+      cliProviderLog(
+        "info",
+        `reaped session ${record.agent}/${record.model} ` +
+          `(status=${record.status}, piSessionId=${record.piSessionId}, ` +
+          `lastSeen=${record.lastSeenAt})`,
+      );
+    } catch (err) {
+      cliProviderLog(
+        "error",
+        `failed to reap session ${record.agent}/${record.model} at ${path}`,
+        err,
+      );
+    }
+  }
+
+  return reaped;
+}
+
+let reaperTimer: ReturnType<typeof setInterval> | null = null;
+
+/** Prefer getter over env when resolving which pi session the reaper protects. */
+export function resolveReaperActivePiSessionId(
+  getActivePiSessionId?: () => string | null,
+  envPiSessionId: string | null | undefined = process.env.PI_SESSION_ID,
+): string | null {
+  // Getter provided (even if temporarily null) → do not fall back to env.
+  // Startup window before session_start must stay "unknown" so all running
+  // markers stay protected (/reload continuity).
+  if (typeof getActivePiSessionId === "function") {
+    const fromGetter = getActivePiSessionId();
+    return fromGetter != null && fromGetter !== "" ? fromGetter : null;
+  }
+  return envPiSessionId != null && envPiSessionId !== ""
+    ? envPiSessionId
+    : null;
+}
+
+export function startCliSessionReaper(opts?: {
+  sweepIntervalMs?: number;
+  inactivityThresholdMs?: number;
+  cwd?: string;
+  getActivePiSessionId?: () => string | null;
+}): void {
+  stopCliSessionReaper();
+  const interval = Math.max(
+    1,
+    opts?.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS,
+  );
+  const sweep = () => {
+    reapStaleCliSessions({
+      inactivityThresholdMs: opts?.inactivityThresholdMs,
+      cwd: opts?.cwd,
+      activePiSessionId: resolveReaperActivePiSessionId(
+        opts?.getActivePiSessionId,
+      ),
+    });
+  };
+  // Do not sweep immediately — activePiSessionId is usually still unset at
+  // extension load; waiting one interval avoids racing session_start.
+  reaperTimer = setInterval(sweep, interval);
+  if (reaperTimer.unref) reaperTimer.unref();
+}
+
+export function stopCliSessionReaper(): void {
+  if (reaperTimer) {
+    clearInterval(reaperTimer);
+    reaperTimer = null;
+  }
+}