aws-runtime-bridge 1.0.0

package/package/cc-switch-sdk/dist/services/ai-config-service.d.ts

@@ -0,0 +1,75 @@
+export interface AiConfigTemplate {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    models?: string[];
+}
+export interface ClaudeCodeConfig {
+    env?: {
+        ANTHROPIC_BASE_URL?: string;
+        ANTHROPIC_AUTH_TOKEN?: string;
+        ANTHROPIC_MODEL?: string;
+    };
+}
+export interface OpenCodeProviderConfig {
+    npm?: string;
+    options?: {
+        baseURL?: string;
+        apiKey?: string;
+    };
+    models?: Record<string, {
+        name: string;
+        modalities?: {
+            input: string[];
+            output: string[];
+        };
+    }>;
+}
+export interface OpenCodeConfig {
+    provider?: {
+        default?: OpenCodeProviderConfig;
+    };
+}
+export interface CodexModelProviderConfig {
+    name?: string;
+    base_url?: string;
+    wire_api?: "responses" | "chat" | string;
+    env_key?: string;
+    env_key_instructions?: string;
+    requires_openai_auth?: boolean;
+}
+export interface CodexConfig {
+    model?: string;
+    model_provider?: string;
+    openai_base_url?: string;
+    model_providers?: Record<string, CodexModelProviderConfig>;
+}
+export interface AiConfigPaths {
+    claudecodeConfigFile: string;
+    codexConfigFile: string;
+    opencodeConfigFile: string;
+}
+export declare function buildToolSpecificAiConfig(template: AiConfigTemplate): {
+    claudecode: ClaudeCodeConfig;
+    codex: CodexConfig;
+    opencode: OpenCodeConfig;
+} | null;
+export declare class AiConfigService {
+    private readonly paths;
+    constructor(paths: AiConfigPaths);
+    readClaudeCodeConfig(): Promise<ClaudeCodeConfig>;
+    readOpenCodeConfig(): Promise<OpenCodeConfig>;
+    readCodexConfig(): Promise<CodexConfig>;
+    writeClaudeCodeConfig(config: ClaudeCodeConfig): Promise<void>;
+    writeOpenCodeConfig(config: OpenCodeConfig): Promise<void>;
+    writeCodexConfig(config: CodexConfig): Promise<void>;
+    applyClaudeCodeConfig(patch: ClaudeCodeConfig): Promise<ClaudeCodeConfig>;
+    applyOpenCodeConfig(patch: OpenCodeConfig): Promise<OpenCodeConfig>;
+    applyCodexConfig(patch: CodexConfig): Promise<CodexConfig>;
+    applyAiConfigTemplate(template: AiConfigTemplate): Promise<{
+        claudecode: ClaudeCodeConfig;
+        codex: CodexConfig;
+        opencode: OpenCodeConfig;
+    } | null>;
+}
+//# sourceMappingURL=ai-config-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-config-service.d.ts","sourceRoot":"","sources":["../../src/services/ai-config-service.ts"],"names":[],"mappings":"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"}

package/package/cc-switch-sdk/dist/services/ai-config-service.js

