llm-cli-gateway 1.0.0

package/dist/executor.js

@@ -0,0 +1,315 @@
+import { spawn } from "child_process";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { readdirSync, existsSync } from "fs";
+import { createCircuitBreaker, withRetry } from "./retry.js";
+const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
+const circuitBreakers = new Map();
+let cachedNvmPath;
+function getCircuitBreaker(command) {
+    const existing = circuitBreakers.get(command);
+    if (existing) {
+        return existing;
+    }
+    const circuitBreaker = createCircuitBreaker();
+    circuitBreakers.set(command, circuitBreaker);
+    return circuitBreaker;
+}
+function getNvmPath() {
+    if (cachedNvmPath !== undefined) {
+        return cachedNvmPath;
+    }
+    const home = homedir();
+    const nvmVersionsDir = join(home, ".nvm/versions/node");
+    if (!existsSync(nvmVersionsDir)) {
+        cachedNvmPath = null;
+        return cachedNvmPath;
+    }
+    try {
+        const versions = readdirSync(nvmVersionsDir);
+        cachedNvmPath = versions.length
+            ? versions.map((version) => join(nvmVersionsDir, version, "bin")).join(":")
+            : null;
+    }
+    catch {
+        cachedNvmPath = null;
+    }
+    return cachedNvmPath;
+}
+// Extend PATH to include common locations for CLI tools
+export function getExtendedPath() {
+    const home = homedir();
+    const additionalPaths = [
+        join(home, ".local/bin"),
+        dirname(process.execPath), // Current node's bin directory
+        "/usr/local/bin",
+        "/usr/bin"
+    ];
+    // Add all nvm node version bin directories
+    const nvmPath = getNvmPath();
+    if (nvmPath) {
+        additionalPaths.push(nvmPath);
+    }
+    const currentPath = process.env.PATH || "";
+    return [...additionalPaths, currentPath].join(":");
+}
+/** Registry of active detached process groups for shutdown cleanup. */
+const activeProcessGroups = new Set();
+export function registerProcessGroup(pid) {
+    activeProcessGroups.add(pid);
+}
+export function unregisterProcessGroup(pid) {
+    activeProcessGroups.delete(pid);
+}
+/**
+ * Kill all active process groups. Called on gateway shutdown.
+ * Sends SIGTERM to all groups, waits 3s, then SIGKILL survivors.
+ * Returns a Promise that resolves after SIGKILL escalation completes.
+ * The returned Promise keeps the event loop alive (no .unref()),
+ * ensuring the process does NOT exit before SIGKILL fires.
+ */
+export function killAllProcessGroups() {
+    if (activeProcessGroups.size === 0)
+        return Promise.resolve();
+    for (const pid of activeProcessGroups) {
+        try {
+            process.kill(-pid, "SIGTERM");
+        }
+        catch { /* ESRCH ok */ }
+    }
+    return new Promise(resolve => {
+        setTimeout(() => {
+            for (const pid of activeProcessGroups) {
+                try {
+                    process.kill(-pid, "SIGKILL");
+                }
+                catch { /* ESRCH ok */ }
+            }
+            activeProcessGroups.clear();
+            resolve();
+        }, 3000); // No .unref() — keeps event loop alive through escalation
+    });
+}
+/**
+ * Kill an entire process group. Falls back to killing just the process
+ * if the group kill fails (e.g., pid not yet assigned).
+ */
+export function killProcessGroup(proc, signal) {
+    if (proc.pid) {
+        try {
+            process.kill(-proc.pid, signal);
+            return true;
+        }
+        catch (err) {
+            // ESRCH = process/group already dead — not an error
+            if (err.code !== "ESRCH") {
+                try {
+                    return proc.kill(signal);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return false;
+        }
+    }
+    try {
+        return proc.kill(signal);
+    }
+    catch {
+        return false;
+    }
+}
+export async function executeCli(command, args, options = {}) {
+    const { timeout, idleTimeout, cwd } = options;
+    const extendedPath = getExtendedPath();
+    const circuitBreaker = getCircuitBreaker(command);
+    const runOnce = () => new Promise((resolve, reject) => {
+        const proc = spawn(command, args, {
+            cwd,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, PATH: extendedPath }
+        });
+        if (proc.pid)
+            registerProcessGroup(proc.pid);
+        // Prevent detached process from keeping parent alive when not needed
+        proc.unref();
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let idledOut = false;
+        let overflowed = false;
+        let exited = false;
+        let outputSize = 0;
+        let settled = false;
+        // Single cleanup flag to prevent double-unregister
+        let groupCleaned = false;
+        const cleanupProcessGroup = () => {
+            if (groupCleaned)
+                return;
+            groupCleaned = true;
+            if (proc.pid)
+                unregisterProcessGroup(proc.pid);
+        };
+        const timeoutMs = typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0 ? timeout : undefined;
+        const timeoutId = timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                killProcessGroup(proc, "SIGTERM");
+                setTimeout(() => {
+                    if (!exited)
+                        killProcessGroup(proc, "SIGKILL");
+                    cleanupProcessGroup();
+                }, 5000);
+            }, timeoutMs)
+            : undefined;
+        // Idle timeout: kill process if no stdout/stderr activity for idleMs
+        const idleMs = typeof idleTimeout === "number" && Number.isFinite(idleTimeout) && idleTimeout > 0
+            ? idleTimeout : undefined;
+        let idleTimerId;
+        const resetIdleTimer = () => {
+            if (!idleMs)
+                return;
+            if (idleTimerId)
+                clearTimeout(idleTimerId);
+            idleTimerId = setTimeout(() => {
+                idledOut = true;
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                killProcessGroup(proc, "SIGTERM");
+                setTimeout(() => {
+                    if (!exited)
+                        killProcessGroup(proc, "SIGKILL");
+                    cleanupProcessGroup();
+                }, 5000);
+            }, idleMs);
+        };
+        // Start idle timer immediately (covers case where process never outputs)
+        resetIdleTimer();
+        const finalizeReject = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (idleTimerId) {
+                clearTimeout(idleTimerId);
+            }
+            reject(error);
+        };
+        const handleOutputChunk = (data, stream) => {
+            outputSize += data.length;
+            if (outputSize > MAX_OUTPUT_SIZE) {
+                overflowed = true;
+                killProcessGroup(proc, "SIGTERM");
+                setTimeout(() => {
+                    if (!exited)
+                        killProcessGroup(proc, "SIGKILL");
+                    cleanupProcessGroup();
+                }, 5000);
+                finalizeReject(new Error("Output exceeded maximum size (50MB)"));
+                return;
+            }
+            resetIdleTimer();
+            const text = data.toString();
+            if (stream === "stdout") {
+                stdout += text;
+            }
+            else {
+                stderr += text;
+            }
+        };
+        proc.stdout.on("data", (data) => {
+            if (settled) {
+                return;
+            }
+            handleOutputChunk(data, "stdout");
+        });
+        proc.stderr.on("data", (data) => {
+            if (settled) {
+                return;
+            }
+            handleOutputChunk(data, "stderr");
+        });
+        proc.on("close", (code) => {
+            exited = true;
+            if (idleTimerId) {
+                clearTimeout(idleTimerId);
+            }
+            // Unregister process group on clean exit (no kill was issued)
+            if (!timedOut && !idledOut && !overflowed) {
+                cleanupProcessGroup();
+            }
+            if (settled) {
+                return;
+            }
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            if (timedOut) {
+                const result = {
+                    stdout,
+                    stderr: stderr + `\nProcess timed out after ${timeoutMs}ms`,
+                    code: 124 // Standard timeout exit code
+                };
+                const error = new Error(result.stderr);
+                error.code = 124;
+                error.result = result;
+                reject(error);
+                return;
+            }
+            if (idledOut) {
+                const result = {
+                    stdout,
+                    stderr: stderr + `\nProcess killed after ${idleMs}ms of inactivity`,
+                    code: 125
+                };
+                const error = new Error(result.stderr);
+                error.code = 125;
+                error.result = result;
+                reject(error);
+                return;
+            }
+            const result = { stdout, stderr, code: code ?? 0 };
+            if (result.code !== 0) {
+                const error = new Error(`Process exited with code ${result.code}`);
+                error.code = result.code;
+                error.result = result;
+                reject(error);
+                return;
+            }
+            resolve(result);
+        });
+        proc.on("error", (err) => {
+            exited = true;
+            if (idleTimerId) {
+                clearTimeout(idleTimerId);
+            }
+            cleanupProcessGroup();
+            if (settled) {
+                return;
+            }
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            settled = true;
+            reject(err);
+        });
+    });
+    try {
+        return await withRetry(runOnce, circuitBreaker, undefined, options.logger);
+    }
+    catch (error) {
+        if (error?.cause?.message === "Output exceeded maximum size (50MB)") {
+            throw error.cause;
+        }
+        const result = error?.result ?? error?.cause?.result;
+        if (result) {
+            return result;
+        }
+        throw error;
+    }
+}

