fraim-framework 2.0.81 → 2.0.83

package/dist/src/cli/setup/mcp-config-generator.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateVSCodeMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateClaudeCodeMCPServers = exports.generateClaudeMCPServers = exports.generateStandardMCPServers = exports.mergeTomlMCPServers = exports.extractTomlMcpServerBlock = void 0;
-const GITHUB_MCP_URL = 'https://api.githubcopilot.com/mcp/';
-const GITLAB_MCP_URL = 'https://gitlab.com/api/v4/mcp';
+const mcp_server_builder_1 = require("../mcp/mcp-server-builder");
+const ide_formats_1 = require("../mcp/ide-formats");
 const normalizeTokens = (tokenInput) => {
     if (!tokenInput)
         return {};
@@ -11,7 +11,6 @@ const normalizeTokens = (tokenInput) => {
     }
     return tokenInput;
 };
-const escapeTomlString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 const findTomlServerBlockRange = (content, server) => {
     const lines = content.split(/\r?\n/);
     const serverSection = `mcp_servers.${server}`;
@@ -92,356 +91,100 @@ const mergeTomlMCPServers = (existingContent, generatedContent, servers) => {
     };
 };
 exports.mergeTomlMCPServers = mergeTomlMCPServers;
-const generateStandardMCPServers = (fraimKey, tokenInput, jiraConfig) => {
-    const tokens = normalizeTokens(tokenInput);
-    const servers = {
-        git: {
-            command: "npx",
-            args: ["-y", "@cyanheads/git-mcp-server"]
-        },
-        playwright: {
-            command: "npx",
-            args: ["-y", "@playwright/mcp"]
-        },
-        fraim: {
-            command: "fraim-mcp",
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: "https://fraim.wellnessatwork.me"
-            }
+// Helper function to add all provider servers with their configs
+const addProviderServers = async (builder, tokens, providerConfigs) => {
+    for (const [providerId, token] of Object.entries(tokens)) {
+        if (token) {
+            // Get provider-specific config if it exists
+            const config = providerConfigs?.[providerId];
+            await builder.addProvider(providerId, token, config);
         }
-    };
-    if (tokens.github) {
-        servers.github = {
-            serverUrl: GITHUB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.github}`
-            }
-        };
-    }
-    if (tokens.gitlab) {
-        servers.gitlab = {
-            serverUrl: GITLAB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.gitlab}`
-            }
-        };
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        servers.jira = {
-            command: "uvx",
-            args: ["mcp-atlassian"],
-            env: {
-                JIRA_URL: jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`,
-                JIRA_USERNAME: jiraConfig.email,
-                JIRA_API_TOKEN: tokens.jira
-            }
-        };
     }
-    return { mcpServers: servers };
+};
+const generateStandardMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    // Dynamically add provider servers based on available tokens
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('standard');
+    return format.transform(builder.getServers());
 };
 exports.generateStandardMCPServers = generateStandardMCPServers;
-const generateClaudeMCPServers = (fraimKey, tokenInput, jiraConfig) => {
-    const servers = {
-        git: {
-            command: "npx",
-            args: ["-y", "@cyanheads/git-mcp-server"]
-        },
-        playwright: {
-            command: "npx",
-            args: ["-y", "@playwright/mcp"]
-        },
-        fraim: {
-            command: "fraim-mcp",
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: "https://fraim.wellnessatwork.me"
-            }
-        }
-    };
+const generateClaudeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
     // Claude Desktop does not support HTTPS MCP servers (GitHub, GitLab, Jira)
     // These cause Claude Desktop to break on boot
     // See: https://github.com/mathursrus/FRAIM/issues/132
-    return { mcpServers: servers };
+    // The ClaudeFormat adapter will filter out HTTP servers
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude');
+    return format.transform(builder.getServers());
 };
 exports.generateClaudeMCPServers = generateClaudeMCPServers;
-const generateClaudeCodeMCPServers = (fraimKey, tokenInput, jiraConfig) => {
+const generateClaudeCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
     const tokens = normalizeTokens(tokenInput);
-    const servers = {
-        git: {
-            command: "npx",
-            args: ["-y", "@cyanheads/git-mcp-server"]
-        },
-        playwright: {
-            command: "npx",
-            args: ["-y", "@playwright/mcp"]
-        },
-        fraim: {
-            command: "fraim-mcp",
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: "https://fraim.wellnessatwork.me"
-            }
-        }
-    };
-    // Claude Code supports HTTPS MCP servers (uses same format as VSCode)
-    if (tokens.github) {
-        servers.github = {
-            type: "http",
-            url: GITHUB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.github}`
-            }
-        };
-    }
-    if (tokens.gitlab) {
-        servers.gitlab = {
-            type: "http",
-            url: GITLAB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.gitlab}`
-            }
-        };
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        servers.jira = {
-            command: "uvx",
-            args: ["mcp-atlassian"],
-            env: {
-                JIRA_URL: jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`,
-                JIRA_USERNAME: jiraConfig.email,
-                JIRA_API_TOKEN: tokens.jira
-            }
-        };
-    }
-    return { mcpServers: servers };
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude-code');
+    return format.transform(builder.getServers());
 };
 exports.generateClaudeCodeMCPServers = generateClaudeCodeMCPServers;
