ai-agent-router 0.2.0 → 0.2.2

package/src/app/api/ide/openclaw/test/route.ts

@@ -0,0 +1,194 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { spawn } from 'child_process';
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const OPENCLAW_FILE = join(OPENCLAW_DIR, 'openclaw.json');
+
+const RUN_TIMEOUT_MS = 30_000;
+
+interface TestResult {
+  success: boolean;
+  error?: string;
+  message?: string;
+  checks?: Record<string, boolean>;
+  configSummary?: {
+    baseUrl?: string;
+    apiKey?: string;
+    routerProvider?: string;
+    primaryModel?: string;
+    fallbackModels?: string[];
+    imageModel?: string;
+    fallbackImageModels?: string[];
+  };
+  probeResult?: {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    error?: string;
+  };
+}
+
+function runCommand(args: string[]): Promise<{ success: boolean; stdout: string; stderr: string; error?: string; code?: number }> {
+  return new Promise((resolve) => {
+    const child = spawn('openclaw', args, {
+      shell: process.platform === 'win32',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString('utf-8');
+    });
+    child.stderr?.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString('utf-8');
+    });
+
+    child.on('error', (err) => {
+      resolve({ success: false, stdout, stderr, error: err.message });
+    });
+
+    child.on('close', (code) => {
+      resolve({ success: code === 0, stdout, stderr, code: code ?? undefined });
+    });
+
+    setTimeout(() => {
+      if (!child.killed) {
+        child.kill();
+        resolve({ success: false, stdout, stderr, error: 'Timeout' });
+      }
+    }, RUN_TIMEOUT_MS);
+  });
+}
+
+function maskApiKey(apiKey: string): string {
+  if (!apiKey || apiKey === 'your-gateway-api-key') return apiKey;
+  if (apiKey.length <= 8) return apiKey.slice(0, 2) + '***' + apiKey.slice(-2);
+  return apiKey.slice(0, 4) + '****' + apiKey.slice(-4);
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    // Check config file exists
+    if (!existsSync(OPENCLAW_FILE)) {
+      return NextResponse.json({
+        success: false,
+        error: 'Configuration file not found',
+        suggestion: 'Please apply configuration first',
+      } as TestResult);
+    }
+
+    const content = readFileSync(OPENCLAW_FILE, 'utf-8');
+    let config: any;
+    try {
+      config = JSON.parse(content);
+    } catch {
+      return NextResponse.json({
+        success: false,
+        error: 'Invalid configuration format',
+      } as TestResult);
+    }
+
+    // Extract config summary
+    const modelsConfig = config.models || {};
+    const providers = modelsConfig.providers || {};
+    const aarProvider = providers['aar-gateway'];
+
+    const configSummary: TestResult['configSummary'] = {
+      baseUrl: aarProvider?.baseUrl,
+      apiKey: maskApiKey(aarProvider?.apiKey || ''),
+      routerProvider: aarProvider ? 'aar' : undefined,
+    };
+
+    const primaryModel = config.agents?.defaults?.model?.primary;
+    if (primaryModel) {
+      configSummary.primaryModel = primaryModel;
+    }
+
+    const fallbackModels = config.agents?.defaults?.model?.fallbacks;
+    if (Array.isArray(fallbackModels)) {
+      configSummary.fallbackModels = fallbackModels;
+    }
+
+    const imageModel = config.agents?.defaults?.imageModel?.primary;
+    if (imageModel) {
+      configSummary.imageModel = imageModel;
+    }
+
+    const fallbackImageModels = config.agents?.defaults?.imageModel?.fallbacks;
+    if (Array.isArray(fallbackImageModels)) {
+      configSummary.fallbackImageModels = fallbackImageModels;
+    }
+
+    // Run probe command to test provider accessibility
+    const probeResult = await runCommand([
+      'models', 'status',
+      '--probe',
+      '--probe-provider', 'aar-gateway',
+      '--json'
+    ]);
+
+    let probeSuccess = false;
+    let probeMessage = 'Provider not found or not accessible';
+
+    if (probeResult.success) {
+      // Try to parse JSON output
+      try {
+        const parsed = JSON.parse(probeResult.stdout);
+        // Check if probe was successful
+        probeSuccess = parsed?.success === true || parsed?.status === 'ok';
+        if (probeSuccess) {
+          probeMessage = 'Provider is accessible and responding';
+        } else {
+          probeMessage = parsed?.message || 'Probe returned unsuccessful status';
+        }
+      } catch {
+        // If not JSON, check for success indicators in text
+        probeSuccess = probeResult.stdout.toLowerCase().includes('ok') ||
+                      probeResult.stdout.toLowerCase().includes('success') ||
+                      probeResult.stdout.toLowerCase().includes('aar-gateway');
+        probeMessage = probeSuccess
+          ? 'Provider is accessible'
+          : 'Could not verify provider status';
+      }
+    } else {
+      probeMessage = probeResult.error || `Command failed (code ${probeResult.code})`;
+    }
+
+    const checks: Record<string, boolean> = {
+      hasBaseUrl: !!aarProvider?.baseUrl,
+      hasApiKey: !!aarProvider?.apiKey && aarProvider?.apiKey !== 'your-gateway-api-key',
+      hasModels: Array.isArray(aarProvider?.models) && aarProvider.models.length > 0,
+      hasPrimaryModel: !!primaryModel,
+      hasProvider: !!aarProvider,
+      probeSuccess,
+    };
+
+    const success = checks.hasBaseUrl && checks.hasApiKey && checks.hasProvider && probeSuccess;
+
+    const result: TestResult = {
+      success,
+      message: success ? 'Configuration verified successfully' : 'Configuration verification failed',
+      checks,
+      configSummary,
+      probeResult: {
+        success: probeSuccess,
+        stdout: probeResult.stdout.slice(-3000),
+        stderr: probeResult.stderr.slice(-500),
+        error: probeResult.error,
+      },
+    };
+
+    return NextResponse.json(result);
+  } catch (error: any) {
+    console.error('OpenClaw Test API error:', error);
+    return NextResponse.json({
+      success: false,
+      error: error.message || 'Internal server error',
+    } as TestResult);
+  }
+}

