llm-cli-gateway 1.0.0

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    info(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    debug(message: string, meta?: unknown): void;
+}
+export declare const noopLogger: Logger;

package/dist/logger.js

@@ -0,0 +1,5 @@
+export const noopLogger = {
+    info: () => { },
+    error: () => { },
+    debug: () => { }
+};

package/dist/metrics.d.ts

@@ -0,0 +1,23 @@
+import { type CliType } from "./session-manager.js";
+export interface ToolMetricsSnapshot {
+    requestCount: number;
+    successCount: number;
+    failureCount: number;
+    averageResponseTimeMs: number;
+    successRate: number;
+    failureRate: number;
+}
+export interface PerformanceMetricsSnapshot {
+    totalRequests: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    overallSuccessRate: number;
+    overallFailureRate: number;
+    byTool: Record<CliType, ToolMetricsSnapshot>;
+    generatedAt: string;
+}
+export declare class PerformanceMetrics {
+    private metrics;
+    recordRequest(cli: CliType, durationMs: number, success: boolean): void;
+    snapshot(): PerformanceMetricsSnapshot;
+}

package/dist/metrics.js

@@ -0,0 +1,57 @@
+import { CLI_TYPES } from "./session-manager.js";
+const createEmptyMetrics = () => Object.fromEntries(CLI_TYPES.map(cli => [cli, { requestCount: 0, successCount: 0, failureCount: 0, totalResponseTimeMs: 0 }]));
+export class PerformanceMetrics {
+    metrics = createEmptyMetrics();
+    recordRequest(cli, durationMs, success) {
+        const metrics = this.metrics[cli];
+        metrics.requestCount += 1;
+        const normalizedDurationMs = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0;
+        metrics.totalResponseTimeMs += normalizedDurationMs;
+        if (success) {
+            metrics.successCount += 1;
+        }
+        else {
+            metrics.failureCount += 1;
+        }
+    }
+    snapshot() {
+        const byTool = {};
+        let totalRequests = 0;
+        let totalSuccesses = 0;
+        let totalFailures = 0;
+        for (const cli of CLI_TYPES) {
+            const metrics = this.metrics[cli];
+            const averageResponseTimeMs = metrics.requestCount > 0
+                ? metrics.totalResponseTimeMs / metrics.requestCount
+                : 0;
+            const successRate = metrics.requestCount > 0
+                ? metrics.successCount / metrics.requestCount
+                : 0;
+            const failureRate = metrics.requestCount > 0
+                ? metrics.failureCount / metrics.requestCount
+                : 0;
+            byTool[cli] = {
+                requestCount: metrics.requestCount,
+                successCount: metrics.successCount,
+                failureCount: metrics.failureCount,
+                averageResponseTimeMs,
+                successRate,
+                failureRate
+            };
+            totalRequests += metrics.requestCount;
+            totalSuccesses += metrics.successCount;
+            totalFailures += metrics.failureCount;
+        }
+        const overallSuccessRate = totalRequests > 0 ? totalSuccesses / totalRequests : 0;
+        const overallFailureRate = totalRequests > 0 ? totalFailures / totalRequests : 0;
+        return {
+            totalRequests,
+            totalSuccesses,
+            totalFailures,
+            overallSuccessRate,
+            overallFailureRate,
+            byTool,
+            generatedAt: new Date().toISOString()
+        };
+    }
+}

package/dist/migrate-sessions.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { PostgreSQLSessionManager } from "./session-manager-pg.js";
+interface MigrationResult {
+    migrated: number;
+    failed: number;
+    errors: string[];
+}
+/**
+ * Migrate sessions from file-based storage to PostgreSQL
+ */
+export declare function migrateFromFile(filePath: string, pgManager: PostgreSQLSessionManager): Promise<MigrationResult>;
+export {};