@@ -0,0 +1,280 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+function normalizeTemplateModels(template) {
+    const dedup = new Set();
+    const appendModel = (value) => {
+        const normalized = String(value || '').trim();
+        if (normalized) {
+            dedup.add(normalized);
+        }
+    };
+    if (Array.isArray(template.models)) {
+        template.models.forEach(appendModel);
+    }
+    appendModel(template.model);
+    return [...dedup];
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await 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 };
+    }
+}
+async function writeJsonFile(filePath, content) {
+    const parent = path.dirname(filePath);
+    await fs.mkdir(parent, { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(content, null, 2), "utf-8");
+}
+function deepMergeConfig(target, source) {
+    if (!source || typeof source !== "object" || Array.isArray(source)) {
+        return target;
+    }
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (value !== null &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            result[key] !== null &&
+            typeof result[key] === "object" &&
+            !Array.isArray(result[key])) {
+            result[key] = deepMergeConfig(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function normalizeCodexBaseUrl(baseUrl) {
+    return normalizeOpenAiCompatibleBaseUrl(baseUrl);
+}
+function escapeTomlString(value) {
+    return String(value || "").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function parseTomlStringValue(value) {
+    const trimmed = String(value || "").trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return trimmed;
+}
+function parseTomlBooleanValue(value) {
+    const normalized = String(value || "").trim().toLowerCase();
+    if (normalized === "true")
+        return true;
+    if (normalized === "false")
+        return false;
+    return undefined;
+}
+function parseCodexConfigToml(raw) {
+    const config = { model_providers: {} };
+    let currentProvider = null;
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const providerMatch = trimmed.match(/^\[model_providers\.([^\]]+)\]$/);
+        if (providerMatch) {
+            currentProvider = providerMatch[1];
+            config.model_providers = config.model_providers || {};
+            config.model_providers[currentProvider] = config.model_providers[currentProvider] || {};
+            continue;
+        }
+        if (trimmed.startsWith("[")) {
+            currentProvider = null;
+            continue;
+        }
+        const keyValueMatch = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+        if (!keyValueMatch) {
+            continue;
+        }
+        const [, key, rawValue] = keyValueMatch;
+        if (currentProvider) {
+            const provider = config.model_providers?.[currentProvider] || {};
+            if (key === "requires_openai_auth") {
+                const parsed = parseTomlBooleanValue(rawValue);
+                if (parsed !== undefined)
+                    provider.requires_openai_auth = parsed;
+            }
+            else if (["name", "base_url", "wire_api", "env_key", "env_key_instructions"].includes(key)) {
+                provider[key] = parseTomlStringValue(rawValue);
+            }
+            config.model_providers = { ...(config.model_providers || {}), [currentProvider]: provider };
+            continue;
+        }
+        if (["model", "model_provider", "openai_base_url"].includes(key)) {
+            config[key] = parseTomlStringValue(rawValue);
+        }
+    }
+    return config;
+}
+function serializeCodexConfig(config) {
+    const lines = [];
+    if (config.model) {
+        lines.push(`model = "${escapeTomlString(config.model)}"`);
+    }
+    if (config.model_provider) {
+        lines.push(`model_provider = "${escapeTomlString(config.model_provider)}"`);
+    }
+    if (config.openai_base_url) {
+        lines.push(`openai_base_url = "${escapeTomlString(config.openai_base_url)}"`);
+    }
+    const providers = config.model_providers || {};
+    for (const [providerId, provider] of Object.entries(providers)) {
+        lines.push("");
+        lines.push(`[model_providers.${providerId}]`);
+        if (provider.name)
+            lines.push(`name = "${escapeTomlString(provider.name)}"`);
+        if (provider.base_url)
+            lines.push(`base_url = "${escapeTomlString(provider.base_url)}"`);
+        if (provider.wire_api)
+            lines.push(`wire_api = "${escapeTomlString(provider.wire_api)}"`);
+        if (provider.env_key)
+            lines.push(`env_key = "${escapeTomlString(provider.env_key)}"`);
+        if (provider.env_key_instructions) {
+            lines.push(`env_key_instructions = "${escapeTomlString(provider.env_key_instructions)}"`);
+        }
+        if (provider.requires_openai_auth !== undefined) {
+            lines.push(`requires_openai_auth = ${provider.requires_openai_auth ? "true" : "false"}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function buildToolSpecificAiConfig(template) {
+    let baseUrl = String(template.baseUrl || "").trim();
+    const apiKey = String(template.apiKey || "").trim();
+    const models = normalizeTemplateModels(template);
+    const model = models[0] || String(template.model || "").trim();
+    if (!baseUrl || !apiKey || !model) {
+        return null;
+    }
+    if (baseUrl &&
+        !baseUrl.startsWith("http://") &&
+        !baseUrl.startsWith("https://")) {
+        baseUrl = `https://${baseUrl}`;
+    }
+    baseUrl = baseUrl.replace(/\/+$/, "");
+    const openCodeBaseUrl = normalizeOpenAiCompatibleBaseUrl(baseUrl);
+    const codexBaseUrl = normalizeCodexBaseUrl(baseUrl);
+    const opencodeModels = Object.fromEntries(models.map((modelName) => [modelName, {
+            name: modelName,
+            modalities: {
+                input: ["text", "image"],
+                output: ["text"],
+            },
+        }]));
+    return {
+        claudecode: {
+            env: {
+                ANTHROPIC_BASE_URL: baseUrl,
+                ANTHROPIC_AUTH_TOKEN: apiKey,
+                ANTHROPIC_MODEL: model,
+            },
+        },
+        codex: {
+            model,
+            model_provider: "default",
+            model_providers: {
+                default: {
+                    name: "Default",
+                    base_url: codexBaseUrl,
+                    wire_api: "responses",
+                    env_key: "OPENAI_API_KEY",
+                    env_key_instructions: "Set OPENAI_API_KEY in your environment",
+                },
+            },
+        },
+        opencode: {
+            provider: {
+                default: {
+                    npm: "@ai-sdk/openai-compatible",
+                    options: {
+                        baseURL: openCodeBaseUrl,
+                        apiKey,
+                    },
+                    models: opencodeModels,
+                },
+            },
+        },
+    };
+}
+/**
+ * 规范化 OpenAI-compatible 的 OpenCode baseURL，确保缺省地址自动补齐 /v1。
+ */
+function normalizeOpenAiCompatibleBaseUrl(baseUrl) {
+    const normalized = String(baseUrl || "").trim().replace(/\/+$/, "");
+    if (!normalized) {
+        return normalized;
+    }
+    return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+export class AiConfigService {
+    constructor(paths) {
+        this.paths = paths;
+    }
+    async readClaudeCodeConfig() {
+        return readJsonFile(this.paths.claudecodeConfigFile, {});
+    }
+    async readOpenCodeConfig() {
+        return readJsonFile(this.paths.opencodeConfigFile, {});
+    }
+    async readCodexConfig() {
+        try {
+            const raw = await fs.readFile(this.paths.codexConfigFile, "utf-8");
+            return parseCodexConfigToml(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    async writeClaudeCodeConfig(config) {
+        await writeJsonFile(this.paths.claudecodeConfigFile, config);
+    }
+    async writeOpenCodeConfig(config) {
+        await writeJsonFile(this.paths.opencodeConfigFile, config);
+    }
+    async writeCodexConfig(config) {
+        const parent = path.dirname(this.paths.codexConfigFile);
+        await fs.mkdir(parent, { recursive: true });
+        await fs.writeFile(this.paths.codexConfigFile, serializeCodexConfig(config), "utf-8");
+    }
+    async applyClaudeCodeConfig(patch) {
+        const current = await this.readClaudeCodeConfig();
+        const merged = deepMergeConfig(current, patch);
+        await this.writeClaudeCodeConfig(merged);
+        return merged;
+    }
+    async applyOpenCodeConfig(patch) {
+        const current = await this.readOpenCodeConfig();
+        const merged = deepMergeConfig(current, patch);
+        await this.writeOpenCodeConfig(merged);
+        return merged;
+    }
+    async applyCodexConfig(patch) {
+        const current = await this.readCodexConfig();
+        const merged = deepMergeConfig(current, patch);
+        await this.writeCodexConfig(merged);
+        return merged;
+    }
+    async applyAiConfigTemplate(template) {
+        const configs = buildToolSpecificAiConfig(template);
+        if (!configs) {
+            return null;
+        }
+        const claudecode = await this.applyClaudeCodeConfig(configs.claudecode);
+        const codex = await this.applyCodexConfig(configs.codex);
+        const opencode = await this.applyOpenCodeConfig(configs.opencode);
+        return { claudecode, codex, opencode };
+    }
+}

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

@@ -0,0 +1,78 @@
+import type { AppId, InstalledSkill, McpServer } from "../types.js";
+import { CcSwitchSdk } from "../sdk.js";
+export interface SkillPackage {
+    downloadUrl?: string;
+    fileName?: string;
+    sha256?: string;
+    skillName?: string;
+    localPath?: string;
+}
+export interface McpServerInput {
+    id?: string;
+    name: string;
+    transport?: string;
+    command?: string;
+    url?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface InstanceOptions {
+    skillEnabled?: boolean;
+    mcpEnabled?: boolean;
+    enabledApps?: AppId[];
+    skillPackage?: SkillPackage;
+    skillPackages?: SkillPackage[];
+    mcpServers?: McpServerInput[];
+}
+export interface InstanceState {
+    initialized: boolean;
+    skills: InstalledSkill[];
+    mcpServers: McpServer[];
+    enabledApps: AppId[];
+    skillEnabled: boolean;
+    mcpEnabled: boolean;
+    updatedAt: string | null;
+}
+export interface InstanceInitResult {
+    ok: boolean;
+    instanceId: string;
+    workspacePath: string;
+    instanceRoot: string;
+    enabledApps: AppId[];
+    skill: {
+        enabled: boolean;
+        packagePresent: boolean;
+        installedCount?: number;
+        installed?: InstalledSkill[];
+    };
+    mcp: {
+        enabled: boolean;
+        installedCount?: number;
+        installed?: McpServer[];
+    };
+}
+export interface InstancePaths {
+    instanceRoot: string;
+    stateFile: string;
+    skillsDir: string;
+    mcpDir: string;
+}
+export declare class InstanceService {
+    private readonly sdk;
+    private readonly instanceRoot;
+    private readonly workspacePath;
+    constructor(sdk: CcSwitchSdk, instanceRoot: string, workspacePath: string);
+    private getPaths;
+    loadState(): Promise<InstanceState>;
+    saveState(state: InstanceState): Promise<InstanceState>;
+    private ensureInstanceRoot;
+    private toAppFlags;
+    initialize(options?: InstanceOptions): Promise<InstanceInitResult>;
+    private installSkillPackage;
+    private upsertMcpServer;
+    getState(): Promise<InstanceState>;
+    updateState(partial: Partial<InstanceState>): Promise<InstanceState>;
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=instance-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance-service.d.ts","sourceRoot":"","sources":["../../src/services/instance-service.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { copyDir, pathExists, removeIfExists } from "../utils/fs.js";
+import { generateId } from "../utils/id.js";
+export class InstanceService {
+    constructor(sdk, instanceRoot, workspacePath) {
+        this.sdk = sdk;
+        this.instanceRoot = instanceRoot;
+        this.workspacePath = workspacePath;
+    }
+    getPaths() {
+        return {
+            instanceRoot: this.instanceRoot,
+            stateFile: path.join(this.instanceRoot, "instance-state.json"),
+            skillsDir: path.join(this.instanceRoot, "skills"),
+            mcpDir: path.join(this.instanceRoot, "mcp"),
+        };
+    }
+    async loadState() {
+        const paths = this.getPaths();
+        try {
+            const raw = await fs.readFile(paths.stateFile, "utf-8");
+            const parsed = JSON.parse(raw);
+            return parsed;
+        }
+        catch {
+            return {
+                initialized: false,
+                skills: [],
+                mcpServers: [],
+                enabledApps: [],
+                skillEnabled: true,
+                mcpEnabled: true,
+                updatedAt: null,
+            };
+        }
+    }
+    async saveState(state) {
+        const paths = this.getPaths();
+        state.updatedAt = new Date().toISOString();
+        await fs.mkdir(path.dirname(paths.stateFile), { recursive: true });
+        await fs.writeFile(paths.stateFile, JSON.stringify(state, null, 2), "utf-8");
+        return state;
+    }
+    async ensureInstanceRoot() {
+        await fs.mkdir(this.instanceRoot, { recursive: true });
+    }
+    toAppFlags(appIds) {
+        return {
+            claude: appIds.includes("claude"),
+            claudecode: appIds.includes("claudecode"),
+            codex: appIds.includes("codex"),
+            gemini: appIds.includes("gemini"),
+            opencode: appIds.includes("opencode"),
+            openclaw: appIds.includes("openclaw"),
+        };
+    }
+    async initialize(options = {}) {
+        await this.ensureInstanceRoot();
+        const paths = this.getPaths();
+        const enabledApps = options.enabledApps ?? ["claudecode", "opencode"];
+        const appFlags = this.toAppFlags(enabledApps);
+        const result = {
+            ok: true,
+            instanceId: generateId(),
+            workspacePath: this.workspacePath,
+            instanceRoot: this.instanceRoot,
+            enabledApps,
+            skill: {
+                enabled: options.skillEnabled ?? true,
+                packagePresent: false,
+            },
+            mcp: {
+                enabled: options.mcpEnabled ?? true,
+            },
+        };
+        const state = await this.loadState();
+        state.initialized = true;
+        state.enabledApps = enabledApps;
+        state.skillEnabled = result.skill.enabled;
+        state.mcpEnabled = result.mcp.enabled;
+        if (result.skill.enabled) {
+            await fs.mkdir(paths.skillsDir, { recursive: true });
+            const skillCandidates = Array.isArray(options.skillPackages) && options.skillPackages.length > 0
+                ? options.skillPackages
+                : options.skillPackage
+                    ? [options.skillPackage]
+                    : [];
+            const installedSkills = [];
+            for (const candidate of skillCandidates) {
+                const installed = await this.installSkillPackage(candidate, paths.skillsDir, appFlags);
+                if (installed) {
+                    installedSkills.push(installed);
+                }
+            }
+            if (installedSkills.length > 0) {
+                result.skill.packagePresent = true;
+                result.skill.installedCount = installedSkills.length;
+                result.skill.installed = installedSkills;
+                state.skills = installedSkills;
+            }
+        }
+        if (result.mcp.enabled) {
+            const mcpServers = Array.isArray(options.mcpServers)
+                ? options.mcpServers
+                : [];
+            const installedMcps = [];
+            for (const input of mcpServers) {
+                const server = await this.upsertMcpServer(input, appFlags);
+                if (server) {
+                    installedMcps.push(server);
+                }
+            }
+            if (installedMcps.length > 0) {
+                result.mcp.installedCount = installedMcps.length;
+                result.mcp.installed = installedMcps;
+                state.mcpServers = installedMcps;
+            }
+        }
+        await this.saveState(state);
+        return result;
+    }
+    async installSkillPackage(pkg, targetDir, apps) {
+        const sourceDir = pkg.localPath;
+        if (!sourceDir || !(await pathExists(sourceDir))) {
+            return null;
+        }
+        const skillName = pkg.skillName || path.basename(sourceDir).replace(/\.skill$/, "");
+        const skillId = generateId();
+        const targetSkillDir = path.join(targetDir, skillName);
+        await copyDir(sourceDir, targetSkillDir);
+        const installed = await this.sdk.installSkill({
+            sourceDir: targetSkillDir,
+            name: skillName,
+            apps,
+        });
+        return installed;
+    }
+    async upsertMcpServer(input, apps) {
+        const name = String(input.name || "").trim();
+        if (!name) {
+            return null;
+        }
+        const existingMcps = this.sdk.getAllMcpServers();
+        const existing = existingMcps.find((s) => s.name === name);
+        const serverSpec = {
+            type: input.transport || "stdio",
+            command: input.command,
+            url: input.url,
+            args: input.args,
+            env: input.env,
+        };
+        if (existing) {
+            return this.sdk.updateMcpServer(existing.id, {
+                name,
+                server: serverSpec,
+                apps,
+            });
+        }
+        return this.sdk.createMcpServer({
+            name,
+            server: serverSpec,
+            apps,
+        });
+    }
+    async getState() {
+        return this.loadState();
+    }
+    async updateState(partial) {
+        const state = await this.loadState();
+        Object.assign(state, partial);
+        return this.saveState(state);
+    }
+    async reset() {
+        const paths = this.getPaths();
+        await removeIfExists(paths.stateFile);
+        await removeIfExists(paths.skillsDir);
+        await removeIfExists(paths.mcpDir);
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { AppId, AppFlags, McpServer } from "../types.js";
+export interface CreateMcpInput {
+    name: string;
+    server: McpServer["server"];
+    description?: string;
+    apps?: Partial<AppFlags>;
+}
+export interface UpdateMcpInput {
+    name?: string;
+    server?: McpServer["server"];
+    description?: string;
+    apps?: Partial<AppFlags>;
+}
+export declare function buildMcpFromInput(input: CreateMcpInput): McpServer;
+export declare function mergeMcp(current: McpServer, patch: UpdateMcpInput): McpServer;
+export declare function applyMcpAppFlag(server: McpServer, appId: AppId, enabled: boolean): McpServer;
+//# sourceMappingURL=mcp-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-model.d.ts","sourceRoot":"","sources":["../../src/services/mcp-model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG9D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1B;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAQlE;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,cAAc,GAAG,SAAS,CAa7E;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,GACf,SAAS,CAQX"}

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

@@ -0,0 +1,34 @@
+import { normalizeAppFlags } from "../constants.js";
+import { createId } from "../utils/id.js";
+export function buildMcpFromInput(input) {
+    return {
+        id: createId("mcp"),
+        name: input.name,
+        server: input.server,
+        description: input.description,
+        apps: normalizeAppFlags(input.apps),
+    };
+}
+export function mergeMcp(current, patch) {
+    return {
+        ...current,
+        name: patch.name ?? current.name,
+        server: patch.server ?? current.server,
+        description: patch.description ?? current.description,
+        apps: patch.apps
+            ? {
+                ...current.apps,
+                ...normalizeAppFlags({ ...current.apps, ...patch.apps }),
+            }
+            : current.apps,
+    };
+}
+export function applyMcpAppFlag(server, appId, enabled) {
+    return {
+        ...server,
+        apps: {
+            ...server.apps,
+            [appId]: enabled,
+        },
+    };
+}