-const generateKiroMCPServers = (fraimKey, tokenInput, jiraConfig) => {
+const generateKiroMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
     const tokens = normalizeTokens(tokenInput);
-    const servers = {
-        git: {
-            command: "npx",
-            args: ["-y", "@cyanheads/git-mcp-server"]
-        },
-        playwright: {
-            command: "npx",
-            args: ["-y", "@playwright/mcp"]
-        },
-        fraim: {
-            command: "fraim-mcp",
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: "https://fraim.wellnessatwork.me"
-            }
-        }
-    };
-    if (tokens.github) {
-        servers.github = {
-            url: GITHUB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.github}`
-            }
-        };
-    }
-    if (tokens.gitlab) {
-        servers.gitlab = {
-            url: GITLAB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.gitlab}`
-            }
-        };
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        servers.jira = {
-            command: "uvx",
-            args: ["mcp-atlassian"],
-            env: {
-                JIRA_URL: jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`,
-                JIRA_USERNAME: jiraConfig.email,
-                JIRA_API_TOKEN: tokens.jira
-            }
-        };
-    }
-    return { mcpServers: servers };
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('kiro');
+    return format.transform(builder.getServers());
 };
 exports.generateKiroMCPServers = generateKiroMCPServers;
-const generateCodexMCPServers = (fraimKey, tokenInput, jiraConfig) => {
+const generateCodexMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
     const tokens = normalizeTokens(tokenInput);
-    const escapedFraimKey = escapeTomlString(fraimKey);
-    let config = `
-[mcp_servers.git]
-command = "npx"
-args = ["-y", "@cyanheads/git-mcp-server"]
-`;
-    if (tokens.github) {
-        const escapedGithubToken = escapeTomlString(tokens.github);
-        config += `
-[mcp_servers.github]
-url = "${GITHUB_MCP_URL}"
-http_headers = { Authorization = "Bearer ${escapedGithubToken}" }
-`;
-    }
-    if (tokens.gitlab) {
-        const escapedGitLabToken = escapeTomlString(tokens.gitlab);
-        config += `
-[mcp_servers.gitlab]
-url = "${GITLAB_MCP_URL}"
-http_headers = { Authorization = "Bearer ${escapedGitLabToken}" }
-`;
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        const escapedJiraToken = escapeTomlString(tokens.jira);
-        const escapedJiraUrl = escapeTomlString(jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`);
-        const escapedJiraEmail = escapeTomlString(jiraConfig.email);
-        config += `
-[mcp_servers.jira]
-command = "uvx"
-args = ["mcp-atlassian"]
-
-[mcp_servers.jira.env]
-JIRA_URL = "${escapedJiraUrl}"
-JIRA_USERNAME = "${escapedJiraEmail}"
-JIRA_API_TOKEN = "${escapedJiraToken}"
-`;
-    }
-    config += `
-[mcp_servers.playwright]
-command = "npx"
-args = ["-y", "@playwright/mcp"]
-
-[mcp_servers.fraim]
-command = "fraim-mcp"
-
-[mcp_servers.fraim.env]
-FRAIM_API_KEY = "${escapedFraimKey}"
-FRAIM_REMOTE_URL = "https://fraim.wellnessatwork.me"
-`;
-    return config;
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('codex');
+    return format.transform(builder.getServers());
 };
 exports.generateCodexMCPServers = generateCodexMCPServers;