package/dist/migrate-sessions.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { PostgreSQLSessionManager } from "./session-manager-pg.js";
+import { loadConfig } from "./config.js";
+import { createDatabaseConnection } from "./db.js";
+// Simple console logger for migration script
+const logger = {
+    info: (message, meta) => console.error(`[INFO] ${message}`, meta || ""),
+    error: (message, meta) => console.error(`[ERROR] ${message}`, meta || ""),
+    debug: (message, meta) => console.error(`[DEBUG] ${message}`, meta || "")
+};
+/**
+ * Migrate sessions from file-based storage to PostgreSQL
+ */
+export async function migrateFromFile(filePath, pgManager) {
+    const result = {
+        migrated: 0,
+        failed: 0,
+        errors: []
+    };
+    // Read file-based sessions
+    let fileData;
+    try {
+        const fileContent = readFileSync(filePath, "utf-8");
+        fileData = JSON.parse(fileContent);
+    }
+    catch (error) {
+        throw new Error(`Failed to read sessions file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.error(`Found ${Object.keys(fileData.sessions).length} sessions to migrate`);
+    // Migrate sessions
+    for (const [id, session] of Object.entries(fileData.sessions)) {
+        try {
+            await pgManager.createSession(session.cli, session.description, session.id);
+            // Migrate metadata if present
+            if (session.metadata) {
+                await pgManager.updateSessionMetadata(id, session.metadata);
+            }
+            result.migrated++;
+            console.error(`✓ Migrated session ${id} (${session.cli})`);
+        }
+        catch (error) {
+            result.failed++;
+            const errorMsg = `Failed to migrate session ${id}: ${error instanceof Error ? error.message : String(error)}`;
+            result.errors.push(errorMsg);
+            console.error(`✗ ${errorMsg}`);
+        }
+    }
+    // Restore active sessions
+    console.error("\nRestoring active sessions...");
+    for (const [cli, sessionId] of Object.entries(fileData.activeSession)) {
+        if (sessionId) {
+            try {
+                await pgManager.setActiveSession(cli, sessionId);
+                console.error(`✓ Set active session for ${cli}: ${sessionId}`);
+            }
+            catch (error) {
+                const errorMsg = `Failed to set active session for ${cli}: ${error instanceof Error ? error.message : String(error)}`;
+                result.errors.push(errorMsg);
+                console.error(`✗ ${errorMsg}`);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Main CLI entry point
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        console.error(`
+Usage: node dist/migrate-sessions.js --from <sessions.json>
+
+Migrate sessions from file-based storage to PostgreSQL.
+
+Options:
+  --from <path>    Path to sessions.json file (default: ~/.llm-cli-gateway/sessions.json)
+  --help, -h       Show this help message
+
+Environment Variables:
+  DATABASE_URL     PostgreSQL connection string (required)
+  REDIS_URL        Redis connection string (required)
+`);
+        process.exit(args[0] === "--help" || args[0] === "-h" ? 0 : 1);
+    }
+    // Parse arguments
+    let filePath = join(homedir(), ".llm-cli-gateway", "sessions.json");
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--from" && args[i + 1]) {
+            filePath = args[i + 1];
+            i++;
+        }
+    }
+    console.error(`Migration Configuration:`);
+    console.error(`  Source: ${filePath}`);
+    console.error(`  DATABASE_URL: ${process.env.DATABASE_URL ? "[set]" : "[not set]"}`);
+    console.error(`  REDIS_URL: ${process.env.REDIS_URL ? "[set]" : "[not set]"}`);
+    console.error("");
+    // Load config
+    const config = loadConfig();
+    if (!config.database || !config.redis) {
+        console.error("ERROR: DATABASE_URL and REDIS_URL must be set");
+        process.exit(1);
+    }
+    // Connect to database
+    console.error("Connecting to database...");
+    const db = await createDatabaseConnection(config, logger);
+    const pgManager = new PostgreSQLSessionManager(db.getPool(), db.getRedis(), config.cacheTtl, logger);
+    console.error("✓ Connected to database\n");
+    try {
+        // Run migration
+        console.error("Starting migration...\n");
+        const result = await migrateFromFile(filePath, pgManager);
+        console.error("\n" + "=".repeat(50));
+        console.error("Migration Summary:");
+        console.error(`  Migrated: ${result.migrated}`);
+        console.error(`  Failed: ${result.failed}`);
+        if (result.errors.length > 0) {
+            console.error("\nErrors:");
+            result.errors.forEach(err => console.error(`  - ${err}`));
+        }
+        if (result.failed === 0) {
+            console.error("\n✓ Migration completed successfully!");
+            process.exit(0);
+        }
+        else {
+            console.error("\n⚠ Migration completed with errors");
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("\nERROR:", error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    finally {
+        await db.disconnect();
+    }
+}
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}

package/dist/migrate.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/migrate.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { Pool } from "pg";
+import { readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Load all migration files from migrations directory
+ */
+function loadMigrations() {
+    const migrationsDir = join(__dirname, "..", "migrations");
+    const files = readdirSync(migrationsDir)
+        .filter(f => f.endsWith(".sql"))
+        .sort(); // Ensures migrations run in order
+    return files.map(file => {
+        const match = file.match(/^(\d+)_(.+)\.sql$/);
+        if (!match) {
+            throw new Error(`Invalid migration filename: ${file}`);
+        }
+        const version = parseInt(match[1], 10);
+        const name = match[2];
+        const sql = readFileSync(join(migrationsDir, file), "utf-8");
+        return { version, name, sql };
+    });
+}
+/**
+ * Get list of applied migrations
+ */
+async function getAppliedMigrations(pool) {
+    // First, ensure schema_migrations table exists
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name VARCHAR(255) NOT NULL,
+      applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `);
+    const result = await pool.query("SELECT version FROM schema_migrations ORDER BY version");
+    return result.rows.map(row => row.version);
+}
+/**
+ * Run a single migration
+ */
+async function runMigration(pool, migration) {
+    console.error(`Running migration ${migration.version}: ${migration.name}...`);
+    const client = await pool.connect();
+    try {
+        await client.query("BEGIN");
+        await client.query(migration.sql);
+        await client.query("COMMIT");
+        console.error(`✓ Migration ${migration.version} completed`);
+    }
+    catch (error) {
+        await client.query("ROLLBACK");
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Main migration runner
+ */
+async function main() {
+    const databaseUrl = process.env.DATABASE_URL;
+    if (!databaseUrl) {
+        console.error("ERROR: DATABASE_URL environment variable not set");
+        process.exit(1);
+    }
+    const pool = new Pool({ connectionString: databaseUrl });
+    try {
+        // Load migrations
+        const migrations = loadMigrations();
+        console.error(`Found ${migrations.length} migration(s)`);
+        // Get applied migrations
+        const applied = await getAppliedMigrations(pool);
+        console.error(`${applied.length} migration(s) already applied`);
+        // Filter pending migrations
+        const pending = migrations.filter(m => !applied.includes(m.version));
+        if (pending.length === 0) {
+            console.error("✓ All migrations up to date");
+            return;
+        }
+        console.error(`Running ${pending.length} pending migration(s)...`);
+        // Run pending migrations
+        for (const migration of pending) {
+            await runMigration(pool, migration);
+        }
+        console.error("✓ All migrations completed successfully");
+    }
+    catch (error) {
+        console.error("ERROR:", error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    finally {
+        await pool.end();
+    }
+}
+main();

package/dist/model-registry.d.ts

@@ -0,0 +1,10 @@
+import type { CliType } from "./session-manager.js";
+export interface CliInfo {
+    description: string;
+    models: Record<string, string>;
+    defaultModel?: string;
+    modelOrder?: string[];
+}
+export type CliInfoMap = Record<CliType, CliInfo>;
+export declare function getCliInfo(forceRefresh?: boolean): CliInfoMap;
+export declare function resolveModelAlias(cli: CliType, model: string | undefined, info: CliInfoMap): string | undefined;