llm-cli-gateway 2.7.0 → 2.9.0

package/dist/acp/process-manager.js

@@ -0,0 +1,364 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { AcpClient } from "./client.js";
+import { AcpError, AcpProcessExitError, ProviderUnavailableError } from "./errors.js";
+import { JsonRpcStdioTransport, } from "./json-rpc-stdio.js";
+import { getAcpProviderEntry } from "./provider-registry.js";
+import { envWithExtendedPath, getExtendedPath } from "../executor.js";
+import { noopLogger } from "../logger.js";
+const SHELL_METACHARACTERS = /[\s|&;<>(){}$`"'\\*?[\]~#! ]/;
+function assertSafeExecutable(command, provider) {
+    if (command.length === 0 || SHELL_METACHARACTERS.test(command)) {
+        throw new ProviderUnavailableError(provider, "configured ACP command is not a bare executable (shell metacharacters are not allowed)", { provider });
+    }
+}
+export function buildProviderEnv(provider, providerConfig, baseEnv) {
+    const env = envWithExtendedPath(baseEnv, getExtendedPath());
+    if (provider === "grok" && providerConfig.isolatedLeaderSocket) {
+        const socketDir = tmpdir();
+        const socketName = `grok-acp-leader-${process.pid}-${Date.now()}.sock`;
+        env.GROK_LEADER_SOCKET = `${socketDir}/${socketName}`;
+    }
+    return env;
+}
+export function resolveProviderSpawn(provider, config, baseEnv, cwd) {
+    const providerConfig = config.providers[provider];
+    const registryEntry = getAcpProviderEntry(provider);
+    let command;
+    let args;
+    if (providerConfig && providerConfig.command.length > 0) {
+        command = providerConfig.command;
+        args = providerConfig.args;
+    }
+    else if (registryEntry.entrypoint) {
+        command = registryEntry.entrypoint.command;
+        args = registryEntry.entrypoint.args;
+    }
+    else {
+        throw new ProviderUnavailableError(provider, "no ACP entrypoint configured and provider has no native ACP entrypoint", { provider });
+    }
+    assertSafeExecutable(command, provider);
+    for (const arg of args) {
+        if (typeof arg !== "string") {
+            throw new ProviderUnavailableError(provider, "ACP args must be strings", { provider });
+        }
+    }
+    const effectiveConfig = providerConfig ?? {
+        enabled: false,
+        command,
+        args: [...args],
+        runtimeEnabled: false,
+        isolatedLeaderSocket: false,
+    };
+    return {
+        command,
+        args: [...args],
+        cwd: cwd ?? `${tmpdir()}/llm-gateway-acp-${provider}`,
+        env: buildProviderEnv(provider, effectiveConfig, baseEnv),
+    };
+}
+export const defaultSpawn = (resolved) => {
+    mkdirSync(resolved.cwd, { recursive: true });
+    const child = nodeSpawn(resolved.command, [...resolved.args], {
+        cwd: resolved.cwd,
+        env: resolved.env,
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    return child;
+};
+export class AcpProcessManager {
+    config;
+    logger;
+    spawnFn;
+    baseEnv;
+    live = new Set();
+    constructor(options) {
+        this.config = options.config;
+        this.logger = options.logger ?? noopLogger;
+        this.spawnFn = options.spawn ?? defaultSpawn;
+        this.baseEnv = options.baseEnv ?? process.env;
+    }
+    async start(options) {
+        const resolved = resolveProviderSpawn(options.provider, this.config, this.baseEnv, options.cwd);
+        let child;
+        try {
+            child = this.spawnFn(resolved);
+        }
+        catch (err) {
+            this.logger.error("acp.process.spawn.failed", {
+                provider: options.provider,
+                errorClass: err instanceof Error ? err.name : "unknown",
+            });
+            throw new ProviderUnavailableError(options.provider, "failed to spawn ACP process", {
+                provider: options.provider,
+            });
+        }
+        if (!child.stdin || !child.stdout) {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+            }
+            throw new ProviderUnavailableError(options.provider, "ACP process did not expose stdin/stdout pipes", { provider: options.provider });
+        }
+        this.logger.info("acp.process.spawn", {
+            provider: options.provider,
+            pid: child.pid,
+        });
+        const managed = new ManagedProcessImpl({
+            provider: options.provider,
+            child,
+            resolved,
+            logger: this.logger,
+            hostServices: options.hostServices,
+            callbacks: options.callbacks,
+            idleTimeoutMs: options.idleTimeoutMs ?? this.config.processIdleTimeoutMs,
+            initializeTimeoutMs: this.config.initializeTimeoutMs,
+            onTerminal: m => this.live.delete(m),
+        });
+        this.live.add(managed);
+        try {
+            await managed.initialize();
+        }
+        catch (err) {
+            managed.shutdown("SIGKILL");
+            this.live.delete(managed);
+            throw err instanceof AcpError
+                ? err
+                : new ProviderUnavailableError(options.provider, "ACP initialize failed", {
+                    provider: options.provider,
+                });
+        }
+        return managed;
+    }
+    shutdownAll(signal = "SIGTERM") {
+        for (const managed of [...this.live]) {
+            managed.shutdown(signal);
+        }
+        this.live.clear();
+    }
+    get liveCount() {
+        return this.live.size;
+    }
+}
+class ManagedProcessImpl {
+    provider;
+    pid;
+    transport;
+    client;
+    resolved;
+    child;
+    logger;
+    callbacks;
+    idleTimeoutMs;
+    onTerminal;
+    _state = "starting";
+    _exitCode = null;
+    _signal = null;
+    _terminalError = null;
+    idleTimer = null;
+    constructor(options) {
+        this.provider = options.provider;
+        this.child = options.child;
+        this.pid = options.child.pid;
+        this.resolved = options.resolved;
+        this.logger = options.logger;
+        this.callbacks = options.callbacks;
+        this.idleTimeoutMs = options.idleTimeoutMs;
+        this.onTerminal = options.onTerminal;
+        this.transport = new JsonRpcStdioTransport({
+            streams: {
+                stdin: options.child.stdin,
+                stdout: options.child.stdout,
+                stderr: options.child.stderr ?? null,
+            },
+            logger: this.logger,
+            provider: this.provider,
+            onNotification: (n) => {
+                this.client.handleNotification(n.method, n.params);
+            },
+            onRequest: (r) => {
+                this.client.handleRequest(r.id, r.method, r.params);
+            },
+            onActivity: () => this.touchIdle(),
+            onClose: () => this.handleChannelClosed(),
+        });
+        this.client = new AcpClient({
+            transport: this.transport,
+            provider: this.provider,
+            hostServices: options.hostServices,
+            callbacks: options.callbacks,
+            logger: this.logger,
+            timeouts: { initializeMs: options.initializeTimeoutMs },
+        });
+        options.child.on("exit", (code, signal) => this.handleExit(code, signal));
+        options.child.on("error", err => this.handleSpawnError(err));
+    }
+    get state() {
+        return this._state;
+    }
+    get exitCode() {
+        return this._exitCode;
+    }
+    get signal() {
+        return this._signal;
+    }
+    get terminalError() {
+        return this._terminalError;
+    }
+    async initialize() {
+        this.logger.info("acp.initialize.start", { provider: this.provider });
+        const response = await this.client.initialize();
+        this._state = "running";
+        this.armIdleTimer();
+        this.logger.info("acp.initialize.success", {
+            provider: this.provider,
+            protocolVersion: response.protocolVersion,
+        });
+    }
+    touchIdle() {
+        if (this._state !== "running") {
+            return;
+        }
+        this.armIdleTimer();
+    }
+    armIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        if (this.idleTimeoutMs <= 0) {
+            return;
+        }
+        this.idleTimer = setTimeout(() => {
+            if (this.transport.pendingCount > 0) {
+                this.armIdleTimer();
+                return;
+            }
+            this.logger.info("acp.process.idle_timeout", {
+                provider: this.provider,
+                pid: this.pid,
+                idleTimeoutMs: this.idleTimeoutMs,
+            });
+            this.shutdown("SIGTERM");
+        }, this.idleTimeoutMs);
+        this.idleTimer.unref?.();
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+    handleExit(code, signal) {
+        if (this._state === "exited" || this._state === "quarantined") {
+            this._exitCode = code;
+            this._signal = signal;
+            return;
+        }
+        this._exitCode = code;
+        this._signal = signal;
+        this._state = "exited";
+        this.clearIdleTimer();
+        this.transport.handleProcessExit(code, signal);
+        const error = new AcpProcessExitError(this.provider, {
+            exitCode: code,
+            signal,
+            debug: { code, signal },
+        });
+        this._terminalError = error;
+        this.logger.error("acp.process.exit", {
+            provider: this.provider,
+            pid: this.pid,
+            exitCode: code,
+            signal,
+        });
+        this.client.notifyProcessExit(error);
+        this.onTerminal(this);
+    }
+    handleSpawnError(err) {
+        if (this._state === "exited" || this._state === "quarantined") {
+            return;
+        }
+        this._state = "quarantined";
+        this.clearIdleTimer();
+        const error = new AcpProcessExitError(this.provider, {
+            debug: { reason: "spawn_error", errorClass: err.name },
+        });
+        this._terminalError = error;
+        this.transport.dispose();
+        this.logger.error("acp.process.error", {
+            provider: this.provider,
+            pid: this.pid,
+            errorClass: err.name,
+        });
+        this.client.notifyProcessExit(error);
+        this.onTerminal(this);
+    }
+    handleChannelClosed() {
+        if (this._state === "exited" || this._state === "quarantined") {
+            return;
+        }
+        this._state = "quarantined";
+        this.clearIdleTimer();
+        const error = this._terminalError ??
+            new AcpProcessExitError(this.provider, {
+                debug: { reason: "stdout_channel_closed" },
+            });
+        this._terminalError = error;
+        this.logger.error("acp.process.channel_closed", {
+            provider: this.provider,
+            pid: this.pid,
+        });
+        this.client.notifyProcessExit(error);
+        try {
+            this.child.kill("SIGTERM");
+        }
+        catch (err) {
+            this.logger.error("acp.process.kill_failed", {
+                provider: this.provider,
+                pid: this.pid,
+                errorClass: err instanceof Error ? err.name : "unknown",
+            });
+        }
+        this.onTerminal(this);
+    }
+    shutdown(signal = "SIGTERM") {
+        if (this._state === "exited" || this._state === "quarantined") {
+            return;
+        }
+        this.clearIdleTimer();
+        const wasRunning = this._state === "running" || this._state === "starting";
+        this._state = "quarantined";
+        if (!this._terminalError) {
+            this._terminalError = new AcpProcessExitError(this.provider, {
+                debug: { reason: "shutdown", signal },
+            });
+        }
+        this.transport.dispose();
+        if (wasRunning) {
+            try {
+                this.child.kill(signal);
+            }
+            catch (err) {
+                this.logger.error("acp.process.kill_failed", {
+                    provider: this.provider,
+                    pid: this.pid,
+                    errorClass: err instanceof Error ? err.name : "unknown",
+                });
+            }
+        }
+        this.logger.info("acp.process.shutdown", {
+            provider: this.provider,
+            pid: this.pid,
+            signal,
+        });
+        this.onTerminal(this);
+    }
+    isHealthy() {
+        return this._state === "running";
+    }
+}

package/dist/acp/provider-registry.d.ts

@@ -0,0 +1,24 @@
+import type { CliType } from "../session-manager.js";
+export type AcpProviderStatus = "native_smoke_passed" | "adapter_mediated_deferred" | "absent_watchlist";
+export type AcpSupportKind = "native" | "adapter_mediated" | "none";
+export interface AcpEntrypoint {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export interface AcpProviderRegistryEntry {
+    readonly provider: CliType;
+    readonly displayName: string;
+    readonly status: AcpProviderStatus;
+    readonly supportKind: AcpSupportKind;
+    readonly targetVersion: string;
+    readonly entrypoint: AcpEntrypoint | null;
+    readonly runtimeEnabledDefault: boolean;
+    readonly shipRuntimePilot: boolean;
+    readonly runtimePriority: number;
+    readonly adapterCandidates: readonly string[];
+    readonly caveat: string;
+}
+export declare function getAcpProviderRegistry(): Readonly<Record<CliType, AcpProviderRegistryEntry>>;
+export declare function getAcpProviderEntry(provider: CliType): AcpProviderRegistryEntry;
+export declare function providerHasNativeAcp(provider: CliType): boolean;
+export declare function getRuntimePilotProviders(): readonly CliType[];

package/dist/acp/provider-registry.js

@@ -0,0 +1,82 @@
+const ACP_PROVIDER_REGISTRY = Object.freeze({
+    mistral: Object.freeze({
+        provider: "mistral",
+        displayName: "Mistral Vibe",
+        status: "native_smoke_passed",
+        supportKind: "native",
+        targetVersion: "vibe 2.14.1",
+        entrypoint: Object.freeze({ command: "vibe-acp", args: Object.freeze([]) }),
+        runtimeEnabledDefault: false,
+        shipRuntimePilot: true,
+        runtimePriority: 1,
+        adapterCandidates: Object.freeze([]),
+        caveat: "Native ACP entrypoint vibe-acp. Manual initialize and session/new smoke passed. First native runtime pilot; runtime routing stays config-gated.",
+    }),
+    grok: Object.freeze({
+        provider: "grok",
+        displayName: "xAI Grok CLI",
+        status: "native_smoke_passed",
+        supportKind: "native",
+        targetVersion: "grok 0.2.50 (cadf94855)",
+        entrypoint: Object.freeze({ command: "grok", args: Object.freeze(["agent", "stdio"]) }),
+        runtimeEnabledDefault: false,
+        shipRuntimePilot: true,
+        runtimePriority: 2,
+        adapterCandidates: Object.freeze([]),
+        caveat: "Native ACP entrypoint grok agent stdio. Manual smoke passed with the installed CLI managing credentials; empty-env smoke is expected to fail. Second native runtime pilot; runtime routing stays config-gated.",
+    }),
+    codex: Object.freeze({
+        provider: "codex",
+        displayName: "OpenAI Codex CLI",
+        status: "adapter_mediated_deferred",
+        supportKind: "adapter_mediated",
+        targetVersion: "codex-cli 0.139.0",
+        entrypoint: null,
+        runtimeEnabledDefault: false,
+        shipRuntimePilot: false,
+        runtimePriority: 0,
+        adapterCandidates: Object.freeze(["zed-industries/codex-acp", "agentclientprotocol/codex-acp"]),
+        caveat: "No native ACP entrypoint at the target version. Adapter-mediated only; tracked but not shipped as native gateway ACP support.",
+    }),
+    claude: Object.freeze({
+        provider: "claude",
+        displayName: "Anthropic Claude Code",
+        status: "adapter_mediated_deferred",
+        supportKind: "adapter_mediated",
+        targetVersion: "claude 2.1.175",
+        entrypoint: null,
+        runtimeEnabledDefault: false,
+        shipRuntimePilot: false,
+        runtimePriority: 0,
+        adapterCandidates: Object.freeze(["Claude Agent SDK ACP adapter"]),
+        caveat: "No native Claude Code CLI ACP entrypoint at the target version. Adapter-mediated only; adapter ownership, permission bridging, and install story unresolved.",
+    }),
+    gemini: Object.freeze({
+        provider: "gemini",
+        displayName: "Google Antigravity",
+        status: "absent_watchlist",
+        supportKind: "none",
+        targetVersion: "agy 1.0.7",
+        entrypoint: null,
+        runtimeEnabledDefault: false,
+        shipRuntimePilot: false,
+        runtimePriority: 0,
+        adapterCandidates: Object.freeze([]),
+        caveat: "No ACP flag or subcommand at the target version. Legacy Gemini CLI ACP evidence does not transfer to Antigravity agy. Watchlist only.",
+    }),
+});
+export function getAcpProviderRegistry() {
+    return ACP_PROVIDER_REGISTRY;
+}
+export function getAcpProviderEntry(provider) {
+    return ACP_PROVIDER_REGISTRY[provider];
+}
+export function providerHasNativeAcp(provider) {
+    return ACP_PROVIDER_REGISTRY[provider].supportKind === "native";
+}
+export function getRuntimePilotProviders() {
+    return Object.values(ACP_PROVIDER_REGISTRY)
+        .filter(entry => entry.shipRuntimePilot)
+        .sort((a, b) => a.runtimePriority - b.runtimePriority)
+        .map(entry => entry.provider);
+}