aws-runtime-bridge 1.0.0

package/dist/adapters/cc-switch/mcp-claudecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-claudecode.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/mcp-claudecode.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAwC7D,qBAAa,oBAAqB,YAAW,WAAW;IAG1C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,SAAgB,KAAK,EAAG,YAAY,CAAU;gBAEjB,UAAU,EAAE,MAAM;IAEzC,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAmBrC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CASrD"}

package/dist/adapters/cc-switch/mcp-claudecode.js

@@ -0,0 +1,77 @@
+/**
+ * ClaudeCode MCP Adapter
+ *
+ * 实现 IMcpAdapter 接口，负责 ClaudeCode 的 MCP 配置读写
+ */
+import { toMcpSpecFromClaudecode, toClaudecodeServer } from './common.js';
+/**
+ * JSON 文件读取工具
+ */
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await import('node:fs/promises').then(fs => fs.readFile(filePath, "utf-8"));
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return { ...fallback };
+    }
+    catch {
+        return { ...fallback };
+    }
+}
+/**
+ * JSON 文件写入工具
+ */
+async function writeJsonFile(filePath, content) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const parent = path.dirname(filePath);
+    await fs.mkdir(parent, { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2), "utf-8");
+}
+/**
+ * 生成唯一 ID
+ */
+function createId(prefix) {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${timestamp}_${random}`;
+}
+export class ClaudecodeMcpAdapter {
+    constructor(configPath) {
+        this.configPath = configPath;
+        this.appId = "claudecode";
+    }
+    async importServers() {
+        const config = await readJsonFile(this.configPath, {});
+        const entries = Object.entries(config.mcpServers ?? {});
+        return entries.map(([name, server]) => ({
+            id: createId("mcp"),
+            name,
+            server: toMcpSpecFromClaudecode(server),
+            apps: {
+                claude: false,
+                claudecode: true,
+                codex: false,
+                gemini: false,
+                opencode: false,
+                openclaw: false,
+            },
+        }));
+    }
+    async syncServer(server) {
+        const config = await readJsonFile(this.configPath, {});
+        config.mcpServers = config.mcpServers ?? {};
+        config.mcpServers[server.name] = toClaudecodeServer(server.server);
+        await writeJsonFile(this.configPath, config);
+    }
+    async removeServer(server) {
+        const config = await readJsonFile(this.configPath, {});
+        if (!config.mcpServers) {
+            return;
+        }
+        delete config.mcpServers[server.name];
+        await writeJsonFile(this.configPath, config);
+    }
+}

package/dist/adapters/cc-switch/mcp-codex.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Codex MCP Adapter
+ *
+ * Codex does not receive per-session MCP servers from the current SDK surface.
+ * This adapter persists MCP servers into Codex's config.toml while preserving
+ * unrelated user-owned config text.
+ */
+import type { IMcpAdapter, McpServer } from '@cc-switch/sdk';
+export declare class CodexMcpAdapter implements IMcpAdapter {
+    private readonly configPath;
+    readonly appId: "codex";
+    constructor(configPath: string);
+    importServers(): Promise<McpServer[]>;
+    syncServer(server: McpServer): Promise<void>;
+    removeServer(server: McpServer): Promise<void>;
+}
+//# sourceMappingURL=mcp-codex.d.ts.map

package/dist/adapters/cc-switch/mcp-codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-codex.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/mcp-codex.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAiB,MAAM,gBAAgB,CAAC;AAuP5E,qBAAa,eAAgB,YAAW,WAAW;IAGrC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,SAAgB,KAAK,EAAG,OAAO,CAAU;gBAEZ,UAAU,EAAE,MAAM;IAEzC,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAiBrC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5C,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAQrD"}

package/dist/adapters/cc-switch/mcp-codex.js

@@ -0,0 +1,248 @@
+/**
+ * Codex MCP Adapter
+ *
+ * Codex does not receive per-session MCP servers from the current SDK surface.
+ * This adapter persists MCP servers into Codex's config.toml while preserving
+ * unrelated user-owned config text.
+ */
+const MCP_TABLE_PATTERN = /^\s*\[mcp_servers\.("(?:\\.|[^"])+"|[A-Za-z0-9_-]+)\]\s*$/;
+const TABLE_PATTERN = /^\s*\[[^\]]+\]\s*$/;
+const KEY_VALUE_PATTERN = /^\s*([A-Za-z0-9_-]+)\s*=\s*(.*)\s*$/;
+async function readTextFile(filePath) {
+    try {
+        const fs = await import('node:fs/promises');
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+async function writeTextFile(filePath, content) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+function createId(prefix) {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${timestamp}_${random}`;
+}
+function escapeTomlString(value) {
+    return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function unescapeTomlString(value) {
+    return value.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+}
+function quoteTomlString(value) {
+    return `"${escapeTomlString(value)}"`;
+}
+function parseTomlString(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('"') || !trimmed.endsWith('"')) {
+        return undefined;
+    }
+    return unescapeTomlString(trimmed.slice(1, -1));
+}
+function parseTomlStringArray(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
+        return undefined;
+    }
+    const values = [];
+    let current = '';
+    let inString = false;
+    let escaping = false;
+    for (const char of trimmed.slice(1, -1)) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === '\\' && inString) {
+            escaping = true;
+            continue;
+        }
+        if (char === '"') {
+            if (inString) {
+                values.push(unescapeTomlString(current));
+                current = '';
+            }
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            current += char;
+        }
+    }
+    return values;
+}
+function formatTomlArray(values) {
+    return `[${(values ?? []).map(quoteTomlString).join(', ')}]`;
+}
+function parseTableName(rawName) {
+    const trimmed = rawName.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return unescapeTomlString(trimmed.slice(1, -1));
+    }
+    return trimmed;
+}
+function isNestedMcpTableForServer(line, serverName) {
+    const trimmed = line.trim();
+    const quotedPrefix = `[mcp_servers.${quoteTomlString(serverName)}.`;
+    const barePrefix = `[mcp_servers.${serverName}.`;
+    return trimmed.startsWith(quotedPrefix) || trimmed.startsWith(barePrefix);
+}
+function findMcpBlocks(raw) {
+    const lines = raw.split(/\r?\n/);
+    const blocks = [];
+    let currentName = null;
+    let currentStart = null;
+    const flushCurrent = (end) => {
+        if (currentName === null || currentStart === null) {
+            return;
+        }
+        blocks.push({
+            name: currentName,
+            start: currentStart,
+            end,
+            lines: lines.slice(currentStart, end),
+        });
+        currentName = null;
+        currentStart = null;
+    };
+    lines.forEach((line, index) => {
+        const mcpMatch = line.match(MCP_TABLE_PATTERN);
+        if (mcpMatch) {
+            flushCurrent(index);
+            currentName = parseTableName(mcpMatch[1]);
+            currentStart = index;
+            return;
+        }
+        if (line.match(TABLE_PATTERN) && currentName && !isNestedMcpTableForServer(line, currentName)) {
+            flushCurrent(index);
+        }
+    });
+    flushCurrent(lines.length);
+    return blocks;
+}
+function buildCodexMcpBlock(server) {
+    const spec = server.server;
+    const lines = [`[mcp_servers.${quoteTomlString(server.name)}]`];
+    if (spec.command) {
+        lines.push(`command = ${quoteTomlString(spec.command)}`);
+    }
+    if (spec.args) {
+        lines.push(`args = ${formatTomlArray(spec.args)}`);
+    }
+    if (spec.cwd) {
+        lines.push(`cwd = ${quoteTomlString(spec.cwd)}`);
+    }
+    if (spec.url) {
+        lines.push(`url = ${quoteTomlString(spec.url)}`);
+    }
+    const envEntries = Object.entries(spec.env ?? {}).sort(([left], [right]) => left.localeCompare(right));
+    if (envEntries.length > 0) {
+        lines.push('');
+        lines.push(`[mcp_servers.${quoteTomlString(server.name)}.env]`);
+        for (const [key, value] of envEntries) {
+            lines.push(`${key} = ${quoteTomlString(value)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function removeCodexMcpBlock(raw, serverName) {
+    const lines = raw.split(/\r?\n/);
+    const block = findMcpBlocks(raw).find((entry) => entry.name === serverName);
+    if (!block) {
+        return raw;
+    }
+    const nextLines = [...lines.slice(0, block.start), ...lines.slice(block.end)];
+    return nextLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+function upsertCodexMcpBlock(raw, server) {
+    const withoutExisting = removeCodexMcpBlock(raw, server.name).trimEnd();
+    const block = buildCodexMcpBlock(server);
+    if (!withoutExisting) {
+        return `${block}\n`;
+    }
+    return `${withoutExisting}\n\n${block}\n`;
+}
+function parseCodexBlock(block) {
+    const spec = { type: 'stdio' };
+    const env = {};
+    let inEnv = false;
+    for (const line of block.lines.slice(1)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        if (trimmed === `[mcp_servers.${quoteTomlString(block.name)}.env]`) {
+            inEnv = true;
+            continue;
+        }
+        const match = line.match(KEY_VALUE_PATTERN);
+        if (!match) {
+            continue;
+        }
+        const [, key, rawValue] = match;
+        if (inEnv) {
+            const value = parseTomlString(rawValue);
+            if (value !== undefined) {
+                env[key] = value;
+            }
+            continue;
+        }
+        if (key === 'args') {
+            spec.args = parseTomlStringArray(rawValue) ?? [];
+            continue;
+        }
+        if (key === 'command' || key === 'cwd' || key === 'url') {
+            const value = parseTomlString(rawValue);
+            if (value !== undefined) {
+                spec[key] = value;
+            }
+        }
+    }
+    if (Object.keys(env).length > 0) {
+        spec.env = env;
+    }
+    if (spec.url) {
+        spec.type = 'sse';
+    }
+    return spec;
+}
+export class CodexMcpAdapter {
+    constructor(configPath) {
+        this.configPath = configPath;
+        this.appId = 'codex';
+    }
+    async importServers() {
+        const raw = await readTextFile(this.configPath);
+        return findMcpBlocks(raw).map((block) => ({
+            id: createId('mcp'),
+            name: block.name,
+            server: parseCodexBlock(block),
+            apps: {
+                claude: false,
+                claudecode: false,
+                codex: true,
+                gemini: false,
+                opencode: false,
+                openclaw: false,
+            },
+        }));
+    }
+    async syncServer(server) {
+        const raw = await readTextFile(this.configPath);
+        await writeTextFile(this.configPath, upsertCodexMcpBlock(raw, server));
+    }
+    async removeServer(server) {
+        const raw = await readTextFile(this.configPath);
+        const next = removeCodexMcpBlock(raw, server.name);
+        if (next === raw) {
+            return;
+        }
+        await writeTextFile(this.configPath, next ? `${next}\n` : '');
+    }
+}

package/dist/adapters/cc-switch/mcp-codex.test.d.ts

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

package/dist/adapters/cc-switch/mcp-codex.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-codex.test.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/mcp-codex.test.ts"],"names":[],"mappings":""}

package/dist/adapters/cc-switch/mcp-codex.test.js

@@ -0,0 +1,125 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { CodexMcpAdapter } from './mcp-codex.js';
+let tempDir;
+let configPath;
+function buildServer(name = 'aws-client-agent-mcp') {
+    return {
+        id: 'mcp_test',
+        name,
+        server: {
+            type: 'stdio',
+            command: 'node',
+            args: ['D:\\code\\AgentsWorkStudio\\aws-runtime-bridge\\package\\cc-switch-sdk\\dist\\index.js'],
+            env: {
+                AWS_AGENT_ID: 'agent-1',
+            },
+        },
+        apps: {
+            claude: false,
+            claudecode: false,
+            codex: true,
+            gemini: false,
+            opencode: false,
+            openclaw: false,
+        },
+    };
+}
+beforeEach(async () => {
+    tempDir = await mkdtemp(path.join(os.tmpdir(), 'codex-mcp-adapter-'));
+    configPath = path.join(tempDir, 'config.toml');
+});
+afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+});
+describe('CodexMcpAdapter', () => {
+    it('creates a Codex config with an MCP block when none exists', async () => {
+        const adapter = new CodexMcpAdapter(configPath);
+        await adapter.syncServer(buildServer());
+        const written = await readFile(configPath, 'utf-8');
+        expect(written).toContain('[mcp_servers."aws-client-agent-mcp"]');
+        expect(written).toContain('command = "node"');
+        expect(written).toContain('args = ["D:\\\\code\\\\AgentsWorkStudio\\\\aws-runtime-bridge\\\\package\\\\cc-switch-sdk\\\\dist\\\\index.js"]');
+        expect(written).toContain('[mcp_servers."aws-client-agent-mcp".env]');
+        expect(written).toContain('AWS_AGENT_ID = "agent-1"');
+    });
+    it('preserves unrelated Codex model/provider config while appending MCP config', async () => {
+        const existing = [
+            '# user comment',
+            'model = "gpt-5.1"',
+            'model_provider = "custom"',
+            '',
+            '[model_providers.custom]',
+            'name = "Custom"',
+            'base_url = "https://example.test/v1"',
+            '',
+        ].join('\n');
+        await writeFile(configPath, existing, 'utf-8');
+        const adapter = new CodexMcpAdapter(configPath);
+        await adapter.syncServer(buildServer());
+        const written = await readFile(configPath, 'utf-8');
+        expect(written).toContain(existing.trimEnd());
+        expect(written).toContain('[mcp_servers."aws-client-agent-mcp"]');
+    });
+    it('updates an existing MCP block without duplicating it', async () => {
+        const adapter = new CodexMcpAdapter(configPath);
+        await adapter.syncServer(buildServer());
+        await adapter.syncServer({
+            ...buildServer(),
+            server: {
+                type: 'stdio',
+                command: 'node',
+                args: ['new-index.js'],
+                env: {
+                    AWS_AGENT_ID: 'agent-2',
+                },
+            },
+        });
+        const written = await readFile(configPath, 'utf-8');
+        expect(written.match(/\[mcp_servers\."aws-client-agent-mcp"\]/g)).toHaveLength(1);
+        expect(written).toContain('args = ["new-index.js"]');
+        expect(written).toContain('AWS_AGENT_ID = "agent-2"');
+        expect(written).not.toContain('agent-1');
+    });
+    it('removes the MCP block and its nested env table only', async () => {
+        const adapter = new CodexMcpAdapter(configPath);
+        await writeFile(configPath, [
+            'model = "gpt-5.1"',
+            '',
+            '[mcp_servers."aws-client-agent-mcp"]',
+            'command = "node"',
+            'args = ["old.js"]',
+            '',
+            '[mcp_servers."aws-client-agent-mcp".env]',
+            'AWS_AGENT_ID = "agent-1"',
+            '',
+            '[model_providers.custom]',
+            'name = "Custom"',
+            '',
+        ].join('\n'), 'utf-8');
+        await adapter.removeServer(buildServer());
+        const written = await readFile(configPath, 'utf-8');
+        expect(written).toContain('model = "gpt-5.1"');
+        expect(written).toContain('[model_providers.custom]');
+        expect(written).not.toContain('aws-client-agent-mcp');
+        expect(written).not.toContain('AWS_AGENT_ID');
+    });
+    it('imports Codex MCP blocks', async () => {
+        const adapter = new CodexMcpAdapter(configPath);
+        await adapter.syncServer(buildServer());
+        const servers = await adapter.importServers();
+        expect(servers).toHaveLength(1);
+        expect(servers[0]).toMatchObject({
+            name: 'aws-client-agent-mcp',
+            apps: { codex: true },
+            server: {
+                type: 'stdio',
+                command: 'node',
+                args: ['D:\\code\\AgentsWorkStudio\\aws-runtime-bridge\\package\\cc-switch-sdk\\dist\\index.js'],
+                env: { AWS_AGENT_ID: 'agent-1' },
+            },
+        });
+    });
+});

package/dist/adapters/cc-switch/mcp-opencode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenCode MCP Adapter
+ *
+ * 实现 IMcpAdapter 接口，负责 OpenCode 的 MCP 配置读写
+ */
+import type { IMcpAdapter, McpServer } from '@cc-switch/sdk';
+export declare class OpenCodeMcpAdapter implements IMcpAdapter {
+    private readonly configPath;
+    readonly appId: "opencode";
+    constructor(configPath: string);
+    /**
+     * 读取 OpenCode MCP 映射，优先使用合法的 mcp 字段，兼容历史错误写入的 mcpServers。
+     */
+    private getMcpMap;
+    /**
+     * 将 MCP 服务器写回 OpenCode 配置，只保留合法的 mcp 字段并清理错误的 mcpServers。
+     */
+    private saveMcpMap;
+    importServers(): Promise<McpServer[]>;
+    syncServer(server: McpServer): Promise<void>;
+    removeServer(server: McpServer): Promise<void>;
+}
+//# sourceMappingURL=mcp-opencode.d.ts.map

package/dist/adapters/cc-switch/mcp-opencode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-opencode.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/mcp-opencode.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAwC7D,qBAAa,kBAAmB,YAAW,WAAW;IAGxC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,SAAgB,KAAK,EAAG,UAAU,CAAU;gBAEf,UAAU,EAAE,MAAM;IAE/C;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;YACW,UAAU;IAQlB,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAmBrC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAUrD"}

package/dist/adapters/cc-switch/mcp-opencode.js

@@ -0,0 +1,100 @@
+/**
+ * OpenCode MCP Adapter
+ *
+ * 实现 IMcpAdapter 接口，负责 OpenCode 的 MCP 配置读写
+ */
+import { toMcpSpecFromOpenCode, toOpenCodeServer } from './common.js';
+/**
+ * JSON 文件读取工具
+ */
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await import('node:fs/promises').then(fs => fs.readFile(filePath, "utf-8"));
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return { ...fallback };
+    }
+    catch {
+        return { ...fallback };
+    }
+}
+/**
+ * JSON 文件写入工具
+ */
+async function writeJsonFile(filePath, content) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const parent = path.dirname(filePath);
+    await fs.mkdir(parent, { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2), "utf-8");
+}
+/**
+ * 生成唯一 ID
+ */
+function createId(prefix) {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${timestamp}_${random}`;
+}
+export class OpenCodeMcpAdapter {
+    constructor(configPath) {
+        this.configPath = configPath;
+        this.appId = "opencode";
+    }
+    /**
+     * 读取 OpenCode MCP 映射，优先使用合法的 mcp 字段，兼容历史错误写入的 mcpServers。
+     */
+    getMcpMap(config) {
+        if (config.mcp && typeof config.mcp === "object") {
+            return config.mcp;
+        }
+        if (config.mcpServers && typeof config.mcpServers === "object") {
+            return config.mcpServers;
+        }
+        return {};
+    }
+    /**
+     * 将 MCP 服务器写回 OpenCode 配置，只保留合法的 mcp 字段并清理错误的 mcpServers。
+     */
+    async saveMcpMap(config, mcp) {
+        config.mcp = mcp;
+        if ("mcpServers" in config) {
+            delete config.mcpServers;
+        }
+        await writeJsonFile(this.configPath, config);
+    }
+    async importServers() {
+        const config = await readJsonFile(this.configPath, {});
+        const entries = Object.entries(this.getMcpMap(config));
+        return entries.map(([name, server]) => ({
+            id: createId("mcp"),
+            name,
+            server: toMcpSpecFromOpenCode(server),
+            apps: {
+                claude: false,
+                claudecode: false,
+                codex: false,
+                gemini: false,
+                opencode: true,
+                openclaw: false,
+            },
+        }));
+    }
+    async syncServer(server) {
+        const config = await readJsonFile(this.configPath, {});
+        const mcp = this.getMcpMap(config);
+        mcp[server.name] = toOpenCodeServer(server.server);
+        await this.saveMcpMap(config, mcp);
+    }
+    async removeServer(server) {
+        const config = await readJsonFile(this.configPath, {});
+        const mcp = this.getMcpMap(config);
+        if (!mcp[server.name]) {
+            return;
+        }
+        delete mcp[server.name];
+        await this.saveMcpMap(config, mcp);
+    }
+}

package/dist/adapters/cc-switch/mcp-placeholder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Placeholder MCP Adapter
+ *
+ * 用于尚未实现的 AI 工具（Codex、Gemini、OpenClaw）
+ */
+import type { AppId, IMcpAdapter, McpServer } from '@cc-switch/sdk';
+export declare class PlaceholderMcpAdapter implements IMcpAdapter {
+    readonly appId: AppId;
+    constructor(appId: AppId);
+    importServers(): Promise<McpServer[]>;
+    syncServer(): Promise<void>;
+    removeServer(): Promise<void>;
+}
+//# sourceMappingURL=mcp-placeholder.d.ts.map

package/dist/adapters/cc-switch/mcp-placeholder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-placeholder.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/mcp-placeholder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEpE,qBAAa,qBAAsB,YAAW,WAAW;aAC3B,KAAK,EAAE,KAAK;gBAAZ,KAAK,EAAE,KAAK;IAElC,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAIrC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAGpC"}

package/dist/adapters/cc-switch/mcp-placeholder.js

@@ -0,0 +1,19 @@
+/**
+ * Placeholder MCP Adapter
+ *
+ * 用于尚未实现的 AI 工具（Codex、Gemini、OpenClaw）
+ */
+export class PlaceholderMcpAdapter {
+    constructor(appId) {
+        this.appId = appId;
+    }
+    async importServers() {
+        return [];
+    }
+    async syncServer() {
+        return;
+    }
+    async removeServer() {
+        return;
+    }
+}

package/dist/adapters/cc-switch/skill-claude.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Claude Skill Adapter
+ *
+ * 实现 ISkillAdapter 接口，负责 Claude Desktop 的 Skill 目录管理
+ */
+import type { ISkillAdapter, InstalledSkill, SkillSyncMethod } from '@cc-switch/sdk';
+export declare class ClaudeSkillAdapter implements ISkillAdapter {
+    private readonly skillsDir;
+    readonly appId: "claude";
+    constructor(skillsDir: string);
+    importSkills(): Promise<Array<Pick<InstalledSkill, "id" | "name" | "directory" | "description">>>;
+    syncSkill(skill: InstalledSkill, sourceDir: string, method: SkillSyncMethod): Promise<void>;
+    removeSkill(skill: InstalledSkill): Promise<void>;
+}
+//# sourceMappingURL=skill-claude.d.ts.map

package/dist/adapters/cc-switch/skill-claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-claude.d.ts","sourceRoot":"","sources":["../../../src/adapters/cc-switch/skill-claude.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAoErF,qBAAa,kBAAmB,YAAW,aAAa;IAG1C,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,SAAgB,KAAK,EAAG,QAAQ,CAAU;gBAEb,SAAS,EAAE,MAAM;IAExC,YAAY,IAAI,OAAO,CAC3B,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,GAAG,WAAW,GAAG,aAAa,CAAC,CAAC,CACzE;IAmBK,SAAS,CACb,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,IAAI,CAAC;IAMV,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAKxD"}