aws-runtime-bridge 1.0.2 → 1.1.0

package/dist/routes/memory.js

@@ -1,429 +0,0 @@
-/**
- * 记忆 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/services/aws-mcp-http.d.ts

@@ -1,11 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export interface AwsMcpContext {
-    agentId: string;
-    workspacePath?: string;
-}
-export declare const AWS_MCP_TOOLS: Tool[];
-export declare function normalizeAwsMcpArgs(args: unknown): Record<string, unknown>;
-export declare function mapAwsMcpToolName(toolName: string): string;
-export declare function injectAwsMcpContext(toolName: string, args: Record<string, unknown>, context: AwsMcpContext): Record<string, unknown>;
-export declare function callAwsMcpTool(toolName: string, args: unknown, context: AwsMcpContext): Promise<unknown>;
-//# sourceMappingURL=aws-mcp-http.d.ts.map

package/dist/services/aws-mcp-http.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aws-mcp-http.d.ts","sourceRoot":"","sources":["../../src/services/aws-mcp-http.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAW/D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AA0BD,eAAO,MAAM,aAAa,EAAE,IAAI,EAwH/B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE1E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUpI;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAa9G"}

package/dist/services/aws-mcp-http.js

@@ -1,225 +0,0 @@
-import axios from 'axios';
-import { schedulerBaseUrl } from '../config.js';
-import { createLogger } from '../utils/logger.js';
-const log = createLogger('aws-mcp-http');
-const DEFAULT_INTERNAL_API_KEY = 'agentswork-internal-dev-key';
-const DEFAULT_TOOL_TIMEOUT_MS = 30000;
-const POLL_MESSAGE_TIMEOUT_MS = 65000;
-export const AWS_MCP_TOOLS = [
-    {
-        name: 'get_colleague',
-        description: '获取当前 Agent 可见的同事 Agent 列表，包含在线和离线状态。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'get_group_rooms',
-        description: '获取当前 Agent 在关系图中可发现的群组列表，包括项目公共群聊以及自己所在的小组群。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'get_profile',
-        description: '获取当前 Agent 的个人信息，包括 ID、显示名称、角色名称、Prompt、在线状态等。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'get_status',
-        description: '获取当前 Agent 的运行状态（连接状态、消息循环状态等）。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'send_group',
-        description: '向公共群聊发送消息，所有在线参与者都能收到。回复群消息时建议传入消息中的 projectName，确保回复到正确的项目群聊。',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                content: { type: 'string', description: '消息内容' },
-                projectName: { type: 'string', description: '目标项目名（可选）。不传则使用 Agent 所属项目（由服务端决定）。' },
-                roomId: { type: 'string', description: '目标群聊房间 ID（可选）。' },
-            },
-            required: ['content'],
-        },
-    },
-    {
-        name: 'send_private',
-        description: '发送私信给指定用户。支持两种模式：通知式（waitReply=false）和调用式（waitReply=true，阻塞等待回复）。',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetId: { type: 'string', description: '目标用户ID' },
-                content: { type: 'string', description: '消息内容' },
-                waitReply: { type: 'boolean', description: '是否等待对方回复（调用式）。' },
-                replyToCallId: { type: 'string', description: '回复的调用ID（用于回复调用式消息）' },
-                timeoutMs: { type: 'number', description: '等待回复的超时时间（毫秒，可选）。' },
-            },
-            required: ['targetId', 'content'],
-        },
-    },
-    {
-        name: 'poll_message',
-        description: '获取未读消息（包括群消息和私信），持续阻塞等待直到有新消息，这是获取消息的主要接口。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'get_message',
-        description: '获取未读消息（非阻塞），从消息缓冲区获取消息，立即返回，若当前没有任务应使用 poll_message。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'get_dm_history',
-        description: '获取私信历史消息。可以获取与特定用户的对话历史，或获取所有私信历史。',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                targetUserId: { type: 'string', description: '目标用户ID（可选）。' },
-                limit: { type: 'number', description: '获取最近历史消息的数量（默认50）' },
-                since: { type: 'string', description: '起始时间（ISO 8601 格式，可选）。' },
-            },
-            required: [],
-        },
-    },
-    {
-        name: 'get_group_history',
-        description: '获取公共群聊的历史消息。',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: '获取最近历史消息的数量（默认50）' },
-                roomId: { type: 'string', description: '目标群聊房间 ID（可选）。' },
-                since: { type: 'string', description: '起始时间（ISO 8601 格式，可选）。' },
-            },
-            required: [],
-        },
-    },
-    {
-        name: 'hire_colleague',
-        description: '向人事部发起招聘同事请求，直接按创建角色实例所需参数创建一个新的 Agent 同事。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'hire_colleagues_batch',
-        description: '向人事部发起批量招聘同事请求，一次提交多个待审批招聘项。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'my_task',
-        description: '获取当前 Agent 被分配的流程线任务列表。',
-        inputSchema: { type: 'object', properties: {}, required: [] },
-    },
-    {
-        name: 'start_task',
-        description: '将流程线任务节点标记为处理中。',
-        inputSchema: { type: 'object', properties: { nodeId: { type: 'string' } }, required: ['nodeId'] },
-    },
-    {
-        name: 'submit_task_result',
-        description: '提交流程线任务的执行结果。',
-        inputSchema: { type: 'object', properties: { nodeId: { type: 'string' }, outputPayload: { type: 'string' } }, required: ['nodeId', 'outputPayload'] },
-    },
-    {
-        name: 'reject_task',
-        description: '拒绝对前序节点输出的任务，任务将回退到前一个节点重新执行。',
-        inputSchema: { type: 'object', properties: { nodeId: { type: 'string' }, reason: { type: 'string' } }, required: ['nodeId', 'reason'] },
-    },
-    {
-        name: 'terminate_task',
-        description: '终止整个流程线任务。',
-        inputSchema: { type: 'object', properties: { taskInstanceId: { type: 'string' }, reason: { type: 'string' } }, required: ['taskInstanceId', 'reason'] },
-    },
-];
-export function normalizeAwsMcpArgs(args) {
-    return args && typeof args === 'object' && !Array.isArray(args) ? { ...args } : {};
-}
-export function mapAwsMcpToolName(toolName) {
-    const mapping = {
-        get_colleague: 'discover_colleague',
-        get_group_rooms: 'discover_group_rooms',
-        send_group: 'send_group_message',
-        send_private: 'send_dm',
-    };
-    return mapping[toolName] || toolName;
-}
-export function injectAwsMcpContext(toolName, args, context) {
-    const nextArgs = { ...args, agentId: context.agentId };
-    if (context.workspacePath && nextArgs.workspacePath == null) {
-        nextArgs.workspacePath = context.workspacePath;
-    }
-    if (toolName === 'send_private') {
-        nextArgs.requireReply = Boolean(nextArgs.waitReply);
-        delete nextArgs.waitReply;
-    }
-    return nextArgs;
-}
-export async function callAwsMcpTool(toolName, args, context) {
-    const normalizedArgs = normalizeAwsMcpArgs(args);
-    if (toolName === 'get_status') {
-        return { agentId: context.agentId, isConnected: true, transport: 'http', bridge: 'aws-runtime-bridge' };
-    }
-    if (toolName === 'poll_message') {
-        return pollMessages(context, true);
-    }
-    if (toolName === 'get_message') {
-        return pollMessages(context, false);
-    }
-    return callSchedulerMcpTool(mapAwsMcpToolName(toolName), injectAwsMcpContext(toolName, normalizedArgs, context));
-}
-async function pollMessages(context, blockIfEmpty) {
-    const direct = await callSchedulerMcpTool('get_dm_messages', {
-        agentId: context.agentId,
-        blockIfEmpty,
-    });
-    const directMessages = Array.isArray(direct.messages) ? direct.messages : [];
-    const groupResult = await fetchAllUnreadGroupMessages(context);
-    return {
-        directMessages,
-        groupMessages: groupResult.messages,
-        ...(groupResult.errors.length > 0 ? { groupErrors: groupResult.errors } : {}),
-        fromBuffer: false,
-    };
-}
-async function fetchAllUnreadGroupMessages(context) {
-    const messages = [];
-    const errors = [];
-    try {
-        const rooms = await callSchedulerMcpTool('discover_group_rooms', { agentId: context.agentId });
-        const groups = Array.isArray(rooms.groups) ? rooms.groups : [];
-        if (groups.length === 0) {
-            const result = await callSchedulerMcpTool('get_group_messages', { agentId: context.agentId });
-            return { messages: Array.isArray(result.messages) ? result.messages : [], errors };
-        }
-        for (const group of groups) {
-            try {
-                const result = await callSchedulerMcpTool('get_group_messages', {
-                    agentId: context.agentId,
-                    projectName: group.projectName,
-                    roomId: group.id,
-                });
-                if (Array.isArray(result.messages)) {
-                    messages.push(...result.messages);
-                }
-            }
-            catch (error) {
-                errors.push(`group ${group.id || 'unknown'}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    catch (error) {
-        const message = `discover groups failed: ${error instanceof Error ? error.message : String(error)}`;
-        log.warn(message);
-        errors.push(message);
-    }
-    return { messages, errors };
-}
-async function callSchedulerMcpTool(tool, args) {
-    const response = await axios.post(new URL('/mcp/call', schedulerBaseUrl).toString(), { tool, arguments: args }, {
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Internal-API-Key': process.env.AWS_INTERNAL_API_KEY || DEFAULT_INTERNAL_API_KEY,
-        },
-        timeout: tool === 'get_dm_messages' && args.blockIfEmpty === true ? POLL_MESSAGE_TIMEOUT_MS : DEFAULT_TOOL_TIMEOUT_MS,
-    });
-    const data = typeof response.data === 'string' ? JSON.parse(response.data) : response.data;
-    if (data?.error) {
-        throw new Error(String(data.error));
-    }
-    return data;
-}

package/dist/services/aws-mcp-http.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=aws-mcp-http.test.d.ts.map

package/dist/services/aws-mcp-http.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aws-mcp-http.test.d.ts","sourceRoot":"","sources":["../../src/services/aws-mcp-http.test.ts"],"names":[],"mappings":""}