aws-runtime-bridge 1.0.0

package/dist/routes/instance.js

@@ -0,0 +1,170 @@
+import { Router } from 'express';
+import axios from 'axios';
+import { validateToken } from '../middleware/auth.js';
+import { schedulerBaseUrl, runtimeToken } from '../config.js';
+import { loadInstanceState, saveInstanceState } from '../services/instance-state.js';
+import { initInstance } from '../services/instance-init-service.js';
+import { detectToolStatuses, ensureToolsInstalled, SUPPORTED_INSTALLABLE_TOOLS } from '../services/tool-installer.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('instance');
+// ★★★ 导出 gracefulShutdown 的触发函数
+// 用于 aws-mcp-server 通知 bridge 保留会话状态关闭
+let gracefulShutdownFn = null;
+export function setGracefulShutdownFn(fn) {
+    gracefulShutdownFn = fn;
+}
+export const instanceRouter = Router();
+instanceRouter.get('/ping', validateToken, async (_req, res) => {
+    try {
+        const schedulerResponse = await axios.get(`${schedulerBaseUrl}/api/runtime/ping`, { headers: { 'X-Runtime-Token': runtimeToken } });
+        res.json({
+            ok: true,
+            runtimeBridge: 'healthy',
+            schedulerReachable: schedulerResponse.status >= 200 && schedulerResponse.status < 300,
+            schedulerBaseUrl,
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(502).json({
+            ok: false,
+            error: err?.message || 'scheduler ping failed',
+            schedulerBaseUrl,
+        });
+    }
+});
+instanceRouter.post('/init-instance', validateToken, async (req, res) => {
+    const { agentId, workspacePath, skillEnabled, mcpEnabled, ccSwitchEnabledTools, skillPackage, skillPackages, mcpServers, } = req.body || {};
+    if (!agentId || !workspacePath) {
+        res.status(400).json({ error: 'agentId and workspacePath are required' });
+        return;
+    }
+    try {
+        const result = await initInstance(agentId, workspacePath, {
+            skillEnabled,
+            mcpEnabled,
+            ccSwitchEnabledTools,
+            skillPackage,
+            skillPackages,
+            mcpServers,
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({
+            error: err?.message || 'initialize instance failed',
+        });
+    }
+});
+instanceRouter.post('/cc-switch/state', validateToken, async (req, res) => {
+    const { agentId } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const state = await loadInstanceState(agentId);
+        const toolStatus = await detectToolStatuses(state.enabledTools || []);
+        res.json({ ok: true, agentId: String(agentId), state: { ...state, toolStatus } });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'load state failed' });
+    }
+});
+instanceRouter.post('/cc-switch/install-tools', validateToken, async (req, res) => {
+    const { agentId, tools } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    const requestedTools = Array.isArray(tools)
+        ? tools.map((tool) => String(tool || '').trim().toLowerCase()).filter(Boolean)
+        : [];
+    const supportedInstallableTools = new Set(SUPPORTED_INSTALLABLE_TOOLS);
+    const installableTools = requestedTools.filter((tool) => supportedInstallableTools.has(tool));
+    if (installableTools.length === 0) {
+        res.status(400).json({ error: `tools must include ${SUPPORTED_INSTALLABLE_TOOLS.join(', ')}` });
+        return;
+    }
+    try {
+        const state = await loadInstanceState(agentId);
+        const enabledTools = Array.from(new Set([...(state.enabledTools || []), ...installableTools]));
+        const toolStatus = await ensureToolsInstalled(installableTools);
+        const refreshedToolStatus = await detectToolStatuses(enabledTools);
+        const nextToolStatus = {
+            ...refreshedToolStatus,
+            ...toolStatus,
+        };
+        const savedState = await saveInstanceState(agentId, {
+            ...state,
+            enabledTools,
+            toolStatus: nextToolStatus,
+        });
+        res.json({
+            ok: true,
+            agentId: String(agentId),
+            toolStatus: nextToolStatus,
+            state: savedState,
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'install tools failed' });
+    }
+});
+/**
+ * ★★★ 新增：aws-mcp-server 通知 bridge 准备重启
+ * POST /runtime/prepare-restart
+ *
+ * 当 aws-mcp-server 准备重启时，调用此接口通知 bridge：
+ * - bridge 保留所有会话状态（不清空持久化）
+ * - aws-mcp-server 重启后可以从 bridge 恢复 agent 状态
+ *
+ * 请求体：
+ * - preserveSessions: true = 保留会话（aws-mcp-server 重启）
+ *                     false = 清理会话（bridge 自己关闭）
+ */
+instanceRouter.post('/prepare-restart', validateToken, async (req, res) => {
+    const { preserveSessions = true } = req.body || {};
+    try {
+        log.info(`[prepare-restart] 收到准备重启通知，preserveSessions=${preserveSessions}`);
+        // 记录重启模式到文件，供下次启动时判断
+        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');
+        if (preserveSessions) {
+            // 创建标记文件，表示 aws-mcp-server 重启，需要保留会话
+            await fs.mkdir(path.dirname(restartFlagFile), { recursive: true });
+            await fs.writeFile(restartFlagFile, JSON.stringify({
+                preserveSessions: true,
+                timestamp: new Date().toISOString(),
+            }), 'utf-8');
+            log.info(`[prepare-restart] 已创建保留会话标记文件: ${restartFlagFile}`);
+        }
+        else {
+            // 删除标记文件，表示 bridge 自己关闭，需要清理会话
+            try {
+                await fs.unlink(restartFlagFile);
+                log.info(`[prepare-restart] 已删除保留会话标记文件`);
+            }
+            catch {
+                // 文件不存在，忽略
+            }
+        }
+        res.json({
+            ok: true,
+            preserveSessions,
+            message: preserveSessions
+                ? 'Bridge will preserve sessions for aws-mcp-server restart'
+                : 'Bridge will clean up sessions on shutdown',
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[prepare-restart] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});

package/dist/routes/instance.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Instance 路由单元测试
+ */
+export {};
+//# sourceMappingURL=instance.test.d.ts.map

package/dist/routes/instance.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.test.d.ts","sourceRoot":"","sources":["../../src/routes/instance.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/instance.test.js

@@ -0,0 +1,64 @@
+/**
+ * Instance 路由单元测试
+ */
+import { describe, it, expect } from 'vitest';
+describe('instance route validation', () => {
+    it('builds correct ping response when healthy', () => {
+        const buildPingResponse = (schedulerStatus, schedulerBaseUrl) => ({
+            ok: true,
+            runtimeBridge: 'healthy',
+            schedulerReachable: schedulerStatus >= 200 && schedulerStatus < 300,
+            schedulerBaseUrl,
+        });
+        const healthyResponse = buildPingResponse(200, 'http://localhost:8080');
+        expect(healthyResponse.ok).toBe(true);
+        expect(healthyResponse.schedulerReachable).toBe(true);
+        const unhealthyResponse = buildPingResponse(502, 'http://localhost:8080');
+        expect(unhealthyResponse.schedulerReachable).toBe(false);
+    });
+    it('requires agentId and workspacePath', () => {
+        const validateInitRequest = (body) => {
+            if (!body.agentId || !body.workspacePath)
+                return { valid: false, error: 'agentId and workspacePath are required' };
+            return { valid: true };
+        };
+        expect(validateInitRequest({}).valid).toBe(false);
+        expect(validateInitRequest({ agentId: 'agent-1', workspacePath: '/path' }).valid).toBe(true);
+    });
+    it('builds correct init options', () => {
+        const buildInitOptions = (body) => ({
+            skillEnabled: body.skillEnabled,
+            mcpEnabled: body.mcpEnabled,
+            ccSwitchEnabledTools: body.ccSwitchEnabledTools,
+        });
+        const options = buildInitOptions({
+            skillEnabled: true,
+            mcpEnabled: false,
+            ccSwitchEnabledTools: ['claude', 'opencode'],
+        });
+        expect(options.skillEnabled).toBe(true);
+        expect(options.mcpEnabled).toBe(false);
+        expect(options.ccSwitchEnabledTools).toEqual(['claude', 'opencode']);
+    });
+    it('requires agentId for state query', () => {
+        const validateStateRequest = (body) => {
+            if (!body.agentId)
+                return { valid: false, error: 'agentId is required' };
+            return { valid: true };
+        };
+        expect(validateStateRequest({}).valid).toBe(false);
+        expect(validateStateRequest({ agentId: 'agent-1' }).valid).toBe(true);
+    });
+    it('accepts codex for cc-switch tool installation validation', async () => {
+        const { SUPPORTED_INSTALLABLE_TOOLS } = await import('../services/tool-installer.js');
+        const normalizeInstallableTools = (tools) => {
+            const supported = new Set(SUPPORTED_INSTALLABLE_TOOLS);
+            const requestedTools = Array.isArray(tools)
+                ? tools.map((tool) => String(tool || '').trim().toLowerCase()).filter(Boolean)
+                : [];
+            return requestedTools.filter((tool) => supported.has(tool));
+        };
+        expect(normalizeInstallableTools(['Codex'])).toEqual(['codex']);
+        expect(SUPPORTED_INSTALLABLE_TOOLS).toContain('codex');
+    });
+});

package/dist/routes/mcp.d.ts

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

package/dist/routes/mcp.d.ts.map

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

package/dist/routes/mcp.js

@@ -0,0 +1,171 @@
+import { Router } from 'express';
+import { validateToken } from '../middleware/auth.js';
+import { loadCcSwitchSdk, runCcSwitchAdapter } from '../services/cc-switch-sdk.js';
+import { syncLegacyStateFromSdk } from '../services/instance-init-service.js';
+import { normalizeSdkAppFlags, normalizeSdkMcpServerSpec } from '../utils/mcp-utils.js';
+export const mcpRouter = Router();
+mcpRouter.post('/cc-switch/mcp/list', validateToken, async (req, res) => {
+    const { agentId } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const sdk = await loadCcSwitchSdk(agentId);
+        const mcpServers = sdk.getAllMcpServers();
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        res.json({ ok: true, agentId: String(agentId), mcpServers, state: synced.state, configPath: synced.configPath });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'list mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/mcp/get', validateToken, async (req, res) => {
+    const { agentId, mcpId } = req.body || {};
+    if (!agentId || !mcpId) {
+        res.status(400).json({ error: 'agentId and mcpId are required' });
+        return;
+    }
+    try {
+        const sdk = await loadCcSwitchSdk(agentId);
+        const mcp = sdk.getMcpServerById(String(mcpId));
+        if (!mcp) {
+            res.status(404).json({ error: 'mcp not found' });
+            return;
+        }
+        res.json({ ok: true, agentId: String(agentId), mcp });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'get mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/mcp/create', validateToken, async (req, res) => {
+    const { agentId, mcp } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const name = String(mcp?.name || '').trim();
+        if (!name) {
+            throw new Error('mcp.name is required');
+        }
+        const sdk = await loadCcSwitchSdk(agentId);
+        const input = {
+            name,
+            server: normalizeSdkMcpServerSpec(mcp),
+            description: mcp?.description == null ? undefined : String(mcp.description),
+            apps: normalizeSdkAppFlags(mcp?.apps),
+        };
+        const created = await sdk.createMcpServer(input);
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        const adapterResult = await runCcSwitchAdapter('create-mcp', agentId, created);
+        res.json({ ok: true, agentId: String(agentId), mcp: created, state: synced.state, configPath: synced.configPath, adapterResult });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'create mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/mcp/update', validateToken, async (req, res) => {
+    const { agentId, mcpId, mcp } = req.body || {};
+    if (!agentId || !mcpId) {
+        res.status(400).json({ error: 'agentId and mcpId are required' });
+        return;
+    }
+    try {
+        const sdk = await loadCcSwitchSdk(agentId);
+        const input = {
+            name: mcp?.name == null ? undefined : String(mcp.name).trim(),
+            server: mcp?.server || mcp?.transport || mcp?.command || mcp?.url || mcp?.args || mcp?.env || mcp?.headers
+                ? normalizeSdkMcpServerSpec(mcp)
+                : undefined,
+            description: mcp?.description == null ? undefined : String(mcp.description),
+            apps: normalizeSdkAppFlags(mcp?.apps),
+        };
+        const updated = await sdk.updateMcpServer(String(mcpId), input);
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        const adapterResult = await runCcSwitchAdapter('update-mcp', agentId, updated);
+        res.json({ ok: true, agentId: String(agentId), mcp: updated, state: synced.state, configPath: synced.configPath, adapterResult });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'update mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/mcp/delete', validateToken, async (req, res) => {
+    const { agentId, mcpId } = req.body || {};
+    if (!agentId || !mcpId) {
+        res.status(400).json({ error: 'agentId and mcpId are required' });
+        return;
+    }
+    try {
+        const sdk = await loadCcSwitchSdk(agentId);
+        const existing = sdk.getMcpServerById(String(mcpId));
+        if (!existing) {
+            res.status(404).json({ error: 'mcp not found' });
+            return;
+        }
+        await sdk.deleteMcpServer(String(mcpId));
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        const adapterResult = await runCcSwitchAdapter('delete-mcp', agentId, existing);
+        res.json({ ok: true, agentId: String(agentId), removedMcp: existing, state: synced.state, configPath: synced.configPath, adapterResult });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'delete mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/add-mcp', validateToken, async (req, res) => {
+    const { agentId, mcp } = req.body || {};
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const name = String(mcp?.name || '').trim();
+        if (!name) {
+            throw new Error('mcp.name is required');
+        }
+        const sdk = await loadCcSwitchSdk(agentId);
+        const input = {
+            name,
+            server: normalizeSdkMcpServerSpec(mcp),
+            description: mcp?.description == null ? undefined : String(mcp.description),
+            apps: normalizeSdkAppFlags(mcp?.apps),
+        };
+        const created = await sdk.createMcpServer(input);
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        const adapterResult = await runCcSwitchAdapter('create-mcp', agentId, created);
+        res.json({ ok: true, agentId: String(agentId), mcp: created, state: synced.state, configPath: synced.configPath, adapterResult });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'add mcp failed' });
+    }
+});
+mcpRouter.post('/cc-switch/remove-mcp', validateToken, async (req, res) => {
+    const { agentId, mcpId } = req.body || {};
+    if (!agentId || !mcpId) {
+        res.status(400).json({ error: 'agentId and mcpId are required' });
+        return;
+    }
+    try {
+        const sdk = await loadCcSwitchSdk(agentId);
+        const existing = sdk.getMcpServerById(String(mcpId));
+        if (!existing) {
+            res.status(404).json({ error: 'mcp not found' });
+            return;
+        }
+        await sdk.deleteMcpServer(String(mcpId));
+        const synced = await syncLegacyStateFromSdk(agentId, sdk);
+        const adapterResult = await runCcSwitchAdapter('delete-mcp', agentId, existing);
+        res.json({ ok: true, agentId: String(agentId), removedMcp: existing, state: synced.state, configPath: synced.configPath, adapterResult });
+    }
+    catch (error) {
+        const err = error;
+        res.status(400).json({ error: err?.message || 'remove mcp failed' });
+    }
+});

package/dist/routes/mcp.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MCP 路由单元测试
+ */
+export {};
+//# sourceMappingURL=mcp.test.d.ts.map

package/dist/routes/mcp.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.test.d.ts","sourceRoot":"","sources":["../../src/routes/mcp.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/mcp.test.js

@@ -0,0 +1,84 @@
+/**
+ * MCP 路由单元测试
+ */
+import { describe, it, expect } from 'vitest';
+describe('mcp route validation', () => {
+    it('requires agentId for list operation', () => {
+        const validateListRequest = (body) => {
+            if (!body.agentId)
+                return { valid: false, error: 'agentId is required' };
+            return { valid: true };
+        };
+        expect(validateListRequest({}).valid).toBe(false);
+        expect(validateListRequest({ agentId: 'agent-123' }).valid).toBe(true);
+    });
+    it('requires agentId and mcpId for get operation', () => {
+        const validateGetRequest = (body) => {
+            if (!body.agentId || !body.mcpId)
+                return { valid: false, error: 'agentId and mcpId are required' };
+            return { valid: true };
+        };
+        expect(validateGetRequest({}).valid).toBe(false);
+        expect(validateGetRequest({ agentId: 'agent-1' }).valid).toBe(false);
+        expect(validateGetRequest({ agentId: 'agent-1', mcpId: 'mcp-1' }).valid).toBe(true);
+    });
+    it('requires mcp.name for create', () => {
+        const validateCreateMcp = (mcp) => {
+            const name = String(mcp?.name || '').trim();
+            if (!name)
+                return { valid: false, error: 'mcp.name is required' };
+            return { valid: true, name };
+        };
+        expect(validateCreateMcp(undefined).valid).toBe(false);
+        expect(validateCreateMcp({ name: 'filesystem' }).valid).toBe(true);
+    });
+});
+describe('mcp server spec normalization', () => {
+    it('normalizes stdio transport', () => {
+        const normalizeMcpSpec = (mcp) => {
+            if (mcp.command) {
+                return {
+                    type: 'stdio',
+                    command: String(mcp.command),
+                    args: Array.isArray(mcp.args) ? mcp.args : [],
+                };
+            }
+            return null;
+        };
+        const result = normalizeMcpSpec({
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-filesystem'],
+        });
+        expect(result).toEqual({
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-filesystem'],
+        });
+    });
+    it('normalizes sse transport', () => {
+        const normalizeMcpSpec = (mcp) => {
+            if (mcp.url && !mcp.command) {
+                return { type: 'sse', url: String(mcp.url) };
+            }
+            return null;
+        };
+        const result = normalizeMcpSpec({ url: 'http://localhost:3000/sse' });
+        expect(result).toEqual({ type: 'sse', url: 'http://localhost:3000/sse' });
+    });
+});
+describe('app flags normalization', () => {
+    it('normalizes app flags from various formats', () => {
+        const normalizeAppFlags = (apps) => {
+            if (!apps)
+                return [];
+            if (typeof apps === 'string')
+                return apps.split(',').map(s => s.trim()).filter(Boolean);
+            if (Array.isArray(apps))
+                return apps.filter(s => typeof s === 'string').map(s => String(s).trim()).filter(Boolean);
+            return [];
+        };
+        expect(normalizeAppFlags('claude,opencode')).toEqual(['claude', 'opencode']);
+        expect(normalizeAppFlags(['claude', 'opencode'])).toEqual(['claude', 'opencode']);
+        expect(normalizeAppFlags(null)).toEqual([]);
+    });
+});

package/dist/routes/memory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 记忆 API 路由
+ *
+ * 提供记忆的 CRUD 操作 REST API
+ * 记忆存储在项目根目录下的 vibe-coding/memory/ 目录
+ *
+ * 权限控制：
+ * - 创建时需提供 creatorId, creatorName，可选 isPublic（默认私有）
+ * - 读取/搜索/列出时需提供 requestorId，只返回自己的记忆 + 公开的记忆
+ * - 更新/删除时需提供操作者 ID，只有创建者可操作自己的记忆
+ */
+export declare const memoryRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=memory.d.ts.map

package/dist/routes/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/routes/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAoBH,eAAO,MAAM,YAAY,4CAAW,CAAC"}