ai-agent-router 0.1.0

package/dist/src/server/providers/anthropic.js

@@ -0,0 +1,52 @@
+import { decryptApiKey } from '../crypto.js';
+export class AnthropicAdapter {
+    async forwardRequest(model, request) {
+        const apiKey = decryptApiKey(model.provider.api_key);
+        const baseUrl = model.provider.base_url || 'https://api.anthropic.com/v1';
+        // Build the target URL
+        let targetPath = request.path;
+        if (targetPath.startsWith('/v1/')) {
+            targetPath = targetPath.substring(4);
+        }
+        const url = `${baseUrl}/${targetPath}`;
+        // Prepare headers
+        const headers = {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json',
+            ...request.headers,
+        };
+        delete headers['host'];
+        delete headers['connection'];
+        delete headers['authorization'];
+        // Make the request
+        const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body: request.method !== 'GET' && request.method !== 'HEAD' ? JSON.stringify(request.body) : undefined,
+        });
+        const responseBody = await response.text();
+        let parsedBody;
+        try {
+            parsedBody = JSON.parse(responseBody);
+        }
+        catch {
+            parsedBody = responseBody;
+        }
+        return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: parsedBody,
+        };
+    }
+    async listModels(provider) {
+        // Anthropic doesn't have a public models endpoint
+        // Return common models
+        return [
+            { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet' },
+            { id: 'claude-3-opus-20240229', name: 'Claude 3 Opus' },
+            { id: 'claude-3-sonnet-20240229', name: 'Claude 3 Sonnet' },
+            { id: 'claude-3-haiku-20240307', name: 'Claude 3 Haiku' },
+        ];
+    }
+}

package/dist/src/server/providers/gemini.js

