aws-runtime-bridge 1.0.0

package/dist/services/aws-client-agent-mcp.js

@@ -0,0 +1,142 @@
+import { cpSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getRuntimeHomeDir, schedulerBaseUrl } from '../config.js';
+import { logger } from '../utils/logger.js';
+export const AWS_MCP_SERVER_NAME = 'aws-mcp';
+const AWS_MCP_ALLOWED_ENV_KEYS = [
+    'AWS_INTERNAL_API_KEY',
+    'AWS_PROJECT_NAME',
+    'AWS_PROMPT',
+    'AWS_ROLE_NAME',
+    'AWS_SERVER_URL',
+    'AWS_MCP_HTTP_URL',
+    'AWS_HEARTBEAT_INTERVAL',
+    'AWS_HEARTBEAT_TIMEOUT',
+    'PATH',
+    'HOME',
+    'USERPROFILE',
+    'TMP',
+    'TEMP',
+    'SystemRoot',
+    'COMSPEC',
+    'PATHEXT',
+    'WINDIR',
+];
+function getPackageRoot() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), '..', '..');
+}
+function getBundledEntryPath() {
+    return path.join(getPackageRoot(), 'package', 'aws-client-agent-mcp', 'dist', 'index.js');
+}
+function getReleasedMcpRoot() {
+    return path.join(getRuntimeHomeDir(), '.aws-bridge', 'mcp');
+}
+export function getReleasedMcpDistPath() {
+    return path.join(getReleasedMcpRoot(), 'dist');
+}
+function getReleasedEntryPath() {
+    return path.join(getReleasedMcpDistPath(), 'index.js');
+}
+export function releaseBundledAwsClientAgentMcp() {
+    const bundledDist = path.dirname(getBundledEntryPath());
+    const releasedDist = getReleasedMcpDistPath();
+    const releasedEntry = path.join(releasedDist, 'index.js');
+    if (!existsSync(path.join(bundledDist, 'index.js'))) {
+        return null;
+    }
+    if (!existsSync(releasedEntry)) {
+        mkdirSync(releasedDist, { recursive: true });
+        cpSync(bundledDist, releasedDist, {
+            errorOnExist: false,
+            force: true,
+            recursive: true,
+        });
+        logger.info(`[runtime-bridge] ${AWS_MCP_SERVER_NAME} MCP 已释放到: ${releasedDist}`);
+    }
+    return releasedEntry;
+}
+function getStringEnv() {
+    return Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === 'string'));
+}
+function getAllowedAwsMcpEnv(baseEnv) {
+    return Object.fromEntries(AWS_MCP_ALLOWED_ENV_KEYS.flatMap((key) => {
+        const value = baseEnv[key];
+        return typeof value === 'string' && value.length > 0 ? [[key, value]] : [];
+    }));
+}
+function parseAwsClientAgentMcpArgs(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed) && parsed.every((value) => typeof value === 'string')) {
+            return parsed;
+        }
+    }
+    catch (error) {
+        logger.warn(`[runtime-bridge] AWS_CLIENT_AGENT_MCP_ARGS 不是合法 JSON，已忽略: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logger.warn('[runtime-bridge] AWS_CLIENT_AGENT_MCP_ARGS 必须是 string[] JSON，已忽略');
+    return [];
+}
+function toWebSocketUrl(baseUrl) {
+    const url = new URL('/ws/agent', baseUrl);
+    if (url.protocol === 'https:') {
+        url.protocol = 'wss:';
+    }
+    else {
+        url.protocol = 'ws:';
+    }
+    return url.toString();
+}
+function toMcpHttpUrl(baseUrl) {
+    return new URL('/mcp/call', baseUrl).toString();
+}
+export function resolveAwsClientAgentMcpCommand(options = {}) {
+    return getAwsClientAgentMcpPreparedInfo(options);
+}
+export function getAwsClientAgentMcpPreparedInfo(options = {}) {
+    const overrideCommand = String(process.env.AWS_CLIENT_AGENT_MCP_COMMAND || '').trim();
+    if (overrideCommand) {
+        return {
+            source: 'override',
+            command: overrideCommand,
+            args: process.env.AWS_CLIENT_AGENT_MCP_ARGS ? parseAwsClientAgentMcpArgs(process.env.AWS_CLIENT_AGENT_MCP_ARGS) : [],
+        };
+    }
+    const exists = options.exists || existsSync;
+    const releasedEntry = getReleasedEntryPath();
+    if (exists(releasedEntry)) {
+        return { source: 'bundled', command: process.execPath, args: [releasedEntry] };
+    }
+    const release = options.release || releaseBundledAwsClientAgentMcp;
+    const released = release();
+    if (released && exists(released)) {
+        return { source: 'bundled', command: process.execPath, args: [released] };
+    }
+    return { source: 'global', command: 'aws-client-agent-mcp', args: [] };
+}
+export function buildAwsMcpServerConfig(input) {
+    const env = getStringEnv();
+    const command = getAwsClientAgentMcpPreparedInfo();
+    return {
+        command: command.command,
+        args: command.args,
+        env: {
+            ...getAllowedAwsMcpEnv(env),
+            AWS_AGENT_ID: input.agentId,
+            AWS_WORKSPACE_PATH: input.workspacePath,
+            AWS_SERVER_URL: env.AWS_SERVER_URL || toWebSocketUrl(schedulerBaseUrl),
+            AWS_MCP_HTTP_URL: env.AWS_MCP_HTTP_URL || toMcpHttpUrl(schedulerBaseUrl),
+        },
+    };
+}
+export function ensureAwsClientAgentMcpReleased() {
+    const prepared = getAwsClientAgentMcpPreparedInfo();
+    const commandLine = prepared.args[0] ? `${prepared.command} ${prepared.args.join(' ')}` : prepared.command;
+    if (prepared.source === 'global') {
+        logger.warn(`[runtime-bridge] ${AWS_MCP_SERVER_NAME} MCP 未找到 bundled 产物，启动时将回退到 PATH 命令: ${commandLine}`);
+        return;
+    }
+    logger.info(`[runtime-bridge] ${AWS_MCP_SERVER_NAME} MCP 已准备(${prepared.source}): ${commandLine}`);
+}

package/dist/services/aws-client-agent-mcp.test.d.ts

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

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

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

package/dist/services/aws-client-agent-mcp.test.js

@@ -0,0 +1,89 @@
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const originalEnv = { ...process.env };
+afterEach(() => {
+    process.env = { ...originalEnv };
+    vi.resetModules();
+    vi.restoreAllMocks();
+});
+describe('aws-client-agent-mcp service', () => {
+    it('prefers explicit command override from env', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'custom-aws-client-agent-mcp';
+        process.env.AWS_CLIENT_AGENT_MCP_ARGS = JSON.stringify(['--stdio', '--trace']);
+        const mod = await import('./aws-client-agent-mcp.js');
+        expect(mod.resolveAwsClientAgentMcpCommand()).toEqual({
+            source: 'override',
+            command: 'custom-aws-client-agent-mcp',
+            args: ['--stdio', '--trace'],
+        });
+    });
+    it('uses bundled dist entry when present', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
+        const mod = await import('./aws-client-agent-mcp.js');
+        const exists = vi.fn().mockReturnValue(true);
+        const resolved = mod.resolveAwsClientAgentMcpCommand({ exists });
+        const releasedEntry = path.join(os.homedir(), '.aws-bridge', 'mcp', 'dist', 'index.js');
+        expect(resolved).toEqual({
+            source: 'bundled',
+            command: process.execPath,
+            args: [releasedEntry],
+        });
+        expect(exists).toHaveBeenCalled();
+    });
+    it('releases bundled mcp into home directory when runtime dist is missing', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
+        const mod = await import('./aws-client-agent-mcp.js');
+        const releasedEntry = path.join(os.homedir(), '.aws-bridge', 'mcp', 'dist', 'index.js');
+        let released = false;
+        const exists = vi.fn((filePath) => released && filePath === releasedEntry);
+        const release = vi.fn(() => {
+            released = true;
+            return releasedEntry;
+        });
+        expect(mod.resolveAwsClientAgentMcpCommand({ exists, release })).toEqual({
+            source: 'bundled',
+            command: process.execPath,
+            args: [releasedEntry],
+        });
+        expect(release).toHaveBeenCalledOnce();
+    });
+    it('falls back to global aws-client-agent-mcp command when bundle is missing', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
+        const mod = await import('./aws-client-agent-mcp.js');
+        expect(mod.resolveAwsClientAgentMcpCommand({ exists: () => false, release: () => null })).toEqual({
+            source: 'global',
+            command: 'aws-client-agent-mcp',
+            args: [],
+        });
+    });
+    it('builds aws-mcp server config with inferred scheduler urls', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'aws-client-agent-mcp';
+        process.env.AWS_RUNTIME_CALLBACK_TOKEN = 'secret-runtime-token';
+        process.env.CUSTOM_SECRET = 'should-not-leak';
+        process.env.AWS_SERVER_URL = '';
+        process.env.AWS_MCP_HTTP_URL = '';
+        const mod = await import('./aws-client-agent-mcp.js');
+        const config = mod.buildAwsMcpServerConfig({
+            agentId: 'agent-1',
+            workspacePath: '/workspace/demo',
+        });
+        expect(config.command).toBe('aws-client-agent-mcp');
+        expect(config.env.AWS_AGENT_ID).toBe('agent-1');
+        expect(config.env.AWS_WORKSPACE_PATH).toBe('/workspace/demo');
+        expect(config.env.AWS_SERVER_URL).toBe('ws://localhost:8080/ws/agent');
+        expect(config.env.AWS_MCP_HTTP_URL).toBe('http://localhost:8080/mcp/call');
+        expect(config.env.AWS_RUNTIME_CALLBACK_TOKEN).toBeUndefined();
+        expect(config.env.CUSTOM_SECRET).toBeUndefined();
+    });
+    it('ignores malformed AWS_CLIENT_AGENT_MCP_ARGS JSON', async () => {
+        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'custom-aws-client-agent-mcp';
+        process.env.AWS_CLIENT_AGENT_MCP_ARGS = '{bad json';
+        const mod = await import('./aws-client-agent-mcp.js');
+        expect(mod.resolveAwsClientAgentMcpCommand()).toEqual({
+            source: 'override',
+            command: 'custom-aws-client-agent-mcp',
+            args: [],
+        });
+    });
+});

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,225 @@
+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

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

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

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

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

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { injectAwsMcpContext, mapAwsMcpToolName, normalizeAwsMcpArgs } from './aws-mcp-http.js';
+describe('aws mcp http service helpers', () => {
+    it('maps public aws-mcp tool names to scheduler tool names', () => {
+        expect(mapAwsMcpToolName('get_colleague')).toBe('discover_colleague');
+        expect(mapAwsMcpToolName('get_group_rooms')).toBe('discover_group_rooms');
+        expect(mapAwsMcpToolName('send_group')).toBe('send_group_message');
+        expect(mapAwsMcpToolName('send_private')).toBe('send_dm');
+        expect(mapAwsMcpToolName('my_task')).toBe('my_task');
+    });
+    it('normalizes non-object args to an empty object', () => {
+        expect(normalizeAwsMcpArgs(undefined)).toEqual({});
+        expect(normalizeAwsMcpArgs(null)).toEqual({});
+        expect(normalizeAwsMcpArgs([])).toEqual({});
+        expect(normalizeAwsMcpArgs({ content: 'hello' })).toEqual({ content: 'hello' });
+    });
+    it('injects bridge-bound agent context and converts waitReply for send_private', () => {
+        const args = injectAwsMcpContext('send_private', { targetId: 'agent-2', content: 'ping', waitReply: true }, { agentId: 'agent-1', workspacePath: '/workspace/demo' });
+        expect(args).toEqual({
+            agentId: 'agent-1',
+            workspacePath: '/workspace/demo',
+            targetId: 'agent-2',
+            content: 'ping',
+            requireReply: true,
+        });
+    });
+});

package/dist/services/cc-switch-sdk.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CC-Switch SDK 包装层
+ *
+ * 负责创建 SDK 实例并注入 adapters。
+ * adapters 实现在 src/adapters/cc-switch/ 中。
+ */
+import { CcSwitchSdk, AiConfigService, type AppFlags } from '@cc-switch/sdk';
+import { InstanceService } from './instance-service.js';
+import type { CcSwitchAppPaths, AdapterResult, SdkApps } from '../types.js';
+export declare function getCcSwitchAppPaths(): CcSwitchAppPaths;
+export declare function getCcSwitchSdk(agentId: string): CcSwitchSdk;
+export declare function loadCcSwitchSdk(agentId: string): Promise<CcSwitchSdk>;
+export declare function getAiConfigService(): AiConfigService;
+export declare function getInstanceService(agentId: string, workspacePath: string): InstanceService;
+export declare function runCcSwitchAdapter(action: string, agentId: string, payload: unknown, sdk?: CcSwitchSdk): Promise<AdapterResult>;
+export declare function toSdkAppsFromEnabledTools(enabledTools: string[]): AppFlags;
+export declare function toSdkApps(apps: SdkApps | undefined): AppFlags;
+//# sourceMappingURL=cc-switch-sdk.d.ts.map

package/dist/services/cc-switch-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cc-switch-sdk.d.ts","sourceRoot":"","sources":["../../src/services/cc-switch-sdk.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAc,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAWzF,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE5E,wBAAgB,mBAAmB,IAAI,gBAAgB,CAWtD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CA8B3D;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAI3E;AAED,wBAAgB,kBAAkB,IAAI,eAAe,CAOpD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,eAAe,CAI1F;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,aAAa,CAAC,CAgBxB;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,QAAQ,CAW1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,CAmB7D"}

package/dist/services/cc-switch-sdk.js

@@ -0,0 +1,117 @@
+/**
+ * CC-Switch SDK 包装层
+ *
+ * 负责创建 SDK 实例并注入 adapters。
+ * adapters 实现在 src/adapters/cc-switch/ 中。
+ */
+import path from 'node:path';
+import { CcSwitchSdk, AiConfigService } from '@cc-switch/sdk';
+import { createMcpAdapters, createSkillAdapters } from '../adapters/cc-switch/index.js';
+import { getCodexConfigFile, getRuntimeHomeDir, getClaudeConfigFile, getClaudeSkillsDir, getOpencodeConfigFile, getOpencodeSkillsDir, } from '../config.js';
+import { getAgentInitRoot } from './instance-state.js';
+import { InstanceService } from './instance-service.js';
+export function getCcSwitchAppPaths() {
+    const runtimeHome = path.resolve(getRuntimeHomeDir());
+    return {
+        runtimeHome,
+        claudeConfigFile: path.resolve(getClaudeConfigFile(runtimeHome)),
+        claudeSkillsDir: path.resolve(getClaudeSkillsDir(runtimeHome)),
+        codexConfigFile: path.resolve(getCodexConfigFile(runtimeHome)),
+        opencodeConfigFile: path.resolve(getOpencodeConfigFile(runtimeHome)),
+        opencodeSkillsDir: path.resolve(getOpencodeSkillsDir(runtimeHome)),
+    };
+}
+export function getCcSwitchSdk(agentId) {
+    const initRoot = getAgentInitRoot(agentId);
+    const sdkRoot = path.join(initRoot, 'cc-switch-sdk');
+    const appPaths = getCcSwitchAppPaths();
+    const paths = {
+        stateFile: path.join(sdkRoot, 'state.json'),
+        backupDir: path.join(sdkRoot, 'backups'),
+        claudeConfigFile: appPaths.claudeConfigFile,
+        claudeSkillsDir: appPaths.claudeSkillsDir,
+        claudecodeConfigFile: appPaths.claudeConfigFile, // 使用 claude 路径
+        claudecodeSkillsDir: appPaths.claudeSkillsDir, // 使用 claude 路径
+        codexConfigFile: appPaths.codexConfigFile,
+        opencodeConfigFile: appPaths.opencodeConfigFile,
+        opencodeSkillsDir: appPaths.opencodeSkillsDir,
+        ssotSkillsDir: path.join(sdkRoot, 'skills'),
+    };
+    // 创建 adapters 实例并注入
+    const mcpAdapters = createMcpAdapters(paths);
+    const skillAdapters = createSkillAdapters(paths);
+    return new CcSwitchSdk({
+        rootDir: sdkRoot,
+        paths,
+        adapters: {
+            mcp: mcpAdapters,
+            skill: skillAdapters,
+        },
+    });
+}
+export async function loadCcSwitchSdk(agentId) {
+    const sdk = getCcSwitchSdk(agentId);
+    await sdk.load();
+    return sdk;
+}
+export function getAiConfigService() {
+    const appPaths = getCcSwitchAppPaths();
+    return new AiConfigService({
+        claudecodeConfigFile: appPaths.claudeConfigFile,
+        codexConfigFile: appPaths.codexConfigFile,
+        opencodeConfigFile: appPaths.opencodeConfigFile,
+    });
+}
+export function getInstanceService(agentId, workspacePath) {
+    const sdk = getCcSwitchSdk(agentId);
+    const initRoot = getAgentInitRoot(agentId);
+    return new InstanceService(sdk, initRoot, workspacePath);
+}
+export async function runCcSwitchAdapter(action, agentId, payload, sdk) {
+    const activeSdk = sdk || (await loadCcSwitchSdk(agentId));
+    const appPaths = getCcSwitchAppPaths();
+    return {
+        ok: true,
+        adapter: 'cc-switch-sdk',
+        action,
+        agentId: String(agentId),
+        payload,
+        paths: appPaths,
+        snapshot: {
+            skills: activeSdk.getAllSkills().length,
+            mcpServers: activeSdk.getAllMcpServers().length,
+        },
+    };
+}
+export function toSdkAppsFromEnabledTools(enabledTools) {
+    const tools = Array.isArray(enabledTools) ? enabledTools : [];
+    const includes = (name) => tools.includes(name);
+    return {
+        claude: includes('claude'),
+        claudecode: includes('claudecode'),
+        codex: includes('codex'),
+        gemini: includes('gemini'),
+        opencode: includes('opencode'),
+        openclaw: includes('openclaw'),
+    };
+}
+export function toSdkApps(apps) {
+    if (!apps) {
+        return {
+            claude: false,
+            claudecode: false,
+            codex: false,
+            gemini: false,
+            opencode: false,
+            openclaw: false,
+        };
+    }
+    return {
+        claude: Boolean(apps.claude),
+        claudecode: false,
+        codex: Boolean(apps.codex),
+        gemini: Boolean(apps.gemini),
+        opencode: Boolean(apps.opencode),
+        openclaw: Boolean(apps.openclaw),
+    };
+}