ai-agent-router 0.1.21 → 0.2.0

package/src/cli/index.ts

@@ -1,16 +1,88 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
-import { spawn } from 'child_process';
+import { spawn, ChildProcess } from 'child_process';
 import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import http from 'http';
 import { getDatabase } from '../db/database';
-import { getConfig, setConfig } from '../db/queries';
+import { getConfig, setConfig, setServiceStatus, updateServiceStatus } from '../db/queries';
 
 const program = new Command();
 
 const packageJsonPath = require.resolve('../../../package.json');
 const packageJson = require(packageJsonPath);
 
+const AAR_DIR = path.join(os.homedir(), '.aar');
+const UI_PID_FILE = path.join(AAR_DIR, 'ui.pid');
+const GATEWAY_PID_FILE = path.join(AAR_DIR, 'gateway.pid');
+const GATEWAY_PORT_FILE = path.join(AAR_DIR, 'gateway.port');
+
+function ensureAarDir(): void {
+  if (!fs.existsSync(AAR_DIR)) {
+    fs.mkdirSync(AAR_DIR, { recursive: true });
+  }
+}
+
+function getPackageRoot(): string {
+  return path.dirname(path.dirname(path.dirname(__dirname)));
+}
+
+/** Wait for HTTP server to respond (e.g. UI or gateway ready) */
+function waitForReady(baseUrl: string, maxWaitMs: number = 30000): Promise<boolean> {
+  const url = new URL(baseUrl);
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tryOnce = () => {
+      const req = http.request(
+        {
+          hostname: url.hostname,
+          port: url.port || '80',
+          path: url.pathname || '/',
+          method: 'GET',
+          timeout: 2000,
+        },
+        (res) => {
+          resolve(res.statusCode !== undefined && res.statusCode < 500);
+        }
+      );
+      req.on('error', () => {
+        if (Date.now() - start >= maxWaitMs) {
+          resolve(false);
+          return;
+        }
+        setTimeout(tryOnce, 800);
+      });
+      req.on('timeout', () => {
+        req.destroy();
+        if (Date.now() - start >= maxWaitMs) resolve(false);
+        else setTimeout(tryOnce, 800);
+      });
+      req.end();
+    };
+    tryOnce();
+  });
+}
+
+function printStatus(uiPort: number, gatewayPort: number, gatewayRunning: boolean, background: boolean): void {
+  const uiUrl = `http://localhost:${uiPort}`;
+  const gatewayUrl = `http://localhost:${gatewayPort}`;
+  console.log('');
+  console.log('-------------------------------------------');
+  console.log('  AI Agent Router');
+  console.log('-------------------------------------------');
+  console.log(`  前台 UI:     ${uiUrl}`);
+  console.log(`  网关地址:   ${gatewayUrl}`);
+  console.log(`  网关状态:   ${gatewayRunning ? '运行中' : '未启动'}`);
+  if (background) {
+    console.log('  运行模式:   后台运行（关闭终端不影响）');
+    console.log('  停止服务:   aar stop');
+  }
+  console.log('-------------------------------------------');
+  console.log('');
+}
+
 program
   .name('aar')
   .description('AI Agent Router - Web UI for managing the API gateway')
@@ -18,47 +90,178 @@ program
 
 program
   .command('start')
-  .description('Start the Web UI management interface')
+  .description('Start the Web UI and gateway (default: both; use --no-gateway for UI only)')
   .option('-p, --port <port>', 'Port for Web UI', '9527')
