ai-agent-router 0.1.0

package/dist/src/db/queries.js

@@ -0,0 +1,261 @@
+import { getDatabase } from './database.js';
+// Provider queries
+export function getAllProviders() {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM providers ORDER BY created_at DESC').all();
+}
+export function getProviderById(id) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM providers WHERE id = ?').get(id);
+}
+export function createProvider(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);
+}
+export function updateProvider(id, provider) {
+    const db = getDatabase();
+    const updates = [];
+    const values = [];
+    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) {
+    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() {
+    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();
+}
+export function getModelsByProvider(providerId) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM models WHERE provider_id = ? ORDER BY name').all(providerId);
+}
+export function getModelById(id) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM models WHERE id = ?').get(id);
+}
+export function getModelByModelId(providerId, modelId) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM models WHERE provider_id = ? AND model_id = ?').get(providerId, modelId);
+}
+export function createModel(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);
+}
+export function updateModel(id, model) {
+    const db = getDatabase();
+    const updates = [];
+    const values = [];
+    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) {
+    const db = getDatabase();
+    const stmt = db.prepare('DELETE FROM models WHERE id = ?');
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+export function getEnabledModels() {
+    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();
+}
+// Request log queries
+export function createRequestLog(log) {
+    const db = getDatabase();
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const result = stmt.run(log.model_id, 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);
+}
+export function getRequestLogs(limit = 100, offset = 0, modelId) {
+    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);
+    }
+    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);
+}
+export function getRequestLogById(id) {
+    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);
+}
+export function getRequestLogCount(modelId) {
+    const db = getDatabase();
+    if (modelId) {
+        return db.prepare('SELECT COUNT(*) as count FROM request_logs WHERE model_id = ?').get(modelId).count;
+    }
+    return db.prepare('SELECT COUNT(*) as count FROM request_logs').get().count;
+}
+// Config queries
+export function getConfig(key) {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM config WHERE key = ?').get(key);
+}
+export function setConfig(key, value) {
+    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() {
+    const db = getDatabase();
+    const configs = db.prepare('SELECT key, value FROM config').all();
+    const result = {};
+    for (const config of configs) {
+        result[config.key] = config.value;
+    }
+    return result;
+}
+// Service status queries
+export function getServiceStatus() {
+    const db = getDatabase();
+    return db.prepare('SELECT * FROM service_status ORDER BY id DESC LIMIT 1').get();
+}
+export function setServiceStatus(status) {
+    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);
+}
+export function updateServiceStatus(updates) {
+    const db = getDatabase();
+    const current = getServiceStatus();
+    if (!current) {
+        return null;
+    }
+    const updateFields = [];
+    const values = [];
+    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() {
+    const db = getDatabase();
+    db.prepare('DELETE FROM service_status').run();
+}

package/dist/src/db/schema.js

@@ -0,0 +1,67 @@
+/**
+ * Database schema definitions
+ */
+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 NOT NULL,
+  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/dist/src/server/crypto.js

@@ -0,0 +1,22 @@
+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) {
+    return CryptoJS.AES.encrypt(apiKey, ENCRYPTION_KEY).toString();
+}
+export function decryptApiKey(encryptedApiKey) {
+    const bytes = CryptoJS.AES.decrypt(encryptedApiKey, ENCRYPTION_KEY);
+    return bytes.toString(CryptoJS.enc.Utf8);
+}
+export function maskApiKey(apiKey) {
+    if (!apiKey || apiKey.length < 8) {
+        return '***';
+    }
+    return apiKey.substring(0, 4) + '***' + apiKey.substring(apiKey.length - 4);
+}
+export function maskToken(token) {
+    if (!token || token.length < 10) {
+        return '***';
+    }
+    return token.substring(0, 6) + '***' + token.substring(token.length - 6);
+}

package/dist/src/server/gateway-server.js