@@ -0,0 +1,64 @@
+import { decryptApiKey } from '../crypto.js';
+export class GeminiAdapter {
+    async forwardRequest(model, request) {
+        const apiKey = decryptApiKey(model.provider.api_key);
+        const baseUrl = model.provider.base_url || 'https://generativelanguage.googleapis.com/v1';
+        // Build the target URL
+        let targetPath = request.path;
+        if (targetPath.startsWith('/v1/')) {
+            targetPath = targetPath.substring(4);
+        }
+        // Add API key to query params for Gemini
+        const url = `${baseUrl}/${targetPath}?key=${apiKey}`;
+        // Prepare headers
+        const headers = {
+            'Content-Type': 'application/json',
+            ...request.headers,
+        };
+        delete headers['host'];
+        delete headers['connection'];
+        delete headers['authorization'];
+        // Make the request
+        const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body: request.method !== 'GET' && request.method !== 'HEAD' ? JSON.stringify(request.body) : undefined,
+        });
+        const responseBody = await response.text();
+        let parsedBody;
+        try {
+            parsedBody = JSON.parse(responseBody);
+        }
+        catch {
+            parsedBody = responseBody;
+        }
+        return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: parsedBody,
+        };
+    }
+    async listModels(provider) {
+        const apiKey = decryptApiKey(provider.api_key);
+        const baseUrl = provider.base_url || 'https://generativelanguage.googleapis.com/v1';
+        try {
+            const response = await fetch(`${baseUrl}/models?key=${apiKey}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch models: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return (data.models || []).map((model) => ({
+                id: model.name.replace('models/', ''),
+                name: model.displayName || model.name,
+            }));
+        }
+        catch (error) {
+            console.error('Error fetching Gemini models:', error);
+            throw error;
+        }
+    }
+}

package/dist/src/server/providers/index.js

@@ -0,0 +1,16 @@
+import { OpenAIAdapter } from './openai.js';
+import { AnthropicAdapter } from './anthropic.js';
+import { GeminiAdapter } from './gemini.js';
+export function getProviderAdapter(protocol) {
+    switch (protocol) {
+        case 'openai':
+            return new OpenAIAdapter();
+        case 'anthropic':
+            return new AnthropicAdapter();
+        case 'gemini':
+            return new GeminiAdapter();
+        default:
+            throw new Error(`Unsupported protocol: ${protocol}`);
+    }
+}
+export { OpenAIAdapter, AnthropicAdapter, GeminiAdapter };

package/dist/src/server/providers/openai.js

@@ -0,0 +1,86 @@
+import { decryptApiKey } from '../crypto.js';
+export class OpenAIAdapter {
+    async forwardRequest(model, request) {
+        const apiKey = decryptApiKey(model.provider.api_key);
+        const baseUrl = model.provider.base_url || 'https://api.openai.com/v1';
+        // Build the target URL
+        let targetPath = request.path;
+        if (targetPath.startsWith('/v1/')) {
+            targetPath = targetPath.substring(4);
+        }
+        const url = `${baseUrl}/${targetPath}`;
+        // Prepare headers
+        const headers = {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...request.headers,
+        };
+        delete headers['host'];
+        delete headers['connection'];
+        // Make the request
+        const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body: request.method !== 'GET' && request.method !== 'HEAD' ? JSON.stringify(request.body) : undefined,
+        });
+        const responseBody = await response.text();
+        let parsedBody;
+        try {
+            parsedBody = JSON.parse(responseBody);
+        }
+        catch {
+            parsedBody = responseBody;
+        }
+        return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: parsedBody,
+        };
+    }
+    async listModels(provider) {
+        const apiKey = decryptApiKey(provider.api_key);
+        let baseUrl = provider.base_url || 'https://api.openai.com/v1';
+        // Ensure baseUrl doesn't end with / and has /v1
+        baseUrl = baseUrl.trim().replace(/\/+$/, ''); // Remove trailing slashes
+        if (!baseUrl.endsWith('/v1')) {
+            baseUrl = baseUrl.endsWith('/') ? baseUrl + 'v1' : baseUrl + '/v1';
+        }
+        const url = `${baseUrl}/models`;
+        console.log('[OpenAI] Fetching models:', {
+            baseUrl: provider.base_url,
+            normalizedBaseUrl: baseUrl,
+            url,
+            apiKeyPrefix: apiKey.substring(0, 10) + '...',
+            apiKeyLength: apiKey.length,
+        });
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            console.log('[OpenAI] Response status:', response.status, response.statusText);
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error('[OpenAI] Error response body:', errorText);
+                throw new Error(`Failed to fetch models: ${response.status} ${response.statusText} - ${errorText.substring(0, 200)}`);
+            }
+            const data = await response.json();
+            console.log('[OpenAI] Fetched models count:', data.data?.length || 0);
+            return (data.data || []).map((model) => ({
+                id: model.id,
+                name: model.id, // OpenAI uses model ID as name
+            }));
+        }
+        catch (error) {
+            console.error('[OpenAI] Error fetching models:', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+                url,
+                baseUrl: provider.base_url,
+            });
+            throw error;
+        }
+    }
+}

package/dist/src/server/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/service-manager.js

@@ -0,0 +1,286 @@
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import { getServiceStatus, setServiceStatus, updateServiceStatus } from '../db/queries.js';
+import path from 'path';
+import fs from 'fs';
+import net from 'net';
+const execAsync = promisify(exec);
+class ServiceManager {
+    constructor() {
+        this.childProcess = null;
+        this.isStarting = false;
+    }
+    /**
+     * Check if a process with the given PID exists
+     */
+    async checkProcessExists(pid) {
+        try {
+            // Use 'ps' command to check if process exists
+            // This works on Unix-like systems (macOS, Linux)
+            await execAsync(`ps -p ${pid} -o pid=`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a port is available
+     */
+    async checkPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.listen(port, () => {
+                server.once('close', () => resolve(true));
+                server.close();
+            });
+            server.on('error', () => {
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Check if a port is in use and get process info
+     */
+    async checkPortInUse(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.listen(port, () => {
+                server.once('close', () => resolve({ inUse: false }));
+                server.close();
+            });
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    // Try to get process info
+                    execAsync(`lsof -ti:${port} 2>/dev/null || echo ''`)
+                        .then(({ stdout }) => {
+                        const pid = stdout.trim();
+                        if (pid) {
+                            resolve({ inUse: true, processInfo: `Port ${port} is in use by process ${pid}` });
+                        }
+                        else {
+                            resolve({ inUse: true, processInfo: `Port ${port} is already in use` });
+                        }
+                    })
+                        .catch(() => {
+                        resolve({ inUse: true, processInfo: `Port ${port} is already in use` });
+                    });
+                }
+                else {
+                    resolve({ inUse: false });
+                }
+            });
+        });
+    }
+    /**
+     * Get current service status, verifying process existence
+     */
+    async getStatus() {
+        const dbStatus = getServiceStatus();
+        if (!dbStatus) {
+            return { status: 'stopped' };
+        }
+        // If status is running, verify process actually exists
+        if (dbStatus.status === 'running' && dbStatus.pid) {
+            const processExists = await this.checkProcessExists(dbStatus.pid);
+            if (!processExists) {
+                // Process doesn't exist, update database
+                updateServiceStatus({ status: 'stopped', pid: null });
+                return { status: 'stopped' };
+            }
+        }
+        return {
+            status: dbStatus.status,
+            port: dbStatus.port,
+            pid: dbStatus.pid,
+            started_at: dbStatus.started_at,
+        };
+    }
+    /**
+     * Start the gateway service
+     */
+    async start(port) {
+        // Prevent concurrent starts
+        if (this.isStarting) {
+            return { status: 'stopped', error: 'Service is already starting' };
+        }
+        // Check if service is already running
+        const currentStatus = await this.getStatus();
+        if (currentStatus.status === 'running') {
+            return { status: 'running', error: 'Service is already running', port: currentStatus.port, pid: currentStatus.pid };
+        }
+        // Check port availability with more details
+        const portCheck = await this.checkPortInUse(port);
+        if (portCheck.inUse) {
+            // In development, if port 3000 is in use, suggest using a different port
+            const isDev = process.env.NODE_ENV !== 'production';
+            if (isDev && port === 3000) {
+                return {
+                    status: 'stopped',
+                    error: `Port 3000 is already in use (likely by the development server). Please configure a different port (e.g., 3001) in the settings.`
+                };
+            }
+            return { status: 'stopped', error: portCheck.processInfo || `Port ${port} is already in use` };
+        }
+        this.isStarting = true;
+        try {
+            const cliPath = path.join(process.cwd(), 'dist', 'src', 'cli', 'index.js');
+            const tsCliPath = path.join(process.cwd(), 'src', 'cli', 'index.ts');
+            let child;
+            // Create isolated environment for child process
+            // Remove Next.js dev server specific env vars to avoid conflicts
+            const childEnv = { ...process.env };
+            // Remove PORT if it might conflict
+            if (childEnv.PORT && parseInt(childEnv.PORT) === 3000) {
+                delete childEnv.PORT;
+            }
+            // Remove Next.js specific env vars that might cause conflicts
+            delete childEnv.NEXT_TELEMETRY_DISABLED;
+            // Gateway server doesn't need Next.js, so we can use any NODE_ENV
+            childEnv.NODE_ENV = process.env.NODE_ENV || 'production';
+            // Check if compiled code exists
+            if (fs.existsSync(cliPath)) {
+                // Use compiled JavaScript
+                child = spawn(process.execPath, [cliPath, 'start', '-p', port.toString()], {
+                    detached: false, // Keep attached for proper tracking
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    cwd: process.cwd(),
+                    env: childEnv,
+                });
+            }
+            else if (fs.existsSync(tsCliPath)) {
+                // In development, try to use tsx via npx
+                // Note: tsx should be installed as dev dependency for this to work
+                child = spawn('npx', ['--yes', 'tsx', tsCliPath, 'start', '-p', port.toString()], {
+                    detached: false, // Keep attached for proper tracking
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    cwd: process.cwd(),
+                    env: childEnv,
+                    shell: true, // Use shell to resolve npx
+                });
+            }
+            else {
+                this.isStarting = false;
+                return {
+                    status: 'stopped',
+                    error: 'CLI not found. Please run "npm run build" first, or ensure src/cli/index.ts exists.'
+                };
+            }
+            this.childProcess = child;
+            // Collect error output for better error messages
+            let errorOutput = '';
+            let hasExited = false;
+            let exitCode = null;
+            // Handle process output (optional, for debugging)
+            // Use setImmediate to avoid blocking the event loop
+            child.stdout?.on('data', (data) => {
+                setImmediate(() => {
+                    const output = data.toString();
+                    // Only log if it's not empty and not just whitespace
+                    if (output.trim()) {
+                        console.log(`[Gateway Service] ${output}`);
+                    }
+                });
+            });
+            child.stderr?.on('data', (data) => {
+                setImmediate(() => {
+                    const errorText = data.toString();
+                    console.error(`[Gateway Service Error] ${errorText}`);
+                    errorOutput += errorText;
+                });
+            });
+            // Handle process exit
+            child.on('exit', (code, signal) => {
+                hasExited = true;
+                exitCode = code;
+                console.log(`[Gateway Service] Process exited with code ${code}, signal ${signal}`);
+                this.childProcess = null;
+                this.isStarting = false;
+                // Update database status
+                updateServiceStatus({ status: 'stopped', pid: null });
+            });
+            // Wait a bit to see if process starts successfully
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            // Check if process exited during startup
+            if (hasExited || child.killed || child.exitCode !== null) {
+                this.isStarting = false;
+                this.childProcess = null;
+                // Extract meaningful error message
+                let errorMessage = 'Service failed to start';
+                if (errorOutput) {
+                    // Try to extract the main error message
+                    const errorMatch = errorOutput.match(/Error: ([^\n]+)/);
+                    if (errorMatch) {
+                        errorMessage = errorMatch[1];
+                    }
+                    else if (errorOutput.includes('production build')) {
+                        errorMessage = 'Production build not found. Please run "npm run build" first, or use development mode.';
+                    }
+                    else {
+                        // Use first meaningful line of error
+                        const lines = errorOutput.split('\n').filter(line => line.trim());
+                        if (lines.length > 0) {
+                            errorMessage = lines[0].substring(0, 200); // Limit length
+                        }
+                    }
+                }
+                return { status: 'stopped', error: errorMessage };
+            }
+            // Save status to database
+            const pid = child.pid || null;
+            const startedAt = new Date().toISOString();
+            setServiceStatus({
+                status: 'running',
+                port,
+                pid,
+                started_at: startedAt,
+            });
+            this.isStarting = false;
+            return {
+                status: 'running',
+                port,
+                pid,
+                started_at: startedAt,
+            };
+        }
+        catch (error) {
+            this.isStarting = false;
+            this.childProcess = null;
+            return { status: 'stopped', error: error.message || 'Failed to start service' };
+        }
+    }
+    /**
+     * Stop the gateway service
+     */
+    async stop() {
+        const currentStatus = await this.getStatus();
+        if (currentStatus.status === 'stopped') {
+            return { status: 'stopped' };
+        }
+        try {
+            // If we have a reference to the child process, kill it
+            if (this.childProcess) {
+                this.childProcess.kill('SIGTERM');
+                this.childProcess = null;
+            }
+            else if (currentStatus.pid) {
+                // Try to kill by PID
+                try {
+                    process.kill(currentStatus.pid, 'SIGTERM');
+                }
+                catch (error) {
+                    // Process might not exist
+                    console.warn(`Failed to kill process ${currentStatus.pid}:`, error);
+                }
+            }
+            // Update database status
+            updateServiceStatus({ status: 'stopped', pid: null });
+            return { status: 'stopped' };
+        }
+        catch (error) {
+            return { status: 'stopped', error: error.message || 'Failed to stop service' };
+        }
+    }
+}
+// Export singleton instance
+export const serviceManager = new ServiceManager();

package/docs/TODO.md

@@ -0,0 +1,19 @@
+# TODO
+
+## 2026-01-11
+
+- [ ] [需求] 模型列表支持按供应商分类，支持搜索
+- [ ] [修复] 一键拉取模型出现了 成功拉取了undefine个模型的提示
+- [ ] [需求] 供应商测试连接应该只能选取该供应商下的模型，并支持搜索
+- [ ] [需求] 开启AI网关之后，支持点击测试按钮进行测试，模型可以搜索选择，可以给出示例链接配置，以 json 的格式
+
+## 2026-01-10
+
+- [x] [需求] 需要简化 cli 指令为 aar
+- [x] [优化] 一键拉取模型列表 名称改为 快捷拉取
+- [x] [优化] 供应商和网关配置 API Key 需要加上小眼睛切换按钮，方便查看和拷贝
+- [x] [修复] 供应商 API Key 无法保存的问题修复
+- [x] [优化] Toast 的位置需要水平居中
+- [x] [需求] 数据库存储到用户目录下，路径如 `~/.aar/`
+- [x] [需求] 点击启动之后，后台服务需要保持启动状态，不能因为刷新页面就没了
+- [x] [需求] 供应商添加测试连接按钮，可下拉选择某个模型进行测试连接 

package/next.config.js

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // Only use standalone output in production
+  ...(process.env.NODE_ENV === 'production' && { output: 'standalone' }),
+}
+
+module.exports = nextConfig