-const generateVSCodeMCPServers = (fraimKey, tokenInput, jiraConfig) => {
+const generateVSCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
     const tokens = normalizeTokens(tokenInput);
-    const servers = {
-        git: {
-            type: 'stdio',
-            command: 'npx',
-            args: ['-y', '@cyanheads/git-mcp-server']
-        },
-        playwright: {
-            type: 'stdio',
-            command: 'npx',
-            args: ['-y', '@playwright/mcp']
-        },
-        fraim: {
-            type: 'stdio',
-            command: 'fraim-mcp',
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: 'https://fraim.wellnessatwork.me'
-            }
-        }
-    };
-    if (tokens.github) {
-        servers.github = {
-            type: 'http',
-            url: GITHUB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.github}`
-            }
-        };
-    }
-    if (tokens.gitlab) {
-        servers.gitlab = {
-            type: 'http',
-            url: GITLAB_MCP_URL,
-            headers: {
-                Authorization: `Bearer ${tokens.gitlab}`
-            }
-        };
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        servers.jira = {
-            type: 'stdio',
-            command: 'uvx',
-            args: ['mcp-atlassian'],
-            env: {
-                JIRA_URL: jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`,
-                JIRA_USERNAME: jiraConfig.email,
-                JIRA_API_TOKEN: tokens.jira
-            }
-        };
-    }
-    return { servers };
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('vscode');
+    return format.transform(builder.getServers());
 };
 exports.generateVSCodeMCPServers = generateVSCodeMCPServers;
-const generateWindsurfMCPServers = (fraimKey, tokenInput, jiraConfig) => {
+const generateWindsurfMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
     const tokens = normalizeTokens(tokenInput);
-    const servers = {
-        git: {
-            command: "npx",
-            args: ["-y", "@cyanheads/git-mcp-server"]
-        },
-        playwright: {
-            command: "npx",
-            args: ["-y", "@playwright/mcp"]
-        },
-        fraim: {
-            command: "fraim-mcp",
-            env: {
-                FRAIM_API_KEY: fraimKey,
-                FRAIM_REMOTE_URL: "https://fraim.wellnessatwork.me"
-            }
-        }
-    };
-    if (tokens.github) {
-        servers.github = {
-            command: "npx",
-            args: ["-y", "@modelcontextprotocol/server-fetch", GITHUB_MCP_URL],
-            env: {
-                GITHUB_TOKEN: tokens.github
-            }
-        };
-    }
-    if (tokens.gitlab) {
-        servers.gitlab = {
-            command: 'npx',
-            args: ['-y', '@modelcontextprotocol/server-fetch', GITLAB_MCP_URL],
-            env: {
-                GITLAB_TOKEN: tokens.gitlab
-            }
-        };
-    }
-    if (tokens.jira && jiraConfig?.baseUrl && jiraConfig?.email) {
-        servers.jira = {
-            command: 'uvx',
-            args: ['mcp-atlassian'],
-            env: {
-                JIRA_URL: jiraConfig.baseUrl.startsWith('http') ? jiraConfig.baseUrl : `https://${jiraConfig.baseUrl}`,
-                JIRA_USERNAME: jiraConfig.email,
-                JIRA_API_TOKEN: tokens.jira
-            }
-        };
-    }
-    return { mcpServers: servers };
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('windsurf');
+    return format.transform(builder.getServers());
 };
 exports.generateWindsurfMCPServers = generateWindsurfMCPServers;
-const generateMCPConfig = (configType, fraimKey, tokenInput, jiraConfig) => {
+const generateMCPConfig = async (configType, fraimKey, tokenInput, providerConfigs) => {
     switch (configType) {
         case 'standard':
-            return (0, exports.generateStandardMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateStandardMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'claude':
-            return (0, exports.generateClaudeMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateClaudeMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'claude-code':
-            return (0, exports.generateClaudeCodeMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateClaudeCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'kiro':
-            return (0, exports.generateKiroMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateKiroMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'vscode':
-            return (0, exports.generateVSCodeMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateVSCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'codex':
-            return (0, exports.generateCodexMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateCodexMCPServers)(fraimKey, tokenInput, providerConfigs);
         case 'windsurf':
-            return (0, exports.generateWindsurfMCPServers)(fraimKey, tokenInput, jiraConfig);
+            return await (0, exports.generateWindsurfMCPServers)(fraimKey, tokenInput, providerConfigs);
         default:
             throw new Error(`Unsupported config type: ${configType}`);
     }