@@ -0,0 +1,200 @@
+/**
+ * Standalone Gateway Server
+ * This server only provides API gateway functionality for external clients
+ * It does NOT include the Web UI
+ */
+import http from 'http';
+import { getDatabase, closeDatabase } from '../db/database.js';
+import { handleGatewayRequest } from './gateway.js';
+export class GatewayServer {
+    constructor(options) {
+        this.server = null;
+        this.port = options.port;
+        this.hostname = options.hostname || 'localhost';
+        this.apiKey = options.apiKey || null;
+    }
+    /**
+     * Validate API key if configured
+     */
+    validateApiKey(authHeader) {
+        if (!this.apiKey) {
+            return true; // No API key configured, allow all requests
+        }
+        if (!authHeader) {
+            return false;
+        }
+        // Support both "Bearer <key>" and direct key
+        const key = authHeader.startsWith('Bearer ')
+            ? authHeader.substring(7)
+            : authHeader;
+        return key === this.apiKey;
+    }
+    /**
+     * Parse request body
+     */
+    async parseBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                if (!body) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve(body);
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+    /**
+     * Handle gateway request
+     */
+    async handleRequest(req, res) {
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        // Handle preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        try {
+            // Validate API key if configured
+            const authHeader = req.headers.authorization || req.headers['x-api-key'] || null;
+            if (!this.validateApiKey(authHeader)) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: { message: 'Invalid or missing API key' } }));
+                return;
+            }
+            // Parse URL
+            const url = new URL(req.url || '/', `http://${this.hostname}:${this.port}`);
+            const pathname = url.pathname;
+            // Parse body first to get model ID
+            let body = null;
+            if (req.method !== 'GET' && req.method !== 'HEAD') {
+                body = await this.parseBody(req);
+            }
+            // Get model ID from query, body, or URL path
+            // Priority: query param > body > path segment
+            let modelId = url.searchParams.get('model') ||
+                url.searchParams.get('model_id') ||
+                null;
+            // Try to get from body if not in query
+            if (!modelId && body) {
+                modelId = body.model || body.model_id || null;
+            }
+            // Try to get from URL path (e.g., /v1/models/{model_id}/...)
+            if (!modelId && pathname) {
+                const pathMatch = pathname.match(/\/(?:v1|api\/gateway)\/models\/([^\/]+)/);
+                if (pathMatch) {
+                    modelId = pathMatch[1];
+                }
+            }
+            if (!modelId) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: {
+                        message: 'Model ID not specified. Please provide model ID in query parameter (?model=xxx), request body, or URL path.'
+                    }
+                }));
+                return;
+            }
+            // Build gateway request
+            const gatewayRequest = {
+                method: req.method || 'GET',
+                path: pathname,
+                headers: req.headers,
+                query: Object.fromEntries(url.searchParams.entries()),
+                body: body,
+            };
+            // Handle the request
+            const response = await handleGatewayRequest(modelId, gatewayRequest);
+            // Send response
+            res.writeHead(response.status, response.headers);
+            res.end(JSON.stringify(response.body));
+        }
+        catch (error) {
+            console.error('Gateway server error:', error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: {
+                    message: error.message || 'Internal server error',
+                    type: 'gateway_error',
+                },
+            }));
+        }
+    }
+    /**
+     * Start the gateway server
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            // Initialize database
+            try {
+                getDatabase();
+            }
+            catch (error) {
+                reject(new Error(`Failed to initialize database: ${error.message}`));
+                return;
+            }
+            this.server = http.createServer((req, res) => {
+                this.handleRequest(req, res).catch((error) => {
+                    console.error('Unhandled request error:', error);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: { message: 'Internal server error' } }));
+                    }
+                });
+            });
+            this.server.listen(this.port, this.hostname, () => {
+                console.log(`✓ Gateway server ready on http://${this.hostname}:${this.port}`);
+                console.log(`  API Gateway: http://${this.hostname}:${this.port}/api/gateway`);
+                if (this.apiKey) {
+                    console.log(`  API Key authentication: Enabled`);
+                }
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${this.port} is already in use`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+            // Graceful shutdown
+            process.on('SIGTERM', () => {
+                this.stop();
+            });
+            process.on('SIGINT', () => {
+                this.stop();
+            });
+        });
+    }
+    /**
+     * Stop the gateway server
+     */
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('Gateway server closed');
+                    closeDatabase();
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/dist/src/server/gateway.js

