aws-runtime-bridge 1.0.0

package/dist/index.js

@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+/**
+ * Runtime Bridge 服务主入口
+ *
+ * 提供 Agent 运行时与调度器之间的桥接功能
+ */
+import express from "express";
+import cors from "cors";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { allowedCorsOrigins, port, validateProductionToken } from "./config.js";
+import { propertiesRouter } from "./routes/properties.js";
+import { ymlRouter } from "./routes/yml.js";
+import { instanceRouter, setGracefulShutdownFn } from "./routes/instance.js";
+import { skillsRouter } from "./routes/skills.js";
+import { mcpRouter } from "./routes/mcp.js";
+import { terminalRouter, sdkSessions } from "./routes/terminal.js";
+import { sessionsRouter } from "./routes/sessions.js";
+import { gitRouter } from "./routes/git.js";
+import { fileBrowserRouter } from "./routes/file-browser.js";
+import { aiSourcesRouter } from "./routes/ai-sources.js";
+import { processesRouter } from "./routes/processes.js";
+import { sessions, flushSessionOutput } from "./services/session-output.js";
+import { loadPersistedSessions, savePersistedSessions } from "./services/terminal-persistence.js";
+import { detectOrphanProcesses } from "./services/process-detector.js";
+import { startOrphanMonitor, stopOrphanMonitor } from "./services/orphan-monitor.js";
+import { getAgentProcessManager } from "./services/agent-process-manager.js";
+import { adapterRegistry } from "./adapter/index.js";
+import { logger } from "./utils/logger.js";
+import { autoRegister, unregister, bridgeRestartCleanup } from "./services/auto-register.js";
+import { ensureAwsClientAgentMcpReleased } from "./services/aws-client-agent-mcp.js";
+// 验证生产环境配置
+validateProductionToken();
+ensureAwsClientAgentMcpReleased();
+// ★ 启动时自动注册
+async function performAutoRegister() {
+    try {
+        const success = await autoRegister();
+        if (success) {
+            logger.info("[runtime-bridge] 自动注册成功");
+        }
+        else {
+            // 检查注册状态
+            const { loadConfig } = await import("./services/auto-register.js");
+            const config = loadConfig();
+            // 判断是否有配置（配置文件存在或环境变量设置了必填项）
+            const hasConfig = config.tenantId && config.userKey;
+            if (hasConfig && config.enabled) {
+                // 有配置但注册失败，服务启动失败
+                logger.error("[runtime-bridge] 自动注册已启用但注册失败，服务启动失败");
+                logger.error("[runtime-bridge] 请检查调度中心是否可达、配置是否正确");
+                process.exitCode = 1;
+            }
+            else {
+                // 没有配置，正常启动服务
+                logger.info("[runtime-bridge] 自动注册未配置，继续启动服务");
+                logger.info("[runtime-bridge] 要启用自动注册，请创建配置文件 ~/.aws-bridge/config.json");
+            }
+        }
+    }
+    catch (error) {
+        const err = error;
+        logger.warn("[runtime-bridge] 自动注册出错:", err.message);
+    }
+}
+performAutoRegister()
+    .then(() => {
+    // ★★★ Bridge 重启清理
+    // 在注册完成后执行清理，确保调度中心将该 bridge 关联的所有 Agent 设置为离线
+    // 这样可以确保 bridge 重启后，之前启动的 Agent 显示为"离线+停止"状态
+    return performBridgeRestartCleanup();
+})
+    .catch(err => {
+    logger.warn("[runtime-bridge] 自动注册或清理出错:", err);
+});
+// ★★★ Bridge 重启清理
+// 在启动时通知调度中心清理该 bridge 关联的所有 Agent 状态
+// 这样可以确保 bridge 重启后，之前启动的 Agent 显示为"离线+停止"状态
+async function performBridgeRestartCleanup() {
+    try {
+        // 只有在已注册的情况下才执行清理
+        const { getRegistrationState } = await import("./services/auto-register.js");
+        const state = getRegistrationState();
+        if (!state.registered || !state.instanceId) {
+            logger.info("[runtime-bridge] 实例未注册，跳过 Bridge 重启清理");
+            return;
+        }
+        logger.info("[runtime-bridge] ★ Bridge 重启，正在通知调度中心清理 Agent 状态...");
+        const result = await bridgeRestartCleanup();
+        if (result.success) {
+            logger.info(`[runtime-bridge] ★ Bridge 重启清理成功，清理了 ${result.agentCount || 0} 个 Agent`);
+        }
+        else {
+            logger.warn(`[runtime-bridge] ★ Bridge 重启清理失败: ${result.error}`);
+        }
+    }
+    catch (error) {
+        const err = error;
+        logger.warn("[runtime-bridge] Bridge 重启清理出错:", err.message);
+    }
+}
+// ★ 启动时重建进程注册表
+async function rebuildProcessRegistry() {
+    try {
+        const persistedSessions = await loadPersistedSessions();
+        if (persistedSessions.length === 0) {
+            logger.info("[runtime-bridge] 无持久化会话，跳过进程注册表重建");
+            return;
+        }
+        const manager = getAgentProcessManager();
+        await manager.rebuildRegistry(persistedSessions.map(s => ({
+            agentId: s.agentId,
+            sessionId: s.sessionId,
+            pid: s.pid,
+            workspacePath: s.workspacePath,
+            command: s.command,
+            mode: s.mode || 'pty',
+        })));
+        logger.info(`[runtime-bridge] 进程注册表重建完成: ${persistedSessions.length} 条记录`);
+    }
+    catch (error) {
+        const err = error;
+        logger.warn("[runtime-bridge] 进程注册表重建失败:", err.message);
+    }
+}
+rebuildProcessRegistry().catch(err => {
+    logger.warn("[runtime-bridge] 进程注册表重建出错:", err);
+});
+// ★ 启动时检测孤儿进程并自动清理
+// ★★★ 修复：bridge 重启时清理所有 agent 进程（包括 SDK 模式）
+// 因为 bridge 重启意味着整个运行环境重启，所有 agent 都应该被清理
+// ★★★ 例外：如果存在 .preserve-sessions 标记文件，说明是 aws-mcp-server 重启，需要保留会话
+async function detectOrphansOnStartup() {
+    try {
+        // ★★★ 检查是否存在保留会话标记文件
+        const fs = await import('fs/promises');
+        const path = await import('path');
+        const os = await import('os');
+        const restartFlagFile = path.join(os.tmpdir(), 'agentswork-runtime-bridge', '.preserve-sessions');
+        let preserveSessions = false;
+        try {
+            const flagContent = await fs.readFile(restartFlagFile, 'utf-8');
+            const flag = JSON.parse(flagContent);
+            preserveSessions = flag.preserveSessions === true;
+            // 读取后删除标记文件
+            await fs.unlink(restartFlagFile);
+            logger.info(`[runtime-bridge] ★ 检测到保留会话标记，preserveSessions=${preserveSessions}`);
+        }
+        catch {
+            // 标记文件不存在，正常启动
+        }
+        const persistedSessions = await loadPersistedSessions();
+        if (persistedSessions.length === 0) {
+            logger.info("[runtime-bridge] 启动时无持久化会话，无需检测孤儿进程");
+            return;
+        }
+        // ★★★ 如果是 aws-mcp-server 重启触发的 bridge 启动，保留会话
+        if (preserveSessions) {
+            logger.info(`[runtime-bridge] ★ aws-mcp-server 重启恢复场景，保留 ${persistedSessions.length} 个会话`);
+            // 重建进程注册表
+            const manager = getAgentProcessManager();
+            await manager.rebuildRegistry(persistedSessions.map(s => ({
+                agentId: s.agentId,
+                sessionId: s.sessionId,
+                pid: s.pid,
+                workspacePath: s.workspacePath,
+                command: s.command,
+                mode: s.mode || 'pty',
+            })));
+            return;
+        }
+        logger.info(`[runtime-bridge] ★ Bridge 重启，检测 ${persistedSessions.length} 个持久化会话的孤儿进程...`);
+        // ★★★ 修复：不再区分 SDK 和 PTY 模式，全部清理
+        // bridge 重启 = 整个运行环境重启，所有 agent 都应该被终止
+        const orphans = detectOrphanProcesses(persistedSessions.map(s => ({
+            agentId: s.agentId,
+            pid: s.pid,
+            workspacePath: s.workspacePath,
+            command: s.command,
+        })));
+        if (orphans.length > 0) {
+            logger.warn(`[runtime-bridge] ★ 检测到 ${orphans.length} 个孤儿进程仍在运行：`);
+            for (const orphan of orphans) {
+                logger.warn(`  - agentId=${orphan.agentId}, pid=${orphan.process.pid}, command=${orphan.process.command?.slice(0, 50)}`);
+            }
+            // ★ 自动清理所有孤儿进程
+            logger.info("[runtime-bridge] 正在自动清理所有孤儿进程...");
+            for (const orphan of orphans) {
+                try {
+                    if (orphan.process.pid) {
+                        // 使用跨平台方式终止进程
+                        if (process.platform === 'win32') {
+                            const { execSync } = await import('child_process');
+                            execSync(`taskkill /PID ${orphan.process.pid} /T /F`, { encoding: 'utf8', timeout: 3000 });
+                            logger.info(`[runtime-bridge] 已自动终止孤儿进程: agentId=${orphan.agentId}, PID=${orphan.process.pid}`);
+                        }
+                        else {
+                            process.kill(orphan.process.pid, 'SIGKILL');
+                            logger.info(`[runtime-bridge] 已自动终止孤儿进程: agentId=${orphan.agentId}, PID=${orphan.process.pid}`);
+                        }
+                    }
+                }
+                catch (killError) {
+                    const err = killError;
+                    logger.warn(`[runtime-bridge] 自动终止孤儿进程失败: agentId=${orphan.agentId}, PID=${orphan.process.pid}, error=${err.message}`);
+                }
+            }
+            // 等待进程完全终止
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        // ★★★ 修复：bridge 重启后清空所有持久化会话
+        // 不再保留任何会话，因为所有 agent 都应该被清理
+        await savePersistedSessions([]);
+        logger.info(`[runtime-bridge] ★ Bridge 重启完成，已清空所有持久化会话（清理了 ${orphans.length} 个孤儿进程）`);
+    }
+    catch (error) {
+        const err = error;
+        logger.warn("[runtime-bridge] 启动时孤儿进程检测失败:", err.message);
+    }
+}
+// 执行孤儿进程检测
+detectOrphansOnStartup().catch(err => {
+    logger.warn("[runtime-bridge] 孤儿进程检测出错:", err);
+});
+// ★ 启动孤儿进程定期监控
+startOrphanMonitor().catch(err => {
+    logger.warn("[runtime-bridge] 启动孤儿进程监控失败:", err);
+});
+// 创建 Express 应用
+const app = express();
+// 中间件配置
+app.use(cors({
+    origin(origin, callback) {
+        if (!origin || allowedCorsOrigins.includes(origin)) {
+            callback(null, true);
+            return;
+        }
+        callback(new Error(`[runtime-bridge] CORS origin is not allowed: ${origin}`));
+    },
+}));
+app.use(express.json({ limit: "1mb" }));
+// 注册路由
+app.use("/runtime", propertiesRouter);
+app.use("/runtime", ymlRouter);
+app.use("/runtime", instanceRouter);
+app.use("/runtime", skillsRouter);
+app.use("/runtime", mcpRouter);
+app.use("/runtime", terminalRouter);
+app.use("/runtime", sessionsRouter);
+app.use("/runtime", processesRouter);
+app.use("/runtime", gitRouter);
+app.use("/runtime", aiSourcesRouter);
+app.use("/api/file-browser", fileBrowserRouter);
+/**
+ * 启动 HTTP 服务并对端口占用给出可诊断错误，避免未捕获异常直接崩溃。
+ */
+function startServer() {
+    const server = app.listen(port, () => {
+        logger.info(`[runtime-bridge] listening on ${port}`);
+    });
+    server.on("error", (error) => {
+        if (error.code === "EADDRINUSE") {
+            logger.error(`[runtime-bridge] port ${port} is already in use. ` +
+                "Stop the existing runtime-bridge process or set AWS_RUNTIME_BRIDGE_PORT to another port before starting.");
+            process.exitCode = 1;
+            return;
+        }
+        logger.error("[runtime-bridge] failed to start server:", error);
+        process.exitCode = 1;
+    });
+    return server;
+}
+/**
+ * 优雅关闭处理
+ *
+ * 在收到终止信号时：
+ * 1. 停止所有 PTY 会话（杀死终端进程）
+ * 2. 停止所有 SDK 会话（终止 Agent 进程）
+ * 3. 验证所有进程已终止
+ * 4. 清空持久化状态（避免恢复残留会话）
+ * 5. 关闭 HTTP 服务器
+ *
+ * ★★★ 修复：添加 preserveSessions 参数
+ * - preserveSessions=true: aws-mcp-server 触发的关闭，保留会话状态
+ * - preserveSessions=false: bridge 自己关闭，清理所有会话
+ */
+let isShuttingDown = false;
+async function gracefulShutdown(signal, server, preserveSessions = false) {
+    if (isShuttingDown) {
+        logger.info(`[runtime-bridge] 已在关闭中，忽略 ${signal}`);
+        return;
+    }
+    isShuttingDown = true;
+    // ★★★ 防御性检测：如果 preserveSessions 未显式设为 true，
+    // 检查 .preserve-sessions 标记文件是否存在。
+    // 这是为了覆盖所有调用路径（包括非信号处理器路径）都能正确识别 aws-mcp-server 重启场景。
+    if (!preserveSessions) {
+        const flagExists = checkPreserveFlagSync();
+        if (flagExists) {
+            preserveSessions = true;
+            logger.info(`[runtime-bridge] ★ 检测到 .preserve-sessions 标记文件，自动升级为保留会话模式`);
+        }
+    }
+    logger.info(`[runtime-bridge] 收到 ${signal} 信号，开始优雅关闭... (preserveSessions=${preserveSessions})`);
+    const startTime = Date.now();
+    try {
+        // 1. 停止所有 PTY 会话
+        const ptyCount = sessions.size;
+        logger.info(`[runtime-bridge] 正在停止 ${ptyCount} 个 PTY 会话...`);
+        for (const [sessionId, session] of sessions.entries()) {
+            try {
+                // 清理定时器
+                if (session.flushTimer) {
+                    clearTimeout(session.flushTimer);
+                    session.flushTimer = null;
+                }
+                // 刷新剩余输出
+                try {
+                    await flushSessionOutput(sessionId);
+                }
+                catch {
+                    // 忽略刷新错误
+                }
+                // 杀死 PTY 进程
+                try {
+                    session.ptyProcess.kill();
+                    logger.info(`[runtime-bridge] PTY 会话 ${sessionId} 已终止 (PID: ${session.ptyProcess.pid})`);
+                }
+                catch {
+                    // 忽略终止错误
+                }
+                sessions.delete(sessionId);
+            }
+            catch (e) {
+                const err = e;
+                logger.error(`[runtime-bridge] PTY 会话 ${sessionId} 终止失败:`, err.message);
+            }
+        }
+        // 2. 停止所有 SDK 会话
+        const sdkCount = sdkSessions.size;
+        logger.info(`[runtime-bridge] 正在停止 ${sdkCount} 个 SDK 会话...`);
+        for (const [sessionId, entry] of sdkSessions.entries()) {
+            try {
+                const providerId = entry.providerId || "claude-code";
+                const adapter = adapterRegistry.get(providerId);
+                // 尝试获取 PID 用于日志
+                let pidInfo = '';
+                try {
+                    const pid = adapter.getSessionPid?.(sessionId);
+                    if (pid) {
+                        pidInfo = ` (PID: ${pid})`;
+                    }
+                }
+                catch {
+                    // 忽略 PID 获取错误
+                }
+                await adapter.terminateSession(sessionId);
+                logger.info(`[runtime-bridge] SDK 会话 ${sessionId} 已终止${pidInfo}`);
+                sdkSessions.delete(sessionId);
+            }
+            catch (e) {
+                const err = e;
+                logger.error(`[runtime-bridge] SDK 会话 ${sessionId} 终止失败:`, err.message);
+                // 即使失败也从内存中移除
+                sdkSessions.delete(sessionId);
+            }
+        }
+        // 3. 停止孤儿进程监控
+        logger.info("[runtime-bridge] 正在停止孤儿进程监控...");
+        stopOrphanMonitor();
+        // 4. ★ 验证所有进程已终止（等待一小段时间让进程完全退出）
+        logger.info("[runtime-bridge] 等待进程完全终止...");
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // 5. 检查是否还有残留进程，如果有则强制终止
+        try {
+            const { detectOrphanProcesses, terminateProcessTree } = await import("./services/process-detector.js");
+            const { loadPersistedSessions } = await import("./services/terminal-persistence.js");
+            const persistedSessions = await loadPersistedSessions();
+            if (persistedSessions.length > 0) {
+                const orphans = detectOrphanProcesses(persistedSessions.map(s => ({
+                    agentId: s.agentId,
+                    pid: s.pid,
+                    workspacePath: s.workspacePath,
+                    command: s.command,
+                })));
+                if (orphans.length > 0) {
+                    logger.warn(`[runtime-bridge] 检测到 ${orphans.length} 个残留进程，正在强制终止...`);
+                    for (const orphan of orphans) {
+                        if (orphan.process.pid) {
+                            // 使用进程树终止（跨平台）
+                            const result = terminateProcessTree(orphan.process.pid);
+                            logger.info(`[runtime-bridge] 已强制终止残留进程树：agentId=${orphan.agentId}, PID=${orphan.process.pid}, 终止了 ${result.terminated} 个进程`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (checkError) {
+            const err = checkError;
+            logger.warn("[runtime-bridge] 残留进程检查失败:", err.message);
+        }
+        // 6. 注销实例
+        logger.info("[runtime-bridge] 正在注销实例...");
+        try {
+            await unregister();
+        }
+        catch (e) {
+            const err = e;
+            logger.error("[runtime-bridge] 注销实例失败:", err.message);
+        }
+        // 7. ★★★ 修复：根据 preserveSessions 决定是否清空持久化状态
+        // - preserveSessions=true (aws-mcp-server 触发): 保留会话状态，aws-mcp-server 重启后可恢复
+        // - preserveSessions=false (bridge 自己关闭): 清空所有会话，agent 应被清理
+        if (!preserveSessions) {
+            logger.info("[runtime-bridge] 正在清空持久化会话状态...");
+            try {
+                await savePersistedSessions([]);
+            }
+            catch (e) {
+                const err = e;
+                logger.error("[runtime-bridge] 清空持久化状态失败:", err.message);
+            }
+        }
+        else {
+            logger.info("[runtime-bridge] ★ 保留持久化会话状态（aws-mcp-server 重启恢复场景）");
+        }
+        // 8. 关闭 HTTP 服务器
+        const elapsed = Date.now() - startTime;
+        logger.info(`[runtime-bridge] 优雅关闭完成 (耗时 ${elapsed}ms)，停止 ${ptyCount} PTY + ${sdkCount} SDK 会话`);
+        server.close(() => {
+            logger.info("[runtime-bridge] HTTP 服务器已关闭");
+            process.exit(0);
+        });
+        // 强制退出超时（防止卡住）
+        setTimeout(() => {
+            logger.warn("[runtime-bridge] 优雅关闭超时，强制退出");
+            process.exit(1);
+        }, 8000); // 增加到 8 秒，给进程终止更多时间
+    }
+    catch (e) {
+        const err = e;
+        logger.error("[runtime-bridge] 优雅关闭过程中发生错误:", err);
+        process.exit(1);
+    }
+}
+// 启动服务器
+const server = startServer();
+/**
+ * ★★★ 修复：同步检测 .preserve-sessions 标记文件
+ *
+ * 当 aws-mcp-server 调用 /runtime/prepare-restart 后，
+ * 会在临时目录创建该标记文件。桥接器收到 SIGTERM/SIGINT 时，
+ * 应检查此文件来决定是否保留会话。
+ *
+ * 信号处理器必须使用同步 I/O，因为异步操作在信号上下文中不可靠。
+ */
+const RESTART_FLAG_FILE = path.join(os.tmpdir(), 'agentswork-runtime-bridge', '.preserve-sessions');
+function checkPreserveFlagSync() {
+    try {
+        if (existsSync(RESTART_FLAG_FILE)) {
+            const content = readFileSync(RESTART_FLAG_FILE, 'utf-8');
+            const flag = JSON.parse(content);
+            return flag.preserveSessions === true;
+        }
+    }
+    catch {
+        // 文件不存在或无法解析，按不保留处理
+    }
+    return false;
+}
+// ★★★ 设置 gracefulShutdown 函数引用，供 instance router 使用
+setGracefulShutdownFn(async (signal, preserveSessions) => {
+    await gracefulShutdown(signal, server, preserveSessions);
+});
+// 注册终止信号处理器
+// ★★★ 修复：收到终止信号时先检查 aws-mcp-server 是否已调用 prepare-restart
+// 如果标记文件存在，说明是 aws-mcp-server 重启场景，需要保留会话状态
+process.on("SIGTERM", () => {
+    const preserve = checkPreserveFlagSync();
+    gracefulShutdown("SIGTERM", server, preserve);
+});
+process.on("SIGINT", () => {
+    const preserve = checkPreserveFlagSync();
+    gracefulShutdown("SIGINT", server, preserve);
+});
+// Windows 支持（Ctrl+C 在 Windows 上触发 SIGBREAK）
+if (process.platform === "win32") {
+    process.on("SIGBREAK", () => {
+        const preserve = checkPreserveFlagSync();
+        gracefulShutdown("SIGBREAK", server, preserve);
+    });
+}
+// 未捕获异常处理
+process.on("uncaughtException", (error) => {
+    logger.error("[runtime-bridge] 未捕获异常:", error);
+    // ★ 未捕获异常时不检查标记文件 — 异常重启需要完整清理
+    gracefulShutdown("uncaughtException", server);
+});
+process.on("unhandledRejection", (reason, promise) => {
+    logger.error("[runtime-bridge] 未处理的 Promise 拒绝:", reason);
+    // 不立即退出，只记录错误
+});

package/dist/middleware/auth.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Token 验证中间件
+ *
+ * 验证请求头中的 X-Runtime-Token 是否与配置的 runtimeToken 匹配
+ */
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Token 验证中间件
+ * 检查请求头中的 X-Runtime-Token 是否有效
+ */
+export declare function validateToken(req: Request, res: Response, next: NextFunction): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/middleware/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG/D;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAOnF"}

package/dist/middleware/auth.js

@@ -0,0 +1,18 @@
+/**
+ * Token 验证中间件
+ *
+ * 验证请求头中的 X-Runtime-Token 是否与配置的 runtimeToken 匹配
+ */
+import { runtimeToken } from '../config.js';
+/**
+ * Token 验证中间件
+ * 检查请求头中的 X-Runtime-Token 是否有效
+ */
+export function validateToken(req, res, next) {
+    const token = req.header('X-Runtime-Token');
+    if (token !== runtimeToken) {
+        res.status(401).json({ error: 'unauthorized' });
+        return;
+    }
+    next();
+}

package/dist/routes/ai-sources.d.ts

@@ -0,0 +1,2 @@
+export declare const aiSourcesRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=ai-sources.d.ts.map

package/dist/routes/ai-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sources.d.ts","sourceRoot":"","sources":["../../src/routes/ai-sources.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe,4CAAW,CAAC"}

package/dist/routes/ai-sources.js

@@ -0,0 +1,136 @@
+import { Router } from 'express';
+import axios from 'axios';
+import { validateToken } from '../middleware/auth.js';
+import { getAiConfigService } from '../services/cc-switch-sdk.js';
+import { buildToolSpecificAiConfig, } from '@cc-switch/sdk';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('ai-sources');
+export const aiSourcesRouter = Router();
+function normalizeListedModels(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return [];
+    }
+    const payloadRecord = payload;
+    const data = Array.isArray(payloadRecord.data) ? payloadRecord.data : [];
+    const ids = new Set();
+    for (const item of data) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const id = String(item.id || '').trim();
+        if (id) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+async function fetchRemoteModelList(baseUrl, apiKey) {
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, '');
+    const openAiCandidates = normalizedBaseUrl.endsWith('/v1')
+        ? [`${normalizedBaseUrl}/models`]
+        : [`${normalizedBaseUrl}/models`, `${normalizedBaseUrl}/v1/models`];
+    for (const candidate of openAiCandidates) {
+        try {
+            const response = await axios.get(candidate, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                timeout: 10000,
+            });
+            const models = normalizeListedModels(response.data);
+            if (models.length > 0) {
+                return models;
+            }
+        }
+        catch {
+            // continue probing next compatible endpoint
+        }
+    }
+    const anthropicCandidate = `${normalizedBaseUrl.endsWith('/v1') ? normalizedBaseUrl : `${normalizedBaseUrl}/v1`}/models`;
+    const anthropicResponse = await axios.get(anthropicCandidate, {
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        timeout: 10000,
+    });
+    return normalizeListedModels(anthropicResponse.data);
+}
+aiSourcesRouter.post('/cc-switch/apply-ai-sources', validateToken, async (req, res) => {
+    const { agentId, template, claudecodeTemplateId, codexTemplateId, opencodeTemplateId, claudecode, codex, opencode, } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const aiConfigService = getAiConfigService();
+        const generatedConfig = template ? buildToolSpecificAiConfig({
+            baseUrl: String(template?.baseUrl || ''),
+            apiKey: String(template?.apiKey || ''),
+            model: String(template?.model || ''),
+            models: Array.isArray(template?.models)
+                ? template.models.map((item) => String(item || '').trim()).filter(Boolean)
+                : undefined,
+        }) : null;
+        const claudeSource = generatedConfig?.claudecode || claudecode;
+        const codexSource = generatedConfig?.codex || codex;
+        const opencodeSource = generatedConfig?.opencode || opencode;
+        let mergedClaude = null;
+        let mergedCodex = null;
+        let mergedOpencode = null;
+        if (claudeSource && typeof claudeSource === 'object') {
+            mergedClaude = await aiConfigService.applyClaudeCodeConfig(claudeSource);
+        }
+        if (codexSource && typeof codexSource === 'object') {
+            mergedCodex = await aiConfigService.applyCodexConfig(codexSource);
+        }
+        if (opencodeSource && typeof opencodeSource === 'object') {
+            mergedOpencode = await aiConfigService.applyOpenCodeConfig(opencodeSource);
+        }
+        res.json({
+            ok: true,
+            agentId: String(agentId),
+            claudecodeTemplateId: String(claudecodeTemplateId || ''),
+            codexTemplateId: String(codexTemplateId || ''),
+            opencodeTemplateId: String(opencodeTemplateId || ''),
+            generatedFromUnifiedTemplate: Boolean(generatedConfig),
+            applied: {
+                claudecode: claudeSource && typeof claudeSource === 'object' ? Object.keys(claudeSource) : [],
+                codex: codexSource && typeof codexSource === 'object' ? Object.keys(codexSource) : [],
+                opencode: opencodeSource && typeof opencodeSource === 'object' ? Object.keys(opencodeSource) : [],
+            },
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('Failed to apply AI sources', {
+            error: err?.message,
+            agentId: String(agentId || ''),
+        });
+        res.status(400).json({ error: err?.message || 'apply ai sources failed' });
+    }
+});
+aiSourcesRouter.post('/cc-switch/list-ai-models', validateToken, async (req, res) => {
+    const { baseUrl, apiKey } = req.body || {};
+    const normalizedBaseUrl = String(baseUrl || '').trim();
+    const normalizedApiKey = String(apiKey || '').trim();
+    if (!normalizedBaseUrl || !normalizedApiKey) {
+        res.status(400).json({ error: 'baseUrl and apiKey are required' });
+        return;
+    }
+    try {
+        const models = await fetchRemoteModelList(normalizedBaseUrl, normalizedApiKey);
+        res.json({
+            ok: true,
+            models,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('Failed to list remote AI models', {
+            error: err?.message,
+            baseUrl: normalizedBaseUrl,
+        });
+        res.status(400).json({ error: err?.message || 'list ai models failed' });
+    }
+});