aws-runtime-bridge 1.0.0

package/dist/routes/memory.js

@@ -0,0 +1,429 @@
+/**
+ * 记忆 API 路由
+ *
+ * 提供记忆的 CRUD 操作 REST API
+ * 记忆存储在项目根目录下的 vibe-coding/memory/ 目录
+ *
+ * 权限控制：
+ * - 创建时需提供 creatorId, creatorName，可选 isPublic（默认私有）
+ * - 读取/搜索/列出时需提供 requestorId，只返回自己的记忆 + 公开的记忆
+ * - 更新/删除时需提供操作者 ID，只有创建者可操作自己的记忆
+ */
+import { Router } from "express";
+import { validateInternalApiKey } from "../middleware/auth.js";
+import { createLogger } from "../utils/logger.js";
+import { getMemoryDirPath, memoryService, } from "../services/memory-service.js";
+const log = createLogger("memory-routes");
+export const memoryRouter = Router();
+/**
+ * 创建记忆
+ * POST /runtime/memory/create
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - memory_type: 记忆类型（必需）
+ * - uri: 记忆 URI（必需）
+ * - content: 记忆内容（必需）
+ * - creatorId: 创建者 Agent ID（必需）
+ * - creatorName: 创建者显示名（必需）
+ * - isPublic: 是否公开（可选，默认 false）
+ */
+memoryRouter.post("/memory/create", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, memory_type, uri, content, creatorId, creatorName, isPublic, } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!memory_type || !uri || !content) {
+            res
+                .status(400)
+                .json({ error: "memory_type, uri, content are required" });
+            return;
+        }
+        if (!creatorId || !creatorName) {
+            res.status(400).json({ error: "creatorId, creatorName are required" });
+            return;
+        }
+        const input = {
+            memory_type: memory_type,
+            uri: String(uri),
+            content: String(content),
+            creatorId: String(creatorId),
+            creatorName: String(creatorName),
+            isPublic: isPublic === true, // 默认 false，只有显式传 true 才为公开
+        };
+        const record = await memoryService.createMemory(normalizedWorkspace, input);
+        const memoryDir = await getMemoryDirPath(normalizedWorkspace);
+        res.json({
+            ok: true,
+            record,
+            memoryDir,
+            visibility: record.isPublic ? "公开（小组内可读取）" : "私有",
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/create] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 读取记忆
+ * POST /runtime/memory/read
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - uri: 记忆 URI（必需）
+ * - memory_type: 记忆类型（可选）
+ * - requestorId: 请求者 Agent ID（必需，用于权限判断）
+ */
+memoryRouter.post("/memory/read", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, uri, memory_type, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!uri) {
+            res.status(400).json({ error: "uri is required" });
+            return;
+        }
+        if (!requestorId) {
+            res.status(400).json({ error: "requestorId is required" });
+            return;
+        }
+        const input = {
+            uri: String(uri),
+            memory_type: memory_type,
+            requestorId: String(requestorId),
+        };
+        const record = await memoryService.readMemory(normalizedWorkspace, input);
+        if (!record) {
+            res.json({
+                ok: true,
+                found: false,
+                message: `Memory not found or no access: ${uri}`,
+            });
+            return;
+        }
+        res.json({
+            ok: true,
+            found: true,
+            record,
+            // 标注来源信息（如果是他人公开的记忆）
+            isOwn: record.isOwn,
+            source: record.source,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/read] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 更新记忆
+ * POST /runtime/memory/update
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - uri: 记忆 URI（必需）
+ * - memory_type: 记忆类型（可选）
+ * - old_string + new_string: 精确替换
+ * - append: 追加内容
+ * - editorId: 编辑者 Agent ID（必需，用于权限校验和记录）
+ * - editorName: 编辑者显示名（必需）
+ */
+memoryRouter.post("/memory/update", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, uri, memory_type, old_string, new_string, append, editorId, editorName, } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!uri) {
+            res.status(400).json({ error: "uri is required" });
+            return;
+        }
+        if (!editorId || !editorName) {
+            res.status(400).json({ error: "editorId, editorName are required" });
+            return;
+        }
+        if (!old_string && !new_string && !append) {
+            res
+                .status(400)
+                .json({ error: "need old_string+new_string or append parameter" });
+            return;
+        }
+        const input = {
+            uri: String(uri),
+            memory_type: memory_type,
+            old_string: old_string ? String(old_string) : undefined,
+            new_string: new_string ? String(new_string) : undefined,
+            append: append ? String(append) : undefined,
+            editorId: String(editorId),
+            editorName: String(editorName),
+        };
+        const record = await memoryService.updateMemory(normalizedWorkspace, input);
+        res.json({
+            ok: true,
+            record,
+            lastEditor: record.lastEditorName
+                ? `${record.lastEditorName} (${record.lastEditorId})`
+                : undefined,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/update] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 删除记忆
+ * POST /runtime/memory/delete
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - uri: 记忆 URI（必需）
+ * - memory_type: 记忆类型（可选）
+ * - requestorId: 请求者 Agent ID（必需，只有创建者可删除）
+ */
+memoryRouter.post("/memory/delete", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, uri, memory_type, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!uri) {
+            res.status(400).json({ error: "uri is required" });
+            return;
+        }
+        if (!requestorId) {
+            res.status(400).json({ error: "requestorId is required" });
+            return;
+        }
+        const input = {
+            uri: String(uri),
+            memory_type: memory_type,
+            requestorId: String(requestorId),
+        };
+        const result = await memoryService.deleteMemory(normalizedWorkspace, input);
+        res.json({
+            ok: true,
+            deleted: result.deleted,
+            uri,
+            reason: result.deleted ? undefined : result.reason,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/delete] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 搜索记忆
+ * POST /runtime/memory/search
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - query: 搜索关键词（必需）
+ * - memory_type: 记忆类型过滤（可选）
+ * - limit: 结果数量限制（可选，默认 10）
+ * - requestorId: 请求者 Agent ID（必需，只返回自己的 + 公开的）
+ */
+memoryRouter.post("/memory/search", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, query, memory_type, limit, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!query) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        if (!requestorId) {
+            res.status(400).json({ error: "requestorId is required" });
+            return;
+        }
+        const input = {
+            query: String(query),
+            memory_type: memory_type,
+            limit: typeof limit === "number" ? limit : 10,
+            requestorId: String(requestorId),
+        };
+        const result = await memoryService.searchMemory(normalizedWorkspace, input);
+        // 为结果添加来源标注
+        const annotatedResults = result.results.map((r) => ({
+            ...r,
+            isOwn: r.isOwn,
+            source: r.source,
+        }));
+        res.json({
+            ok: true,
+            query: result.query,
+            results: annotatedResults,
+            count: annotatedResults.length,
+            totalFound: result.totalFound,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/search] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 按类型列出记忆
+ * POST /runtime/memory/list
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - memory_type: 记忆类型（必需，task_list 或 recently_memory）
+ * - requestorId: 请求者 Agent ID（必需，只返回自己的 + 公开的）
+ */
+memoryRouter.post("/memory/list", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, memory_type, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!memory_type) {
+            res.status(400).json({
+                error: "memory_type is required (task_list or recently_memory)",
+            });
+            return;
+        }
+        const type = memory_type;
+        if (type !== "task_list" && type !== "recently_memory") {
+            res
+                .status(400)
+                .json({ error: "memory_type must be task_list or recently_memory" });
+            return;
+        }
+        if (!requestorId) {
+            res.status(400).json({ error: "requestorId is required" });
+            return;
+        }
+        const input = {
+            memory_type: type,
+            requestorId: String(requestorId),
+        };
+        const records = await memoryService.listByType(normalizedWorkspace, input);
+        // 为结果添加来源标注
+        const annotatedRecords = records.map((r) => ({
+            ...r,
+            isOwn: r.isOwn,
+            source: r.source,
+        }));
+        res.json({
+            ok: true,
+            memory_type: type,
+            count: annotatedRecords.length,
+            records: annotatedRecords,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/list] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 归档短期记忆
+ * POST /runtime/memory/archive
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - uri: 记忆 URI（必需）
+ * - requestorId: 请求者 Agent ID（必需，只有创建者可归档）
+ */
+memoryRouter.post("/memory/archive", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, uri, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        if (!uri) {
+            res.status(400).json({ error: "uri is required" });
+            return;
+        }
+        if (!requestorId) {
+            res.status(400).json({ error: "requestorId is required" });
+            return;
+        }
+        const record = await memoryService.archiveRecentlyMemory(normalizedWorkspace, String(uri), String(requestorId));
+        res.json({
+            ok: true,
+            archived: true,
+            record,
+            message: `已归档到长期记忆（cold-memory.json）`,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/archive] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 获取记忆统计信息
+ * POST /runtime/memory/stats
+ *
+ * 请求体参数：
+ * - workspacePath: 工作目录（必需）
+ * - requestorId: 请求者 Agent ID（可选，用于计算可访问数量）
+ */
+memoryRouter.post("/memory/stats", validateInternalApiKey, async (req, res) => {
+    const { workspacePath, requestorId } = req.body || {};
+    try {
+        const normalizedWorkspace = workspacePath
+            ? String(workspacePath).trim()
+            : "";
+        if (!normalizedWorkspace) {
+            res.status(400).json({ error: "workspacePath is required" });
+            return;
+        }
+        const stats = await memoryService.getStats(normalizedWorkspace, requestorId ? String(requestorId) : undefined);
+        res.json({
+            ok: true,
+            stats,
+            memoryDir: stats.memoryDir,
+            summary: requestorId
+                ? `总计 ${stats.total} 条记忆，其中 ${stats.own} 条属于你，${stats.public} 条公开，${stats.accessible} 条可访问`
+                : `总计 ${stats.total} 条记忆`,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error(`[memory/stats] ${err.message}`);
+        res.status(400).json({ error: err.message });
+    }
+});

package/dist/routes/processes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 进程管理 API 路由
+ *
+ * 提供 Agent 进程的全局发现、生命周期管理、健康检查和孤儿回收功能
+ */
+export declare const processesRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=processes.d.ts.map

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

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

package/dist/routes/processes.js

@@ -0,0 +1,245 @@
+/**
+ * 进程管理 API 路由
+ *
+ * 提供 Agent 进程的全局发现、生命周期管理、健康检查和孤儿回收功能
+ */
+import { Router } from 'express';
+import { validateToken } from '../middleware/auth.js';
+import { getAgentProcessManager } from '../services/agent-process-manager.js';
+import { discoverAllProcessesFull } from '../services/process-detector.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('processes');
+export const processesRouter = Router();
+/**
+ * 列出机器上所有 Agent 进程（含管理状态）
+ * GET /runtime/processes
+ *
+ * 返回：
+ * - managed: 被 bridge 管理的进程
+ * - orphan: 在运行但脱离 bridge 控制的进程
+ * - unknown: 注册表中记录但进程已退出
+ */
+processesRouter.get('/processes', validateToken, async (_req, res) => {
+    try {
+        const manager = getAgentProcessManager();
+        const registryRecords = manager.getAllManagedProcesses();
+        // 构建 registry 导出供发现使用
+        const registryExport = registryRecords
+            .filter(r => r.pid > 0)
+            .map(r => ({ agentId: r.agentId, pid: r.pid }));
+        // 全局发现：扫描全机进程 + 对比注册表
+        const discovered = discoverAllProcessesFull(registryExport);
+        // 补充 sessionId 信息
+        const enriched = discovered.map(d => {
+            const record = registryRecords.find(r => r.pid === d.pid || r.agentId === d.agentId);
+            return {
+                ...d,
+                sessionId: record?.sessionId,
+                state: record?.state,
+            };
+        });
+        res.json({
+            ok: true,
+            processes: enriched,
+            stats: manager.getStats(),
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/list] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 触发全机进程发现扫描
+ * POST /runtime/processes/discover
+ *
+ * 主动扫描机器上所有 Agent 进程，对比注册表，
+ * 标记 orphan/unknown 状态
+ */
+processesRouter.post('/processes/discover', validateToken, async (_req, res) => {
+    try {
+        const manager = getAgentProcessManager();
+        const discovered = await manager.discoverAllProcesses();
+        res.json({
+            ok: true,
+            discovered,
+            managedCount: discovered.filter(d => d.managementStatus === 'managed').length,
+            orphanCount: discovered.filter(d => d.managementStatus === 'orphan').length,
+            unknownCount: discovered.filter(d => d.managementStatus === 'unknown').length,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/discover] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 获取单个进程详情
+ * GET /runtime/processes/:agentId
+ */
+processesRouter.get('/processes/:agentId', validateToken, async (req, res) => {
+    const agentIdParam = req.params.agentId;
+    const agentId = Array.isArray(agentIdParam) ? agentIdParam[0] : agentIdParam;
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const manager = getAgentProcessManager();
+        const process = manager.getProcess(agentId);
+        if (!process) {
+            res.status(404).json({ error: 'Process not found', agentId });
+            return;
+        }
+        res.json({
+            ok: true,
+            process,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/get] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 回收脱离控制的进程
+ * POST /runtime/processes/:agentId/reclaim
+ *
+ * 尝试将脱离 bridge 管理的进程重新纳入控制
+ */
+processesRouter.post('/processes/:agentId/reclaim', validateToken, async (req, res) => {
+    const agentIdParam = req.params.agentId;
+    const agentId = Array.isArray(agentIdParam) ? agentIdParam[0] : agentIdParam;
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const manager = getAgentProcessManager();
+        const result = await manager.reclaimOrphan(agentId);
+        res.json({
+            ok: result.success,
+            agentId,
+            pid: result.pid,
+            action: result.action,
+            message: result.action === 'adopted'
+                ? '进程已重新纳入管理'
+                : result.action === 'terminated'
+                    ? '进程已被终止'
+                    : '回收失败',
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/reclaim] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 强制终止进程（升级策略）
+ * POST /runtime/processes/:agentId/force-kill
+ *
+ * 使用 4 级升级策略强制终止进程：
+ * Level 1: SIGTERM → 等待 3s
+ * Level 2: taskkill /F (Win) 或 kill -9 (Unix) → 等待 3s
+ * Level 3: terminateProcessTree → 等待 5s
+ * Level 4: 标记为 unstoppable
+ */
+processesRouter.post('/processes/:agentId/force-kill', validateToken, async (req, res) => {
+    const agentIdParam = req.params.agentId;
+    const agentId = Array.isArray(agentIdParam) ? agentIdParam[0] : agentIdParam;
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const manager = getAgentProcessManager();
+        const result = await manager.forceKill(agentId);
+        res.json({
+            ok: result.success,
+            agentId,
+            pid: result.pid,
+            level: result.level,
+            terminated: result.terminated,
+            failed: result.failed,
+            message: result.message,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/force-kill] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 批量扫描并回收所有孤儿进程
+ * POST /runtime/processes/scan-reclaim-all
+ */
+processesRouter.post('/processes/scan-reclaim-all', validateToken, async (_req, res) => {
+    try {
+        const manager = getAgentProcessManager();
+        const results = await manager.scanAndReclaimAll();
+        res.json({
+            ok: true,
+            scanned: results.length,
+            results,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/scan-reclaim-all] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 获取进程健康状态
+ * GET /runtime/processes/:agentId/health
+ */
+processesRouter.get('/processes/:agentId/health', validateToken, async (req, res) => {
+    const agentIdParam = req.params.agentId;
+    const agentId = Array.isArray(agentIdParam) ? agentIdParam[0] : agentIdParam;
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    try {
+        const manager = getAgentProcessManager();
+        const health = await manager.healthCheck(agentId);
+        res.json({
+            ok: true,
+            agentId,
+            health,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/health] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 批量健康检查
+ * POST /runtime/processes/health-check-all
+ */
+processesRouter.post('/processes/health-check-all', validateToken, async (_req, res) => {
+    try {
+        const manager = getAgentProcessManager();
+        const results = await manager.healthCheckAll();
+        const healthArray = Array.from(results.entries()).map(([_agentId, health]) => ({
+            ...health,
+        }));
+        res.json({
+            ok: true,
+            checked: healthArray.length,
+            health: healthArray,
+        });
+    }
+    catch (error) {
+        const err = error;
+        log.error('[processes/health-check-all] Error:', err);
+        res.status(500).json({ error: err.message });
+    }
+});

package/dist/routes/properties.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 属性文件 API 路由
+ *
+ * 提供属性文件的读取和写入功能
+ */
+export declare const propertiesRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=properties.d.ts.map

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

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