ai-agent-router 0.1.0

package/src/db/database.ts

@@ -0,0 +1,125 @@
+import Database from 'better-sqlite3';
+import { CREATE_TABLES_SQL } from './schema';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const DB_PATH = process.env.DB_PATH || path.join(os.homedir(), '.aar', 'gateway.db');
+
+let dbInstance: Database.Database | null = null;
+
+export function getDatabase(): Database.Database {
+  if (!dbInstance) {
+    try {
+      // Ensure directory exists
+      const dbDir = path.dirname(DB_PATH);
+      if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+      }
+
+      dbInstance = new Database(DB_PATH, {
+        // Add timeout for busy operations to avoid blocking
+        timeout: 5000,
+      });
+      
+      // Enable WAL mode for better concurrency
+      dbInstance.pragma('journal_mode = WAL');
+      // Set busy timeout to handle concurrent access
+      dbInstance.pragma('busy_timeout = 5000');
+      
+      // Initialize schema with error handling for concurrent access
+      try {
+        dbInstance.exec(CREATE_TABLES_SQL);
+        
+        // Migration: Allow NULL model_id in request_logs table (for gateway requests)
+        // SQLite doesn't support ALTER COLUMN, so we need to recreate the table
+        try {
+          // Check if request_logs table exists and has NOT NULL constraint
+          const tableInfo = dbInstance.prepare("PRAGMA table_info(request_logs)").all() as any[];
+          const modelIdColumn = tableInfo.find(col => col.name === 'model_id');
+          
+          if (modelIdColumn && modelIdColumn.notnull === 1) {
+            // Table exists with NOT NULL constraint, need to migrate
+            console.log('[Database] Migrating request_logs table to allow NULL model_id...');
+            
+            // Create new table with NULL allowed
+            dbInstance.exec(`
+              CREATE TABLE IF NOT EXISTS request_logs_new (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                model_id INTEGER,
+                request_method TEXT NOT NULL,
+                request_path TEXT NOT NULL,
+                request_headers TEXT,
+                request_query TEXT,
+                request_body TEXT,
+                response_status INTEGER,
+                response_body TEXT,
+                response_time_ms INTEGER,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (model_id) REFERENCES models(id) ON DELETE SET NULL
+              );
+              
+              -- Copy data from old table
+              INSERT INTO request_logs_new 
+              SELECT * FROM request_logs;
+              
+              -- Drop old table
+              DROP TABLE request_logs;
+              
+              -- Rename new table
+              ALTER TABLE request_logs_new RENAME TO request_logs;
+            `);
+            
+            console.log('[Database] Migration completed successfully');
+          }
+        } catch (migrationError: any) {
+          // Migration errors are not critical, just log them
+          // The table might already be migrated or in use
+          if (!migrationError.message.includes('no such table') && 
+              !migrationError.message.includes('already exists')) {
+            console.warn('[Database] Migration warning (non-critical):', migrationError.message);
+          }
+        }
+      } catch (schemaError: any) {
+        // Ignore "table already exists" errors (concurrent initialization)
+        if (!schemaError.message.includes('already exists') && 
+            !schemaError.message.includes('duplicate')) {
+          throw schemaError;
+        }
+      }
+    } catch (error: any) {
+      console.error('Database initialization error:', error);
+      // Don't throw if it's a busy/locked error, retry might work
+      if (error.message && error.message.includes('database is locked')) {
+        // Wait a bit and retry once
+        setTimeout(() => {
+          if (!dbInstance) {
+            try {
+              dbInstance = new Database(DB_PATH, { timeout: 5000 });
+              dbInstance.pragma('journal_mode = WAL');
+              dbInstance.pragma('busy_timeout = 5000');
+            } catch (retryError) {
+              console.error('Database retry failed:', retryError);
+            }
+          }
+        }, 100);
+        // Return a temporary instance or throw
+        throw new Error(`Database is temporarily locked: ${error.message}`);
+      }
+      throw new Error(`Failed to initialize database: ${error.message}`);
+    }
+  }
+  
+  return dbInstance;
+}
+
+export function closeDatabase(): void {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+
+export function getDbPath(): string {
+  return DB_PATH;
+}

package/src/db/queries.ts

@@ -0,0 +1,339 @@
+import { getDatabase } from './database';
+import type { Provider, Model, RequestLog, Config, ServiceStatus } from './schema';
+
+// Provider queries
+export function getAllProviders(): Provider[] {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM providers ORDER BY created_at DESC').all() as Provider[];
+}
+
+export function getProviderById(id: number): Provider | null {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM providers WHERE id = ?').get(id) as Provider | null;
+}
+
+export function createProvider(provider: Omit<Provider, 'id' | 'created_at' | 'updated_at'>): Provider {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO providers (name, protocol, base_url, api_key, updated_at)
+    VALUES (?, ?, ?, ?, datetime('now'))
+  `);
+  const result = stmt.run(provider.name, provider.protocol, provider.base_url, provider.api_key);
+  return getProviderById(result.lastInsertRowid as number)!;
+}
+
+export function updateProvider(id: number, provider: Partial<Omit<Provider, 'id' | 'created_at'>>): Provider | null {
+  const db = getDatabase();
+  const updates: string[] = [];
+  const values: any[] = [];
+
+  if (provider.name !== undefined) {
+    updates.push('name = ?');
+    values.push(provider.name);
+  }
+  if (provider.protocol !== undefined) {
+    updates.push('protocol = ?');
+    values.push(provider.protocol);
+  }
+  if (provider.base_url !== undefined) {
+    updates.push('base_url = ?');
+    values.push(provider.base_url);
+  }
+  if (provider.api_key !== undefined) {
+    updates.push('api_key = ?');
+    values.push(provider.api_key);
+  }
+
+  if (updates.length === 0) {
+    return getProviderById(id);
+  }
+
+  updates.push("updated_at = datetime('now')");
+  values.push(id);
+
+  const stmt = db.prepare(`UPDATE providers SET ${updates.join(', ')} WHERE id = ?`);
+  stmt.run(...values);
+  return getProviderById(id);
+}
+
+export function deleteProvider(id: number): boolean {
+  const db = getDatabase();
+  const stmt = db.prepare('DELETE FROM providers WHERE id = ?');
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+// Model queries
+export function getAllModels(): Model[] {
+  const db = getDatabase();
+  return db.prepare(`
+    SELECT m.*, p.name as provider_name, p.protocol as provider_protocol
+    FROM models m
+    JOIN providers p ON m.provider_id = p.id
+    ORDER BY m.created_at DESC
+  `).all() as any[];
+}
+
+export function getModelsByProvider(providerId: number): Model[] {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM models WHERE provider_id = ? ORDER BY name').all(providerId) as Model[];
+}
+
+export function getModelById(id: number): Model | null {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM models WHERE id = ?').get(id) as Model | null;
+}
+
+export function getModelByModelId(providerId: number, modelId: string): Model | null {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM models WHERE provider_id = ? AND model_id = ?').get(providerId, modelId) as Model | null;
+}
+
+export function createModel(model: Omit<Model, 'id' | 'created_at' | 'updated_at'>): Model {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO models (provider_id, name, model_id, enabled, updated_at)
+    VALUES (?, ?, ?, ?, datetime('now'))
+  `);
+  const result = stmt.run(model.provider_id, model.name, model.model_id, model.enabled ? 1 : 0);
+  return getModelById(result.lastInsertRowid as number)!;
+}
+
+export function updateModel(id: number, model: Partial<Omit<Model, 'id' | 'created_at'>>): Model | null {
+  const db = getDatabase();
+  const updates: string[] = [];
+  const values: any[] = [];
+
+  if (model.name !== undefined) {
+    updates.push('name = ?');
+    values.push(model.name);
+  }
+  if (model.model_id !== undefined) {
+    updates.push('model_id = ?');
+    values.push(model.model_id);
+  }
+  if (model.enabled !== undefined) {
+    updates.push('enabled = ?');
+    values.push(model.enabled ? 1 : 0);
+  }
+  if (model.provider_id !== undefined) {
+    updates.push('provider_id = ?');
+    values.push(model.provider_id);
+  }
+
+  if (updates.length === 0) {
+    return getModelById(id);
+  }
+
+  updates.push("updated_at = datetime('now')");
+  values.push(id);
+
+  const stmt = db.prepare(`UPDATE models SET ${updates.join(', ')} WHERE id = ?`);
+  stmt.run(...values);
+  return getModelById(id);
+}
+
+export function deleteModel(id: number): boolean {
+  const db = getDatabase();
+  const stmt = db.prepare('DELETE FROM models WHERE id = ?');
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+export function getEnabledModels(): Model[] {
+  const db = getDatabase();
+  return db.prepare(`
+    SELECT m.*, p.name as provider_name, p.protocol, p.base_url, p.api_key
+    FROM models m
+    JOIN providers p ON m.provider_id = p.id
+    WHERE m.enabled = 1
+    ORDER BY m.name
+  `).all() as any[];
+}
+
+// Request log queries
+export function createRequestLog(log: Omit<RequestLog, 'id' | 'created_at'>): RequestLog {
+  const db = getDatabase();
+  
+  // Try to insert with model_id (for regular requests)
+  // If model_id is null or doesn't exist, insert with NULL (for gateway requests)
+  const stmt = db.prepare(`
+    INSERT INTO request_logs (
+      model_id, request_method, request_path, request_headers,
+      request_query, request_body, response_status, response_body, response_time_ms
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  
+  try {
+    const result = stmt.run(
+      log.model_id || null, // Allow NULL for gateway requests
+      log.request_method,
+      log.request_path,
+      log.request_headers,
+      log.request_query,
+      log.request_body,
+      log.response_status,
+      log.response_body,
+      log.response_time_ms
+    );
+    return db.prepare('SELECT * FROM request_logs WHERE id = ?').get(result.lastInsertRowid) as RequestLog;
+  } catch (error: any) {
+    // If foreign key constraint fails, try again with NULL model_id
+    if (error.code === 'SQLITE_CONSTRAINT_FOREIGNKEY' && log.model_id) {
+      console.warn(`[RequestLog] Foreign key constraint failed for model_id ${log.model_id}, retrying with NULL`);
+      const result = stmt.run(
+        null, // Use NULL for gateway requests
+        log.request_method,
+        log.request_path,
+        log.request_headers,
+        log.request_query,
+        log.request_body,
+        log.response_status,
+        log.response_body,
+        log.response_time_ms
+      );
+      return db.prepare('SELECT * FROM request_logs WHERE id = ?').get(result.lastInsertRowid) as RequestLog;
+    }
+    throw error;
+  }
+}
+
+export function getRequestLogs(limit: number = 100, offset: number = 0, modelId?: number): RequestLog[] {
+  const db = getDatabase();
+  if (modelId) {
+    return db.prepare(`
+      SELECT l.*, m.name as model_name, m.model_id, p.name as provider_name
+      FROM request_logs l
+      LEFT JOIN models m ON l.model_id = m.id
+      LEFT JOIN providers p ON m.provider_id = p.id
+      WHERE l.model_id = ?
+      ORDER BY l.created_at DESC
+      LIMIT ? OFFSET ?
+    `).all(modelId, limit, offset) as any[];
+  }
+  return db.prepare(`
+    SELECT l.*, m.name as model_name, m.model_id, p.name as provider_name
+    FROM request_logs l
+    LEFT JOIN models m ON l.model_id = m.id
+    LEFT JOIN providers p ON m.provider_id = p.id
+    ORDER BY l.created_at DESC
+    LIMIT ? OFFSET ?
+  `).all(limit, offset) as any[];
+}
+
+export function getRequestLogById(id: number): RequestLog | null {
+  const db = getDatabase();
+  return db.prepare(`
+    SELECT l.*, m.name as model_name, m.model_id, p.name as provider_name
+    FROM request_logs l
+    LEFT JOIN models m ON l.model_id = m.id
+    LEFT JOIN providers p ON m.provider_id = p.id
+    WHERE l.id = ?
+  `).get(id) as any | null;
+}
+
+export function getRequestLogCount(modelId?: number): number {
+  const db = getDatabase();
+  if (modelId) {
+    return (db.prepare('SELECT COUNT(*) as count FROM request_logs WHERE model_id = ?').get(modelId) as any).count;
+  }
+  return (db.prepare('SELECT COUNT(*) as count FROM request_logs').get() as any).count;
+}
+
+// Config queries
+export function getConfig(key: string): Config | null {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM config WHERE key = ?').get(key) as Config | null;
+}
+
+export function setConfig(key: string, value: string): Config {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO config (key, value, updated_at)
+    VALUES (?, ?, datetime('now'))
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      updated_at = datetime('now')
+  `);
+  stmt.run(key, value);
+  return getConfig(key)!;
+}
+
+export function getAllConfig(): Record<string, string> {
+  const db = getDatabase();
+  const configs = db.prepare('SELECT key, value FROM config').all() as Config[];
+  const result: Record<string, string> = {};
+  for (const config of configs) {
+    result[config.key] = config.value;
+  }
+  return result;
+}
+
+// Service status queries
+export function getServiceStatus(): ServiceStatus | null {
+  const db = getDatabase();
+  return db.prepare('SELECT * FROM service_status ORDER BY id DESC LIMIT 1').get() as ServiceStatus | null;
+}
+
+export function setServiceStatus(status: Omit<ServiceStatus, 'id' | 'updated_at'>): ServiceStatus {
+  const db = getDatabase();
+  // Delete old status records (keep only one)
+  db.prepare('DELETE FROM service_status').run();
+  
+  // Insert new status
+  const stmt = db.prepare(`
+    INSERT INTO service_status (status, port, pid, started_at, updated_at)
+    VALUES (?, ?, ?, ?, datetime('now'))
+  `);
+  const result = stmt.run(
+    status.status,
+    status.port,
+    status.pid,
+    status.started_at
+  );
+  return db.prepare('SELECT * FROM service_status WHERE id = ?').get(result.lastInsertRowid) as ServiceStatus;
+}
+
+export function updateServiceStatus(updates: Partial<Omit<ServiceStatus, 'id' | 'updated_at'>>): ServiceStatus | null {
+  const db = getDatabase();
+  const current = getServiceStatus();
+  if (!current) {
+    return null;
+  }
+
+  const updateFields: string[] = [];
+  const values: any[] = [];
+
+  if (updates.status !== undefined) {
+    updateFields.push('status = ?');
+    values.push(updates.status);
+  }
+  if (updates.port !== undefined) {
+    updateFields.push('port = ?');
+    values.push(updates.port);
+  }
+  if (updates.pid !== undefined) {
+    updateFields.push('pid = ?');
+    values.push(updates.pid);
+  }
+  if (updates.started_at !== undefined) {
+    updateFields.push('started_at = ?');
+    values.push(updates.started_at);
+  }
+
+  if (updateFields.length === 0) {
+    return current;
+  }
+
+  updateFields.push("updated_at = datetime('now')");
+  values.push(current.id);
+
+  const stmt = db.prepare(`UPDATE service_status SET ${updateFields.join(', ')} WHERE id = ?`);
+  stmt.run(...values);
+  return getServiceStatus();
+}
+
+export function clearServiceStatus(): void {
+  const db = getDatabase();
+  db.prepare('DELETE FROM service_status').run();
+}

package/src/db/schema.ts

@@ -0,0 +1,117 @@
+/**
+ * Database schema definitions
+ */
+
+export interface Provider {
+  id: number;
+  name: string;
+  protocol: 'openai' | 'anthropic' | 'gemini';
+  base_url: string;
+  api_key: string; // encrypted
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Model {
+  id: number;
+  provider_id: number;
+  name: string;
+  model_id: string;
+  enabled: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface RequestLog {
+  id: number;
+  model_id: number;
+  request_method: string;
+  request_path: string;
+  request_headers: string; // JSON string
+  request_query: string; // JSON string
+  request_body: string; // JSON string
+  response_status: number;
+  response_body: string; // JSON string
+  response_time_ms: number;
+  created_at: string;
+}
+
+export interface Config {
+  key: string;
+  value: string; // JSON string
+  updated_at: string;
+}
+
+export interface ServiceStatus {
+  id: number;
+  status: 'running' | 'stopped';
+  port: number;
+  pid: number | null;
+  started_at: string | null;
+  updated_at: string;
+}
+
+export const CREATE_TABLES_SQL = `
+-- Providers table
+CREATE TABLE IF NOT EXISTS providers (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  protocol TEXT NOT NULL CHECK(protocol IN ('openai', 'anthropic', 'gemini')),
+  base_url TEXT NOT NULL,
+  api_key TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Models table
+CREATE TABLE IF NOT EXISTS models (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  provider_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  enabled BOOLEAN DEFAULT 1,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (provider_id) REFERENCES providers(id) ON DELETE CASCADE,
+  UNIQUE(provider_id, model_id)
+);
+
+-- Request logs table
+CREATE TABLE IF NOT EXISTS request_logs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  model_id INTEGER,
+  request_method TEXT NOT NULL,
+  request_path TEXT NOT NULL,
+  request_headers TEXT,
+  request_query TEXT,
+  request_body TEXT,
+  response_status INTEGER,
+  response_body TEXT,
+  response_time_ms INTEGER,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (model_id) REFERENCES models(id) ON DELETE SET NULL
+);
+
+-- Config table
+CREATE TABLE IF NOT EXISTS config (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Service status table
+CREATE TABLE IF NOT EXISTS service_status (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  status TEXT NOT NULL CHECK(status IN ('running', 'stopped')),
+  port INTEGER NOT NULL,
+  pid INTEGER,
+  started_at DATETIME,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_models_provider_id ON models(provider_id);
+CREATE INDEX IF NOT EXISTS idx_models_enabled ON models(enabled);
+CREATE INDEX IF NOT EXISTS idx_request_logs_model_id ON request_logs(model_id);
+CREATE INDEX IF NOT EXISTS idx_request_logs_created_at ON request_logs(created_at);
+`;

package/src/server/crypto.ts

@@ -0,0 +1,48 @@
+import CryptoJS from 'crypto-js';
+
+// Simple encryption key - in production, use environment variable
+const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY || 'default-encryption-key-change-in-production';
+
+export function encryptApiKey(apiKey: string): string {
+  return CryptoJS.AES.encrypt(apiKey, ENCRYPTION_KEY).toString();
+}
+
+export function decryptApiKey(encryptedApiKey: string): string {
+  if (!encryptedApiKey || encryptedApiKey.trim() === '') {
+    throw new Error('Encrypted API key is empty');
+  }
+  
+  try {
+    const bytes = CryptoJS.AES.decrypt(encryptedApiKey, ENCRYPTION_KEY);
+    const decrypted = bytes.toString(CryptoJS.enc.Utf8);
+    
+    if (!decrypted || decrypted.trim() === '') {
+      // If decryption returns empty, the key might not be encrypted
+      // Try to return the original value (for backward compatibility with unencrypted keys)
+      console.warn('[Crypto] Decryption returned empty string, key might not be encrypted');
+      return encryptedApiKey;
+    }
+    
+    return decrypted;
+  } catch (error: any) {
+    console.error('[Crypto] Decryption error:', error.message);
+    // If decryption fails, the key might not be encrypted (backward compatibility)
+    // Return the original value and let the API call fail with proper error
+    console.warn('[Crypto] Decryption failed, assuming key is not encrypted (backward compatibility)');
+    return encryptedApiKey;
+  }
+}
+
+export function maskApiKey(apiKey: string): string {
+  if (!apiKey || apiKey.length < 8) {
+    return '***';
+  }
+  return apiKey.substring(0, 4) + '***' + apiKey.substring(apiKey.length - 4);
+}
+
+export function maskToken(token: string): string {
+  if (!token || token.length < 10) {
+    return '***';
+  }
+  return token.substring(0, 6) + '***' + token.substring(token.length - 6);
+}