+  .option('-g, --gateway-port <port>', 'Port for gateway (default: from config or 1357)')
+  .option('--no-gateway', 'Only start Web UI, do not start gateway')
+  .option('--no-background', 'Run in foreground (attach to terminal)')
   .action(async (options) => {
-    const port = parseInt(options.port || '9527');
-
-    console.log(`Starting AI Agent Router Web UI`);
-    console.log(`  Port: ${port}`);
-    console.log(`  Access the UI at: http://localhost:${port}`);
-    console.log('');
+    const uiPort = parseInt(options.port || '9527', 10);
+    const startGateway = options.gateway !== false;
+    const background = options.background !== false;
+    const packageRoot = getPackageRoot();
 
-    // Get the package root directory (where package.json is located)
-    const packageRoot = path.dirname(path.dirname(path.dirname(__dirname)));
+    let gatewayPort = 1357;
+    if (startGateway) {
+      try {
+        await getDatabase();
+        const portConfig = await getConfig('port');
+        gatewayPort = options.gatewayPort
+          ? parseInt(options.gatewayPort, 10)
+          : parseInt(portConfig?.value || '1357', 10);
+      } catch (e) {
+        gatewayPort = options.gatewayPort ? parseInt(options.gatewayPort, 10) : 1357;
+      }
+    }
 
-    // Start Web UI using Next.js
-    // Always use production mode for globally installed package
     const serverPath = path.join(packageRoot, 'node_modules', 'next', 'dist', 'bin', 'next');
-    const uiProcess = spawn(process.execPath, [serverPath, 'start', '-p', port.toString()], {
+    const gatewayScriptPath = path.join(packageRoot, 'dist', 'src', 'cli', 'gateway-server.js');
+
+    if (background) {
+      ensureAarDir();
+      const envBase = { ...process.env, NODE_ENV: 'production' as const };
+
+      const uiProc: ChildProcess = spawn(process.execPath, [serverPath, 'start', '-p', uiPort.toString()], {
+        cwd: packageRoot,
+        env: { ...envBase, PORT: uiPort.toString() },
+        detached: true,
+        stdio: 'ignore',
+      });
+      uiProc.unref();
+      if (uiProc.pid) {
+        fs.writeFileSync(UI_PID_FILE, String(uiProc.pid));
+      }
+
+      let gatewayRunning = false;
+      if (startGateway && fs.existsSync(gatewayScriptPath)) {
+        const gwProc: ChildProcess = spawn(process.execPath, [gatewayScriptPath, '--port', String(gatewayPort)], {
+          cwd: packageRoot,
+          env: envBase,
+          detached: true,
+          stdio: 'ignore',
+        });
+        gwProc.unref();
+        if (gwProc.pid) {
+          fs.writeFileSync(GATEWAY_PID_FILE, String(gwProc.pid));
+          fs.writeFileSync(GATEWAY_PORT_FILE, String(gatewayPort));
+          gatewayRunning = true;
+        }
+        try {
+          await getDatabase();
+          await setServiceStatus({
+            status: 'running',
+            port: gatewayPort,
+            pid: gwProc.pid ?? null,
+            started_at: new Date().toISOString(),
+          });
+        } catch {
+          // ignore db errors
+        }
+      }
+
+      printStatus(uiPort, gatewayPort, gatewayRunning, true);
+      process.exit(0);
+    }
+
+    // Foreground: start UI first
+    console.log('Starting AI Agent Router...');
+    const uiProcess = spawn(process.execPath, [serverPath, 'start', '-p', uiPort.toString()], {
       cwd: packageRoot,
       stdio: ['ignore', 'inherit', 'inherit'],
-      env: { ...process.env, PORT: port.toString(), NODE_ENV: 'production' },
-    });
-
-    // Handle UI process exit
-    uiProcess.on('exit', (code) => {
-      console.log(`Web UI process exited with code ${code}`);
-      process.exit(code || 0);
+      env: { ...process.env, PORT: uiPort.toString(), NODE_ENV: 'production' },
     });
 
-    uiProcess.on('error', (error) => {
+    uiProcess.on('error', (error: Error) => {
       console.error(`Failed to start Web UI: ${error.message}`);
       process.exit(1);
     });
 
-    // Keep the process alive
-    process.on('SIGINT', () => {
-      console.log('\nShutting down...');
+    const gatewayProcess: ChildProcess | null = startGateway && fs.existsSync(gatewayScriptPath)
+      ? spawn(process.execPath, [gatewayScriptPath, '--port', String(gatewayPort)], {
+          cwd: packageRoot,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: { ...process.env, NODE_ENV: 'production' },
+        })
+      : null;
+
+    if (gatewayProcess?.stdout) {
+      gatewayProcess.stdout.on('data', (d) => process.stdout.write(d));
+    }
+    if (gatewayProcess?.stderr) {
+      gatewayProcess.stderr.on('data', (d) => process.stderr.write(d));
+    }
+
+    const ready = await waitForReady(`http://localhost:${uiPort}`);
+    if (ready) {
+      printStatus(uiPort, gatewayPort, !!gatewayProcess, false);
+    }
+
+    const shutdown = (signal: string) => {
+      console.log(`\nShutting down (${signal})...`);
+      if (gatewayProcess?.pid) {
+        try {
+          process.kill(gatewayProcess.pid, 'SIGTERM');
+        } catch {
+          // ignore
+        }
+      }
       uiProcess.kill('SIGTERM');
       process.exit(0);
+    };
+
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+    uiProcess.on('exit', (code) => {
+      if (gatewayProcess?.pid) {
+        try {
+          process.kill(gatewayProcess.pid, 'SIGTERM');
+        } catch {
+          // ignore
+        }
+      }
+      process.exit(code ?? 0);
     });
   });
 
+program
+  .command('stop')
+  .description('Stop AI Agent Router when running in background')
+  .action(async () => {
+    ensureAarDir();
+    let stopped = 0;
+    const killPidFile = (file: string, name: string) => {
+      if (!fs.existsSync(file)) return;
+      try {
+        const pid = parseInt(fs.readFileSync(file, 'utf8').trim(), 10);
+        if (!isNaN(pid)) {
+          try {
+            process.kill(pid, 'SIGTERM');
+            console.log(`Stopped ${name} (PID ${pid})`);
+            stopped++;
+          } catch (e: any) {
+            if (e?.code !== 'ESRCH') console.warn(`${name} (PID ${pid}): ${e.message}`);
+          }
+        }
+        fs.unlinkSync(file);
+      } catch (e) {
+        // ignore
+      }
+    };
+    killPidFile(GATEWAY_PID_FILE, 'gateway');
+    killPidFile(UI_PID_FILE, 'Web UI');
+    if (fs.existsSync(GATEWAY_PORT_FILE)) fs.unlinkSync(GATEWAY_PORT_FILE);
+    try {
+      await getDatabase();
+      await updateServiceStatus({ status: 'stopped', pid: null });
+    } catch {
+      // ignore
+    }
+    if (stopped === 0) {
+      console.log('No background processes found (or already stopped).');
+    }
+  });
+
 program
   .command('config')
   .description('Manage gateway configuration')

package/src/db/database.ts

@@ -8,6 +8,25 @@ const DB_PATH = process.env.DB_PATH || path.join(os.homedir(), '.aar', 'gateway.
 
 let dbInstance: Database | null = null;
 let sqlJsInstance: any = null;
+/** 上次从磁盘加载 DB 的时间（用于多进程时发现磁盘被其他进程更新则重新加载） */
+let lastLoadMtimeMs: number = 0;
+
+/** 若磁盘上的 DB 被其他进程更新则重新加载，以便读到最新数据 */
+function reloadFromFileIfNewer(): void {
+  if (!dbInstance || !fs.existsSync(DB_PATH)) return;
+  const mtime = fs.statSync(DB_PATH).mtimeMs;
+  if (mtime <= lastLoadMtimeMs) return;
+  try {
+    const fresh = loadDatabase();
+    if (fresh) {
+      dbInstance.close();
+      dbInstance = fresh;
+      lastLoadMtimeMs = fs.statSync(DB_PATH).mtimeMs;
+    }
+  } catch (e) {
+    console.warn('[Database] Reload from file failed:', (e as Error).message);
+  }
+}
 
 async function initSqlJsEngine(): Promise<any> {
   if (!sqlJsInstance) {
@@ -32,6 +51,9 @@ function saveDatabase(db: Database): void {
       fs.mkdirSync(dbDir, { recursive: true });
     }
     fs.writeFileSync(DB_PATH, buffer);
+    if (fs.existsSync(DB_PATH)) {
+      lastLoadMtimeMs = fs.statSync(DB_PATH).mtimeMs;
+    }
   } catch (error) {
     console.error('Failed to save database:', error);
   }
@@ -53,7 +75,14 @@ export async function getDatabase(): Promise<Database> {
   if (!dbInstance) {
     const engine = await initSqlJsEngine();
     
-    dbInstance = loadDatabase() || new engine.Database();
+    const loaded = loadDatabase();
+    if (loaded) {
+      dbInstance = loaded;
+      if (fs.existsSync(DB_PATH)) lastLoadMtimeMs = fs.statSync(DB_PATH).mtimeMs;
+    } else {
+      dbInstance = new engine.Database();
+      lastLoadMtimeMs = 0;
+    }
     
     try {
       dbInstance!.run(CREATE_TABLES_SQL);
@@ -112,9 +141,10 @@ export async function getDatabase(): Promise<Database> {
         }
       }
     }
-    
-    return dbInstance!;
-  }
+
+  reloadFromFileIfNewer();
+  return dbInstance!;
+}
 
 export async function closeDatabase(): Promise<void> {
   if (dbInstance) {

package/src/db/queries.ts

@@ -157,10 +157,10 @@ export async function createRequestLog(log: Omit<RequestLog, 'id' | 'created_at'
     const result = await run(
       `INSERT INTO request_logs (
         model_id, request_method, request_path, request_headers,
-        request_query, request_body, response_status, response_body, response_time_ms
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        request_query, request_body, response_status, response_body, response_time_ms, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now', 'localtime'))`,
       [
-        log.model_id || null,
+        log.model_id === undefined ? null : log.model_id,
         log.request_method,
         log.request_path,
         log.request_headers,
@@ -182,10 +182,10 @@ export async function createRequestLog(log: Omit<RequestLog, 'id' | 'created_at'
       const result = await run(
         `INSERT INTO request_logs (
           model_id, request_method, request_path, request_headers,
-          request_query, request_body, response_status, response_body, response_time_ms
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          request_query, request_body, response_status, response_body, response_time_ms, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now', 'localtime'))`,
         [
-          null,
+          log.model_id === undefined ? null : log.model_id,
           log.request_method,
           log.request_path,
           log.request_headers,

package/src/server/logger.ts

@@ -1,6 +1,21 @@
 import { createRequestLog } from '../db/queries';
 import { maskApiKey, maskToken } from './crypto';
 
+/** Safe JSON.stringify that never throws; use for logging arbitrary response/request bodies. */
+function safeStringify(value: any): string {
+  if (value === undefined) return '';
+  if (value === null) return 'null';
+  try {
+    return JSON.stringify(value);
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return '[Non-serializable]';
+    }
+  }
+}
+
 export interface LogRequest {
   modelId: number | null; // Allow null for gateway requests
   method: string;
@@ -30,11 +45,11 @@ export async function logRequest(
       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),
+      request_headers: safeStringify(maskedHeaders),
+      request_query: safeStringify(request.query),
+      request_body: safeStringify(maskedBody),
       response_status: response.status,
-      response_body: JSON.stringify(response.body),
+      response_body: safeStringify(response.body),
       response_time_ms: response.responseTimeMs,
     });
   } catch (error) {