llm-cli-gateway 1.0.0

package/dist/claude-mcp-config.js

@@ -0,0 +1,161 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, renameSync, openSync, fsyncSync, closeSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { parse as parseToml } from "toml";
+export const CLAUDE_MCP_SERVER_NAMES = ["sqry", "exa", "ref_tools", "trstr"];
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const strings = value.filter((item) => typeof item === "string");
+    return strings.length === value.length ? strings : undefined;
+}
+function asStringRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") {
+            record[key] = String(entry);
+        }
+    }
+    return Object.keys(record).length > 0 ? record : undefined;
+}
+function readCodexServerConfig(server) {
+    const codexConfigPath = join(homedir(), ".codex", "config.toml");
+    if (!existsSync(codexConfigPath)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(codexConfigPath, "utf-8");
+        const parsed = parseToml(content);
+        const mcpServers = parsed.mcp_servers;
+        if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+            return {};
+        }
+        const serverConfig = mcpServers[server];
+        if (!serverConfig || typeof serverConfig !== "object" || Array.isArray(serverConfig)) {
+            return {};
+        }
+        const obj = serverConfig;
+        const command = typeof obj.command === "string" ? obj.command : undefined;
+        const args = asStringArray(obj.args);
+        const env = asStringRecord(obj.env);
+        return {
+            command,
+            args,
+            env
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function findInstalledExaEntrypoint() {
+    const nvmVersionsDir = join(homedir(), ".nvm", "versions", "node");
+    if (!existsSync(nvmVersionsDir)) {
+        return null;
+    }
+    let versions = [];
+    try {
+        versions = readdirSync(nvmVersionsDir);
+    }
+    catch {
+        return null;
+    }
+    const candidates = [];
+    for (const version of versions) {
+        const entrypoint = join(nvmVersionsDir, version, "lib", "node_modules", "exa-mcp-server", ".smithery", "stdio", "index.cjs");
+        if (existsSync(entrypoint)) {
+            candidates.push(entrypoint);
+        }
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    candidates.sort((a, b) => b.localeCompare(a, undefined, { numeric: true, sensitivity: "base" }));
+    return candidates[0];
+}
+function defaultServerDef(server) {
+    switch (server) {
+        case "sqry":
+            return { command: join(homedir(), ".local", "bin", "sqry-mcp"), args: [] };
+        case "trstr":
+            return { command: join(homedir(), ".local", "bin", "trstr-mcp"), args: [] };
+        case "exa": {
+            const exaEntrypoint = findInstalledExaEntrypoint();
+            if (exaEntrypoint) {
+                return { command: "node", args: [exaEntrypoint] };
+            }
+            return { command: "npx", args: ["-y", "exa-mcp-server"] };
+        }
+        case "ref_tools":
+            return { command: "npx", args: ["-y", "ref-tools-mcp"] };
+        default: {
+            const _exhaustive = server;
+            throw new Error(`Unknown MCP server: ${_exhaustive}`);
+        }
+    }
+}
+function toClaudeServerDef(server) {
+    const codexDef = readCodexServerConfig(server);
+    const fallback = defaultServerDef(server);
+    const command = codexDef.command || fallback.command;
+    const args = codexDef.args || fallback.args || [];
+    const env = {};
+    if (codexDef.env) {
+        Object.assign(env, codexDef.env);
+    }
+    if (server === "exa" && process.env.EXA_API_KEY) {
+        env.EXA_API_KEY = process.env.EXA_API_KEY;
+    }
+    if (server === "ref_tools" && process.env.REF_API_KEY) {
+        env.REF_API_KEY = process.env.REF_API_KEY;
+    }
+    // sqry should always be usable without env, but exa/ref_tools typically need credentials.
+    if ((server === "exa" && !env.EXA_API_KEY) || (server === "ref_tools" && !env.REF_API_KEY)) {
+        return null;
+    }
+    return {
+        command,
+        args,
+        ...(Object.keys(env).length > 0 ? { env } : {})
+    };
+}
+export function buildClaudeMcpConfig(servers) {
+    const uniqueServers = [...new Set(servers)];
+    const enabled = [];
+    const missing = [];
+    const mcpServers = {};
+    for (const server of uniqueServers) {
+        const def = toClaudeServerDef(server);
+        if (!def) {
+            missing.push(server);
+            continue;
+        }
+        mcpServers[server] = def;
+        enabled.push(server);
+    }
+    const configPath = join(homedir(), ".llm-cli-gateway", "claude-mcp.generated.json");
+    const configDir = dirname(configPath);
+    try {
+        mkdirSync(configDir, { recursive: true });
+        const tempPath = `${configPath}.tmp.${process.pid}`;
+        writeFileSync(tempPath, JSON.stringify({ mcpServers }, null, 2), { encoding: "utf-8", mode: 0o600 });
+        const fd = openSync(tempPath, "r+");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(tempPath, configPath);
+        chmodSync(configPath, 0o600);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to write Claude MCP config: ${message}`);
+    }
+    return { path: configPath, enabled, missing };
+}

package/dist/config.d.ts

@@ -0,0 +1,35 @@
+export interface CacheTtl {
+    session: number;
+    activeSession: number;
+    sessionList: number;
+}
+export interface DatabaseConfig {
+    connectionString: string;
+    pool: {
+        max: number;
+        idleTimeoutMillis: number;
+        connectionTimeoutMillis: number;
+        statementTimeout: number;
+    };
+}
+export interface RedisConfig {
+    url: string;
+    retryStrategy: {
+        maxRetries: number;
+        initialDelay: number;
+        maxDelay: number;
+    };
+}
+export declare const DEFAULT_SESSION_TTL_SECONDS = 2592000;
+export interface Config {
+    database?: DatabaseConfig;
+    redis?: RedisConfig;
+    cacheTtl: CacheTtl;
+    sessionTtl: number;
+}
+/**
+ * Load configuration from environment variables.
+ * Always returns a Config object with base fields (cacheTtl, sessionTtl).
+ * Database and Redis fields are populated only when both env vars are set.
+ */
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+// Zod schemas for configuration validation
+const DatabaseUrlSchema = z.string().url().refine((url) => url.startsWith("postgresql://") || url.startsWith("postgres://"), { message: "Database URL must start with postgresql:// or postgres://" });
+const RedisUrlSchema = z.string().url().startsWith("redis://");
+export const DEFAULT_SESSION_TTL_SECONDS = 2592000; // 30 days
+/**
+ * Load configuration from environment variables.
+ * Always returns a Config object with base fields (cacheTtl, sessionTtl).
+ * Database and Redis fields are populated only when both env vars are set.
+ */
+export function loadConfig() {
+    const databaseUrl = process.env.DATABASE_URL;
+    const redisUrl = process.env.REDIS_URL;
+    // Default cache TTLs
+    const cacheTtl = {
+        session: 3600, // 1 hour
+        activeSession: 1800, // 30 minutes
+        sessionList: 120 // 2 minutes
+    };
+    const rawSessionTtl = parseInt(process.env.SESSION_TTL || String(DEFAULT_SESSION_TTL_SECONDS), 10);
+    const sessionTtl = (Number.isFinite(rawSessionTtl) && rawSessionTtl > 0)
+        ? rawSessionTtl : DEFAULT_SESSION_TTL_SECONDS;
+    // If no database config, return base config (file-based storage)
+    if (!databaseUrl || !redisUrl) {
+        return { cacheTtl, sessionTtl };
+    }
+    // Validate URLs
+    try {
+        DatabaseUrlSchema.parse(databaseUrl);
+        RedisUrlSchema.parse(redisUrl);
+    }
+    catch (error) {
+        throw new Error(`Invalid database or redis URL: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return {
+        database: {
+            connectionString: databaseUrl,
+            pool: {
+                max: 10,
+                idleTimeoutMillis: 30000,
+                connectionTimeoutMillis: 5000,
+                statementTimeout: 10000
+            }
+        },
+        redis: {
+            url: redisUrl,
+            retryStrategy: {
+                maxRetries: 3,
+                initialDelay: 50,
+                maxDelay: 2000
+            }
+        },
+        cacheTtl,
+        sessionTtl
+    };
+}

package/dist/db.d.ts

@@ -0,0 +1,48 @@
+import { Pool } from "pg";
+import { Redis } from "ioredis";
+import { Config } from "./config.js";
+import type { Logger } from "./logger.js";
+export interface HealthCheckResult {
+    postgres: {
+        connected: boolean;
+        latency: number;
+    };
+    redis: {
+        connected: boolean;
+        latency: number;
+    };
+}
+/**
+ * Database connection manager for PostgreSQL and Redis
+ */
+export declare class DatabaseConnection {
+    private logger;
+    private pool;
+    private redis;
+    private config;
+    constructor(config: Config, logger?: Logger);
+    /**
+     * Initialize connections to PostgreSQL and Redis
+     */
+    connect(): Promise<void>;
+    /**
+     * Graceful shutdown - close all connections
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Health check for PostgreSQL and Redis
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Get PostgreSQL pool
+     */
+    getPool(): Pool;
+    /**
+     * Get Redis client
+     */
+    getRedis(): Redis;
+}
+/**
+ * Factory function to create and connect DatabaseConnection
+ */
+export declare function createDatabaseConnection(config: Config, logger?: Logger): Promise<DatabaseConnection>;

package/dist/db.js

@@ -0,0 +1,170 @@
+import { Pool } from "pg";
+import { Redis } from "ioredis";
+import { noopLogger } from "./logger.js";
+/**
+ * Database connection manager for PostgreSQL and Redis
+ */
+export class DatabaseConnection {
+    logger;
+    pool = null;
+    redis = null;
+    config;
+    constructor(config, logger = noopLogger) {
+        this.logger = logger;
+        if (!config.database || !config.redis) {
+            throw new Error("Database and Redis configuration required");
+        }
+        this.config = config;
+    }
+    /**
+     * Initialize connections to PostgreSQL and Redis
+     */
+    async connect() {
+        // Initialize PostgreSQL pool
+        const poolConfig = {
+            connectionString: this.config.database.connectionString,
+            max: this.config.database.pool.max,
+            idleTimeoutMillis: this.config.database.pool.idleTimeoutMillis,
+            connectionTimeoutMillis: this.config.database.pool.connectionTimeoutMillis,
+            statement_timeout: this.config.database.pool.statementTimeout
+        };
+        this.pool = new Pool(poolConfig);
+        // Test PostgreSQL connection
+        try {
+            const client = await this.pool.connect();
+            await client.query("SELECT 1");
+            client.release();
+            this.logger.info("PostgreSQL connection established");
+        }
+        catch (error) {
+            this.logger.error("Failed to connect to PostgreSQL", { error });
+            throw new Error(`Failed to connect to PostgreSQL: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Initialize Redis client
+        const redisOptions = {
+            retryStrategy: (times) => {
+                const { maxRetries, initialDelay, maxDelay } = this.config.redis.retryStrategy;
+                if (times > maxRetries) {
+                    return null; // Stop retrying
+                }
+                return Math.min(initialDelay * times, maxDelay);
+            },
+            lazyConnect: false,
+            reconnectOnError: (err) => {
+                // Reconnect on READONLY and ECONNRESET errors
+                const targetErrors = ["READONLY", "ECONNRESET"];
+                return targetErrors.some(targetError => err.message.includes(targetError));
+            }
+        };
+        this.redis = new Redis(this.config.redis.url, redisOptions);
+        // Test Redis connection
+        try {
+            await this.redis.ping();
+            this.logger.info("Redis connection established");
+        }
+        catch (error) {
+            this.logger.error("Failed to connect to Redis", { error });
+            throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Graceful shutdown - close all connections
+     */
+    async disconnect() {
+        this.logger.info("Disconnecting database connections");
+        const errors = [];
+        if (this.pool) {
+            try {
+                await this.pool.end();
+                this.pool = null;
+            }
+            catch (error) {
+                errors.push(new Error(`PostgreSQL disconnect error: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        }
+        if (this.redis) {
+            try {
+                this.redis.disconnect();
+                this.redis = null;
+            }
+            catch (error) {
+                errors.push(new Error(`Redis disconnect error: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error(`Disconnect errors: ${errors.map(e => e.message).join("; ")}`);
+        }
+    }
+    /**
+     * Health check for PostgreSQL and Redis
+     */
+    async healthCheck() {
+        const result = {
+            postgres: { connected: false, latency: 0 },
+            redis: { connected: false, latency: 0 }
+        };
+        // Check PostgreSQL
+        if (this.pool) {
+            const pgStart = Date.now();
+            let client = null;
+            try {
+                client = await this.pool.connect();
+                await client.query("SELECT 1");
+                result.postgres.connected = true;
+                result.postgres.latency = Date.now() - pgStart;
+            }
+            catch (error) {
+                result.postgres.connected = false;
+            }
+            finally {
+                // Always release the client to prevent connection leaks
+                if (client) {
+                    client.release();
+                }
+            }
+        }
+        // Check Redis
+        if (this.redis) {
+            const redisStart = Date.now();
+            try {
+                await this.redis.ping();
+                result.redis.connected = true;
+                result.redis.latency = Date.now() - redisStart;
+            }
+            catch (error) {
+                result.redis.connected = false;
+            }
+        }
+        this.logger.debug("Health check completed", {
+            postgres: result.postgres.connected,
+            redis: result.redis.connected
+        });
+        return result;
+    }
+    /**
+     * Get PostgreSQL pool
+     */
+    getPool() {
+        if (!this.pool) {
+            throw new Error("PostgreSQL pool not initialized");
+        }
+        return this.pool;
+    }
+    /**
+     * Get Redis client
+     */
+    getRedis() {
+        if (!this.redis) {
+            throw new Error("Redis client not initialized");
+        }
+        return this.redis;
+    }
+}
+/**
+ * Factory function to create and connect DatabaseConnection
+ */
+export async function createDatabaseConnection(config, logger) {
+    const db = new DatabaseConnection(config, logger);
+    await db.connect();
+    return db;
+}

package/dist/executor.d.ts

@@ -0,0 +1,30 @@
+import { ChildProcess } from "child_process";
+import type { Logger } from "./logger.js";
+export interface ExecuteOptions {
+    timeout?: number;
+    idleTimeout?: number;
+    cwd?: string;
+    logger?: Logger;
+}
+export interface ExecuteResult {
+    stdout: string;
+    stderr: string;
+    code: number;
+}
+export declare function getExtendedPath(): string;
+export declare function registerProcessGroup(pid: number): void;
+export declare function unregisterProcessGroup(pid: number): void;
+/**
+ * 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 declare function killAllProcessGroups(): Promise<void>;
+/**
+ * Kill an entire process group. Falls back to killing just the process
+ * if the group kill fails (e.g., pid not yet assigned).
+ */
+export declare function killProcessGroup(proc: ChildProcess, signal: NodeJS.Signals): boolean;
+export declare function executeCli(command: string, args: string[], options?: ExecuteOptions): Promise<ExecuteResult>;