package/src/app/api/ide/opencode/apply/route.ts

@@ -0,0 +1,92 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildMergedConfig } from '../build-config';
+
+const OPENCODE_DIR =
+  process.platform === 'win32'
+    ? join(process.env.APPDATA || homedir(), 'opencode')
+    : join(homedir(), '.config', 'opencode');
+const OPENCODE_FILE = join(OPENCODE_DIR, 'opencode.json');
+const BACKUP_FILE = join(OPENCODE_DIR, 'opencode.json.aar.bak');
+
+function backupOriginalConfig(): { success: boolean; existed: boolean; isFromAar: boolean; error?: string } {
+  try {
+    const existing = existsSync(OPENCODE_FILE);
+    if (existing) {
+      const original = readFileSync(OPENCODE_FILE, 'utf-8');
+      let isFromAar = false;
+      try {
+        const parsed = JSON.parse(original);
+        isFromAar = !!(parsed.provider && parsed.provider['aar-gateway']);
+      } catch {}
+      // 仅在当前配置不是 AAR 时写入备份，这样「还原」才能恢复到应用 AAR 前的状态；若已是 AAR 则保留原有备份不覆盖
+      if (!isFromAar) {
+        writeFileSync(BACKUP_FILE, original, 'utf-8');
+      }
+      return { success: true, existed: true, isFromAar };
+    }
+    return { success: true, existed: false, isFromAar: false };
+  } catch (error: any) {
+    return { success: false, existed: false, isFromAar: false, error: `Backup failed: ${error.message}` };
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { default_model: defaultModel, config: customConfigStr } = body;
+
+    let existing: Record<string, any> | null = null;
+    if (existsSync(OPENCODE_FILE)) {
+      try {
+        existing = JSON.parse(readFileSync(OPENCODE_FILE, 'utf-8'));
+      } catch {
+        existing = null;
+      }
+    }
+
+    let config: Record<string, any>;
+    if (typeof customConfigStr === 'string' && customConfigStr.trim()) {
+      try {
+        config = JSON.parse(customConfigStr);
+        if (!config || typeof config !== 'object') throw new Error('Invalid config object');
+      } catch (e: any) {
+        return NextResponse.json({ error: 'Invalid config JSON: ' + (e.message || 'parse error') }, { status: 400 });
+      }
+    } else {
+      if (defaultModel === undefined || defaultModel === '') {
+        return NextResponse.json({ error: 'Missing required field: default_model' }, { status: 400 });
+      }
+      config = await buildMergedConfig(defaultModel, existing);
+    }
+
+    const backupResult = backupOriginalConfig();
+    if (!backupResult.success) {
+      return NextResponse.json({ error: backupResult.error }, { status: 500 });
+    }
+
+    if (!existsSync(OPENCODE_DIR)) {
+      mkdirSync(OPENCODE_DIR, { recursive: true });
+    }
+
+    const jsonString = JSON.stringify(config, null, 2);
+    writeFileSync(OPENCODE_FILE, jsonString, 'utf-8');
+
+    const alreadyHadAar = !!(existing?.provider?.['aar-gateway']);
+    return NextResponse.json({
+      success: true,
+      message: alreadyHadAar ? 'OpenCode 配置已更新为最新网关信息' : 'OpenCode configuration applied successfully',
+      config,
+      backup: backupResult.existed ? 'Created backup' : 'No existing config to backup',
+      previousWasFromAar: backupResult.existed && backupResult.isFromAar,
+    });
+  } catch (error: any) {
+    console.error('OpenCode Apply API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/ide/opencode/available-models/route.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAllModels, getProviderById } from '@/db/queries';
+
+type AvailableModel = {
+  id: number;
+  name: string;
+  model_id: string;
+  provider_id: number;
+  provider_name: string;
+  enabled: boolean;
+};
+
+type GroupedModels = { [providerName: string]: AvailableModel[] };
+
+/**
+ * 查询可用模型列表（与 Claude 共用网关，用于 OpenCode 配置）
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const allModels = (await getAllModels()).filter((m: any) => m.enabled);
+
+    if (allModels.length === 0) {
+      return NextResponse.json({
+        models: {},
+        count: 0,
+        message: 'No enabled models found. Please enable some models first.',
+      });
+    }
+
+    const grouped = await allModels.reduce(async (acc: Promise<GroupedModels>, model: any) => {
+      const resolvedAcc = await acc;
+      const provider = await getProviderById(model.provider_id);
+      if (provider) {
+        if (!resolvedAcc[provider.name]) resolvedAcc[provider.name] = [];
+        resolvedAcc[provider.name].push({
+          id: model.id,
+          name: model.name,
+          model_id: model.model_id,
+          provider_id: model.provider_id,
+          provider_name: provider.name,
+          enabled: model.enabled,
+        });
+      }
+      return resolvedAcc;
+    }, Promise.resolve({} as GroupedModels));
+
+    return NextResponse.json({
+      models: grouped,
+      count: allModels.length,
+      providers: Object.keys(grouped),
+    });
+  } catch (error: any) {
+    console.error('OpenCode Available Models API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/ide/opencode/build-config.ts

@@ -0,0 +1,69 @@
+import { getDatabase } from '@/db/database';
+import { getConfig } from '@/db/queries';
+import { getAllModels, getProviderById } from '@/db/queries';
+
+export async function getGatewayAddress(): Promise<string> {
+  await getDatabase();
+  const portConfig = await getConfig('port');
+  const port = portConfig?.value || '1357';
+  return `http://localhost:${port}/v1`;
+}
+
+export async function getGatewayApiKey(): Promise<string> {
+  await getDatabase();
+  const apiKeyConfig = await getConfig('api_key');
+  return apiKeyConfig?.value || 'your-gateway-api-key';
+}
+
+/** OpenCode provider 下单个 provider 的结构（与官方 provider 文档一致） */
+export type AarGatewayProviderEntry = {
+  npm: string;
+  name: string;
+  options: { baseURL: string; apiKey: string };
+  models: Record<string, { name: string; limit?: { context: number; output?: number } }>;
+};
+
+export async function buildAarGatewayProvider(): Promise<AarGatewayProviderEntry> {
+  const gatewayAddress = await getGatewayAddress();
+  const gatewayApiKey = await getGatewayApiKey();
+  const allModels = (await getAllModels()).filter((m: any) => m.enabled);
+  const models: Record<string, { name: string; limit: { context: number; output: number } }> = {};
+  for (const m of allModels) {
+    await getProviderById(m.provider_id);
+    models[m.model_id] = { name: m.name, limit: { context: 128000, output: 65536 } };
+  }
+  return {
+    npm: '@ai-sdk/openai-compatible',
+    name: 'AAR Model Router',
+    options: { baseURL: gatewayAddress, apiKey: gatewayApiKey },
+    models,
+  };
+}
+
+const AAR_PROVIDER_ID = 'aar-gateway';
+
+/** 合并现有配置与 AAR 网关：写入 config.provider["aar-gateway"]，并设置 config.model = "aar-gateway/{defaultModel}" */
+export function mergeConfigWithAar(
+  existing: Record<string, any> | null,
+  defaultModel: string,
+  aarProvider: AarGatewayProviderEntry
+): Record<string, any> {
+  const base = existing && typeof existing === 'object' ? { ...existing } : {};
+  const provider: Record<string, any> =
+    base.provider && typeof base.provider === 'object' ? { ...base.provider } : {};
+  provider[AAR_PROVIDER_ID] = aarProvider;
+  return {
+    ...base,
+    provider,
+    model: `${AAR_PROVIDER_ID}/${defaultModel}`,
+  };
+}
+
+/** 生成合并后的配置（不写入磁盘），供预览或应用使用 */
+export async function buildMergedConfig(
+  defaultModel: string,
+  existing: Record<string, any> | null
+): Promise<Record<string, any>> {
+  const aarProvider = await buildAarGatewayProvider();
+  return mergeConfigWithAar(existing, defaultModel, aarProvider);
+}

package/src/app/api/ide/opencode/preview/route.ts

@@ -0,0 +1,40 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildMergedConfig } from '../build-config';
+
+const OPENCODE_FILE =
+  process.platform === 'win32'
+    ? join(process.env.APPDATA || homedir(), 'opencode', 'opencode.json')
+    : join(homedir(), '.config', 'opencode', 'opencode.json');
+
+/** GET ?default_model=xxx 返回配置预览：始终返回「现有配置 + AAR provider + 默认模型」的合并结果，即应用后将写入的内容 */
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const defaultModel = searchParams.get('default_model') || '';
+
+    if (!defaultModel) {
+      return NextResponse.json({ error: 'Missing query: default_model' }, { status: 400 });
+    }
+
+    let existing: Record<string, any> | null = null;
+    if (existsSync(OPENCODE_FILE)) {
+      try {
+        existing = JSON.parse(readFileSync(OPENCODE_FILE, 'utf-8'));
+      } catch {
+        /* 文件损坏时 existing 保持 null */
+      }
+    }
+
+    const config = await buildMergedConfig(defaultModel, existing);
+    return NextResponse.json({ config });
+  } catch (error: any) {
+    console.error('OpenCode Preview API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/ide/opencode/restore/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, copyFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const OPENCODE_DIR =
+  process.platform === 'win32'
+    ? join(process.env.APPDATA || homedir(), 'opencode')
+    : join(homedir(), '.config', 'opencode');
+const OPENCODE_FILE = join(OPENCODE_DIR, 'opencode.json');
+const BACKUP_FILE = join(OPENCODE_DIR, 'opencode.json.aar.bak');
+
+export async function POST(request: NextRequest) {
+  try {
+    if (!existsSync(BACKUP_FILE)) {
+      return NextResponse.json(
+        { error: 'No backup file found. Please apply configuration first before restoring.' },
+        { status: 404 }
+      );
+    }
+
+    const backupContent = readFileSync(BACKUP_FILE, 'utf-8');
+
+    if (!existsSync(OPENCODE_DIR)) {
+      return NextResponse.json({ error: 'OpenCode config directory does not exist' }, { status: 500 });
+    }
+
+    copyFileSync(BACKUP_FILE, OPENCODE_FILE);
+
+    let parsedBackup: any;
+    try {
+      parsedBackup = JSON.parse(backupContent);
+    } catch {
+      return NextResponse.json(
+        { error: 'Backup file is corrupted or invalid JSON', backupContent },
+        { status: 500 }
+      );
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: 'OpenCode configuration restored successfully',
+      config: parsedBackup,
+    });
+  } catch (error: any) {
+    console.error('OpenCode Restore API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/ide/opencode/save/route.ts

@@ -0,0 +1,131 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getDatabase } from '@/db/database';
+import { getConfig } from '@/db/queries';
+import { buildMergedConfig } from '../build-config';
+
+const OPENCODE_DIR =
+  process.platform === 'win32'
+    ? join(process.env.APPDATA || homedir(), 'opencode')
+    : join(homedir(), '.config', 'opencode');
+const OPENCODE_FILE = join(OPENCODE_DIR, 'opencode.json');
+const BACKUP_FILE = join(OPENCODE_DIR, 'opencode.json.aar.bak');
+const AAR_DIR = join(homedir(), '.aar');
+const TEMP_OPENCODE_FILE = join(AAR_DIR, 'opencode.tmp.json');
+
+function backupIfExists(): { success: boolean; error?: string } {
+  try {
+    if (existsSync(OPENCODE_FILE)) {
+      const original = readFileSync(OPENCODE_FILE, 'utf-8');
+      writeFileSync(BACKUP_FILE, original, 'utf-8');
+    }
+    return { success: true };
+  } catch (error: any) {
+    return { success: false, error: `Backup failed: ${error.message}` };
+  }
+}
+
+async function getGatewayAddress(): Promise<string> {
+  await getDatabase();
+  const portConfig = await getConfig('port');
+  return `http://localhost:${portConfig?.value || '1357'}/v1`;
+}
+
+async function getGatewayApiKey(): Promise<string> {
+  await getDatabase();
+  const apiKeyConfig = await getConfig('api_key');
+  return apiKeyConfig?.value || 'your-gateway-api-key';
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { default_model: defaultModel, config: customConfigStr } = body;
+
+    // 若前端传了编辑后的 config，直接写入 opencode.json（与「应用配置」一致）
+    if (typeof customConfigStr === 'string' && customConfigStr.trim()) {
+      let config: Record<string, any>;
+      try {
+        config = JSON.parse(customConfigStr);
+        if (!config || typeof config !== 'object') throw new Error('Invalid config object');
+      } catch (e: any) {
+        return NextResponse.json({ error: 'Invalid config JSON: ' + (e.message || 'parse error') }, { status: 400 });
+      }
+      const backupResult = backupIfExists();
+      if (!backupResult.success) {
+        return NextResponse.json({ error: backupResult.error }, { status: 500 });
+      }
+      if (!existsSync(OPENCODE_DIR)) mkdirSync(OPENCODE_DIR, { recursive: true });
+      writeFileSync(OPENCODE_FILE, JSON.stringify(config, null, 2), 'utf-8');
+      return NextResponse.json({
+        success: true,
+        message: '配置已更新到 OpenCode',
+        saveType: 'applied',
+        savePath: '~/.config/opencode/opencode.json',
+        config,
+      });
+    }
+
+    if (defaultModel === undefined || defaultModel === '') {
+      return NextResponse.json({ error: 'No default model provided' }, { status: 400 });
+    }
+
+    const gatewayAddress = await getGatewayAddress();
+    const gatewayApiKey = await getGatewayApiKey();
+
+    const fileExists = existsSync(OPENCODE_FILE);
+    let current: Record<string, any> | null = null;
+    if (fileExists) {
+      try {
+        current = JSON.parse(readFileSync(OPENCODE_FILE, 'utf-8'));
+      } catch {
+        current = null;
+      }
+    }
+    const aar = current?.provider?.['aar-gateway'];
+    const isCurrentGatewayApplied =
+      !!aar &&
+      aar?.options?.baseURL === gatewayAddress &&
+      aar?.options?.apiKey === gatewayApiKey;
+
+    let savePath: string;
+    let saveType: string;
+    let mergedConfig: any;
+
+    if (fileExists && isCurrentGatewayApplied && current) {
+      mergedConfig = await buildMergedConfig(defaultModel, current);
+      savePath = OPENCODE_FILE;
+      saveType = 'applied';
+    } else {
+      savePath = TEMP_OPENCODE_FILE;
+      saveType = 'temp';
+      mergedConfig = {
+        defaultModel,
+        isTemp: true,
+        savedAt: new Date().toISOString(),
+      };
+    }
+
+    const targetDir = savePath === OPENCODE_FILE ? OPENCODE_DIR : AAR_DIR;
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    writeFileSync(savePath, JSON.stringify(mergedConfig, null, 2), 'utf-8');
+
+    return NextResponse.json({
+      success: true,
+      message: saveType === 'applied' ? '配置已更新到 OpenCode' : '配置已保存（临时）',
+      saveType,
+      savePath: savePath === OPENCODE_FILE ? '~/.config/opencode/opencode.json' : '~/.aar/opencode.tmp.json',
+      config: mergedConfig,
+    });
+  } catch (error: any) {
+    console.error('OpenCode Save API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error', stack: process.env.NODE_ENV === 'development' ? error.stack : undefined },
+      { status: 500 }
+    );
+  }
+}