@@ -0,0 +1,76 @@
+import { getEnabledModels } from '../db/queries.js';
+import { getProviderAdapter } from './providers/index.js';
+import { logRequest } from './logger.js';
+export async function handleGatewayRequest(modelId, request) {
+    const startTime = Date.now();
+    try {
+        // Find the model
+        // First, try to find by model_id in enabled models
+        const enabledModels = getEnabledModels();
+        const model = enabledModels.find(m => m.model_id === modelId);
+        if (!model) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: { error: { message: `Model ${modelId} not found or disabled` } },
+            };
+        }
+        // Get provider adapter
+        const adapter = getProviderAdapter(model.protocol);
+        // Forward the request
+        const response = await adapter.forwardRequest(model, request);
+        // Log the request
+        const responseTimeMs = Date.now() - startTime;
+        await logRequest({
+            modelId: model.id,
+            method: request.method,
+            path: request.path,
+            headers: request.headers,
+            query: request.query,
+            body: request.body,
+        }, {
+            status: response.status,
+            headers: response.headers,
+            body: response.body,
+            responseTimeMs,
+        });
+        return response;
+    }
+    catch (error) {
+        const responseTimeMs = Date.now() - startTime;
+        const errorResponse = {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+            body: {
+                error: {
+                    message: error.message || 'Internal server error',
+                    type: 'gateway_error',
+                },
+            },
+        };
+        // Try to log the error request if we have model info
+        try {
+            const enabledModels = getEnabledModels();
+            const model = enabledModels.find(m => m.model_id === modelId);
+            if (model) {
+                await logRequest({
+                    modelId: model.id,
+                    method: request.method,
+                    path: request.path,
+                    headers: request.headers,
+                    query: request.query,
+                    body: request.body,
+                }, {
+                    status: errorResponse.status,
+                    headers: errorResponse.headers,
+                    body: errorResponse.body,
+                    responseTimeMs,
+                });
+            }
+        }
+        catch (logError) {
+            console.error('Failed to log error request:', logError);
+        }
+        return errorResponse;
+    }
+}

package/dist/src/server/logger.js

@@ -0,0 +1,72 @@
+import { createRequestLog } from '../db/queries.js';
+import { maskApiKey, maskToken } from './crypto.js';
+export async function logRequest(request, response) {
+    try {
+        // Mask sensitive information
+        const maskedHeaders = maskSensitiveHeaders(request.headers);
+        const maskedBody = maskSensitiveData(request.body);
+        await createRequestLog({
+            model_id: request.modelId,
+            request_method: request.method,
+            request_path: request.path,
+            request_headers: JSON.stringify(maskedHeaders),
+            request_query: JSON.stringify(request.query),
+            request_body: JSON.stringify(maskedBody),
+            response_status: response.status,
+            response_body: JSON.stringify(response.body),
+            response_time_ms: response.responseTimeMs,
+        });
+    }
+    catch (error) {
+        console.error('Failed to log request:', error);
+        // Don't throw - logging failure shouldn't break the request
+    }
+}
+function maskSensitiveHeaders(headers) {
+    const masked = { ...headers };
+    // Mask API keys
+    if (masked['authorization']) {
+        const auth = masked['authorization'];
+        if (auth.startsWith('Bearer ')) {
+            masked['authorization'] = `Bearer ${maskToken(auth.substring(7))}`;
+        }
+        else {
+            masked['authorization'] = maskToken(auth);
+        }
+    }
+    if (masked['x-api-key']) {
+        masked['x-api-key'] = maskApiKey(masked['x-api-key']);
+    }
+    if (masked['api-key']) {
+        masked['api-key'] = maskApiKey(masked['api-key']);
+    }
+    return masked;
+}
+function maskSensitiveData(data) {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(maskSensitiveData);
+    }
+    const masked = {};
+    for (const [key, value] of Object.entries(data)) {
+        const lowerKey = key.toLowerCase();
+        if (lowerKey.includes('api') && lowerKey.includes('key')) {
+            masked[key] = maskApiKey(String(value));
+        }
+        else if (lowerKey.includes('token')) {
+            masked[key] = maskToken(String(value));
+        }
+        else if (lowerKey === 'authorization') {
+            masked[key] = maskToken(String(value));
+        }
+        else if (typeof value === 'object' && value !== null) {
+            masked[key] = maskSensitiveData(value);
+        }
+        else {
+            masked[key] = value;
+        }
+    }
+    return masked;
+}