package/dist/health.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseConnection } from "./db.js";
+export interface HealthStatus {
+    status: "healthy" | "degraded" | "unhealthy";
+    postgres: {
+        status: "up" | "down";
+        latency: number;
+    };
+    redis: {
+        status: "up" | "down";
+        latency: number;
+    };
+    timestamp: string;
+}
+/**
+ * Check health status of PostgreSQL and Redis
+ * - Both up → healthy
+ * - Only PostgreSQL up → degraded (Redis down but DB works)
+ * - PostgreSQL down → unhealthy (critical failure)
+ */
+export declare function checkHealth(db: DatabaseConnection): Promise<HealthStatus>;

package/dist/health.js

@@ -0,0 +1,32 @@
+/**
+ * Check health status of PostgreSQL and Redis
+ * - Both up → healthy
+ * - Only PostgreSQL up → degraded (Redis down but DB works)
+ * - PostgreSQL down → unhealthy (critical failure)
+ */
+export async function checkHealth(db) {
+    const result = await db.healthCheck();
+    const health = {
+        status: "unhealthy",
+        postgres: {
+            status: result.postgres.connected ? "up" : "down",
+            latency: result.postgres.latency
+        },
+        redis: {
+            status: result.redis.connected ? "up" : "down",
+            latency: result.redis.latency
+        },
+        timestamp: new Date().toISOString()
+    };
+    // Determine overall health status
+    if (result.postgres.connected && result.redis.connected) {
+        health.status = "healthy";
+    }
+    else if (result.postgres.connected && !result.redis.connected) {
+        health.status = "degraded";
+    }
+    else {
+        health.status = "unhealthy";
+    }
+    return health;
+}

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { ISessionManager } from "./session-manager.js";
+import { AsyncJobManager } from "./async-job-manager.js";
+import { ApprovalRecord } from "./approval-manager.js";
+import { ReviewIntegrityResult } from "./review-integrity.js";
+import { ClaudeMcpServerName } from "./claude-mcp-config.js";
+type ExtendedToolResponse = {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+    sessionId?: string;
+    resumable?: boolean;
+    approval?: ApprovalRecord | null;
+    mcpServers?: {
+        requested: ClaudeMcpServerName[];
+        enabled?: ClaudeMcpServerName[];
+        missing?: ClaudeMcpServerName[];
+    };
+    reviewIntegrity?: ReviewIntegrityResult;
+};
+export interface GeminiRequestParams {
+    prompt: string;
+    model?: string;
+    sessionId?: string;
+    resumeLatest: boolean;
+    createNewSession: boolean;
+    approvalMode?: string;
+    approvalStrategy: "legacy" | "mcp_managed";
+    approvalPolicy?: string;
+    mcpServers?: ClaudeMcpServerName[];
+    allowedTools?: string[];
+    includeDirs?: string[];
+    correlationId?: string;
+    optimizePrompt: boolean;
+    optimizeResponse?: boolean;
+    idleTimeoutMs?: number;
+}
+export interface HandlerDeps {
+    sessionManager: ISessionManager;
+    logger: {
+        info: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+        debug: (...args: any[]) => void;
+    };
+}
+export interface AsyncHandlerDeps extends HandlerDeps {
+    asyncJobManager: AsyncJobManager;
+}
+export declare function handleGeminiRequest(deps: HandlerDeps, params: GeminiRequestParams): Promise<ExtendedToolResponse>;
+export declare function handleGeminiRequestAsync(deps: AsyncHandlerDeps, params: Omit<GeminiRequestParams, "optimizeResponse">): Promise<ExtendedToolResponse>;
+export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params: {
+    prompt: string;
+    model?: string;
+    fullAuto: boolean;
+    dangerouslyBypassApprovalsAndSandbox: boolean;
+    approvalStrategy: "legacy" | "mcp_managed";
+    approvalPolicy?: string;
+    mcpServers?: ClaudeMcpServerName[];
+    sessionId?: string;
+    createNewSession: boolean;
+    correlationId?: string;
+    optimizePrompt: boolean;
+    idleTimeoutMs?: number;
+}): Promise<ExtendedToolResponse>;
+export {};