fraim 2.0.100

package/dist/src/cli/internal/device-flow-service.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceFlowService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+class DeviceFlowService {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Start the Device Flow Login
+     */
+    async login() {
+        console.log(chalk_1.default.blue('\n🔗 Starting Authentication...'));
+        try {
+            // 1. Request device and user codes
+            const deviceCode = await this.requestDeviceCode();
+            console.log(chalk_1.default.yellow('\nACTION REQUIRED:'));
+            console.log(`1. Go to: ${chalk_1.default.cyan.underline(deviceCode.verification_uri)}`);
+            console.log(`2. Enter the code: ${chalk_1.default.bold.green(deviceCode.user_code)}`);
+            console.log(chalk_1.default.gray(`\nWaiting for authorization (expires in ${Math.floor(deviceCode.expires_in / 60)} minutes)...`));
+            // 2. Poll for the access token
+            const token = await this.pollForToken(deviceCode.device_code, deviceCode.interval);
+            console.log(chalk_1.default.green('\n✅ Authentication Successful!'));
+            return token;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`\n❌ Authentication failed: ${error.message}`));
+            throw error;
+        }
+    }
+    async requestDeviceCode() {
+        const response = await axios_1.default.post(this.config.authUrl, {
+            client_id: this.config.clientId,
+            scope: this.config.scope
+        }, {
+            headers: { Accept: 'application/json' }
+        });
+        return response.data;
+    }
+    async pollForToken(deviceCode, interval) {
+        let currentInterval = interval * 1000;
+        return new Promise((resolve, reject) => {
+            const poll = async () => {
+                try {
+                    const response = await axios_1.default.post(this.config.tokenUrl, {
+                        client_id: this.config.clientId,
+                        device_code: deviceCode,
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code'
+                    }, {
+                        headers: { Accept: 'application/json' }
+                    });
+                    if (response.data.access_token) {
+                        resolve(response.data.access_token);
+                        return;
+                    }
+                    if (response.data.error) {
+                        const error = response.data.error;
+                        if (error === 'authorization_pending') {
+                            // Keep polling
+                            setTimeout(poll, currentInterval);
+                        }
+                        else if (error === 'slow_down') {
+                            currentInterval += 5000;
+                            setTimeout(poll, currentInterval);
+                        }
+                        else {
+                            reject(new Error(response.data.error_description || error));
+                        }
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            setTimeout(poll, currentInterval);
+        });
+    }
+}
+exports.DeviceFlowService = DeviceFlowService;

package/dist/src/cli/mcp/ide-formats.js

@@ -0,0 +1,243 @@
+"use strict";
+// IDE Format Adapters - transform logical server structure to IDE-specific formats
+// Uses the centralized registry to determine server types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDE_FORMATS = exports.CodexFormat = exports.WindsurfFormat = exports.ClaudeCodeFormat = exports.ClaudeFormat = exports.VSCodeFormat = exports.KiroFormat = exports.StandardFormat = void 0;
+exports.getIDEFormat = getIDEFormat;
+const mcp_server_registry_1 = require("./mcp-server-registry");
+const provider_registry_1 = require("../providers/provider-registry");
+// Standard format (Cursor, Kiro, Antigravity, etc.)
+class StandardFormat {
+    constructor() {
+        this.name = 'standard';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use serverUrl for standard format
+                mcpServers[key] = {
+                    serverUrl: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.StandardFormat = StandardFormat;
+// Kiro format (also used by Cursor)
+class KiroFormat {
+    constructor() {
+        this.name = 'kiro';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use url (not serverUrl)
+                mcpServers[key] = {
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.KiroFormat = KiroFormat;
+// VSCode format
+class VSCodeFormat {
+    constructor() {
+        this.name = 'vscode';
+    }
+    transform(servers) {
+        const vscodeServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server
+                vscodeServers[key] = {
+                    type: 'http',
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                vscodeServers[key] = {
+                    type: 'stdio',
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { servers: vscodeServers };
+    }
+}
+exports.VSCodeFormat = VSCodeFormat;
+// Claude Desktop format (excludes provider servers - Issue #132)
+class ClaudeFormat {
+    constructor() {
+        this.name = 'claude';
+    }
+    async transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            // Skip all provider servers - they break Claude Desktop
+            // See: https://github.com/mathursrus/FRAIM/issues/132
+            if (await (0, mcp_server_registry_1.isProviderServer)(key)) {
+                continue;
+            }
+            // Only include base servers (git, playwright, fraim)
+            mcpServers[key] = {
+                command: server.command,
+                ...(server.args && { args: server.args }),
+                ...(server.env && { env: server.env })
+            };
+        }
+        return { mcpServers };
+    }
+}
+exports.ClaudeFormat = ClaudeFormat;
+// Claude Code format (supports HTTP servers with VSCode-style format)
+class ClaudeCodeFormat {
+    constructor() {
+        this.name = 'claude-code';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use VSCode-style format
+                mcpServers[key] = {
+                    type: 'http',
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.ClaudeCodeFormat = ClaudeCodeFormat;
+// Windsurf format (uses server-fetch wrapper for HTTP servers)
+class WindsurfFormat {
+    constructor() {
+        this.name = 'windsurf';
+    }
+    async transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - wrap with server-fetch
+                const provider = await (0, provider_registry_1.getProvider)(key);
+                const tokenEnvVar = provider?.id ? `${provider.id.toUpperCase()}_TOKEN` : undefined;
+                if (tokenEnvVar && server.headers?.Authorization) {
+                    const token = server.headers.Authorization.replace('Bearer ', '');
+                    mcpServers[key] = {
+                        command: 'npx',
+                        args: ['-y', '@modelcontextprotocol/server-fetch', server.url],
+                        env: {
+                            [tokenEnvVar]: token
+                        }
+                    };
+                }
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.WindsurfFormat = WindsurfFormat;
+// Codex format (TOML)
+class CodexFormat {
+    constructor() {
+        this.name = 'codex';
+    }
+    transform(servers) {
+        const sections = [];
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server
+                const token = server.headers?.Authorization?.replace('Bearer ', '') || '';
+                const escapedToken = this.escapeToml(token);
+                const escapedUrl = this.escapeToml(server.url);
+                sections.push(`[mcp_servers.${key}]`);
+                sections.push(`url = "${escapedUrl}"`);
+                sections.push(`http_headers = { Authorization = "Bearer ${escapedToken}" }`);
+                sections.push('');
+            }
+            else {
+                // stdio server
+                sections.push(`[mcp_servers.${key}]`);
+                sections.push(`command = "${this.escapeToml(server.command || '')}"`);
+                if (server.args && server.args.length > 0) {
+                    const argsStr = server.args.map(arg => `"${this.escapeToml(arg)}"`).join(', ');
+                    sections.push(`args = [${argsStr}]`);
+                }
+                if (server.env) {
+                    sections.push('');
+                    sections.push(`[mcp_servers.${key}.env]`);
+                    for (const [envKey, envValue] of Object.entries(server.env)) {
+                        sections.push(`${envKey} = "${this.escapeToml(envValue)}"`);
+                    }
+                }
+                sections.push('');
+            }
+        }
+        return sections.join('\n');
+    }
+    escapeToml(value) {
+        return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    }
+}
+exports.CodexFormat = CodexFormat;
+// Format registry
+exports.IDE_FORMATS = {
+    standard: new StandardFormat(),
+    kiro: new KiroFormat(),
+    vscode: new VSCodeFormat(),
+    claude: new ClaudeFormat(),
+    'claude-code': new ClaudeCodeFormat(),
+    windsurf: new WindsurfFormat(),
+    codex: new CodexFormat()
+};
+function getIDEFormat(configType) {
+    const format = exports.IDE_FORMATS[configType];
+    if (!format) {
+        throw new Error(`Unsupported IDE format: ${configType}`);
+    }
+    return format;
+}

package/dist/src/cli/mcp/mcp-server-builder.js

@@ -0,0 +1,48 @@
+"use strict";
+// MCP Server Builder - builds logical server structure (format-agnostic)
+// Uses the centralized registry for all server definitions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServerBuilder = void 0;
+const mcp_server_registry_1 = require("./mcp-server-registry");
+class MCPServerBuilder {
+    constructor() {
+        this.servers = new Map();
+    }
+    addBaseServers(fraimKey) {
+        const baseServers = (0, mcp_server_registry_1.buildAllBaseServers)(fraimKey);
+        for (const [id, server] of baseServers) {
+            this.servers.set(id, server);
+        }
+        return this;
+    }
+    async addProvider(providerId, token, config) {
+        try {
+            const server = await (0, mcp_server_registry_1.buildProviderMCPServer)(providerId, token, config);
+            this.servers.set(providerId, server);
+        }
+        catch (error) {
+            // Always warn user when MCP server can't be built
+            // Common case: Jira without baseUrl/email config
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`⚠️  Skipping ${providerId} MCP server: ${errorMessage}`);
+        }
+        return this;
+    }
+    // Legacy methods for backward compatibility - delegate to addProvider
+    async addGitHub(token) {
+        return await this.addProvider('github', token);
+    }
+    async addGitLab(token) {
+        return await this.addProvider('gitlab', token);
+    }
+    async addJira(token, config) {
+        return await this.addProvider('jira', token, config);
+    }
+    getServers() {
+        return new Map(this.servers);
+    }
+    toObject() {
+        return Object.fromEntries(this.servers);
+    }
+}
+exports.MCPServerBuilder = MCPServerBuilder;

package/dist/src/cli/mcp/mcp-server-registry.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_MCP_SERVERS = void 0;
+exports.buildProviderMCPServer = buildProviderMCPServer;
+exports.getBaseMCPServer = getBaseMCPServer;
+exports.getProviderMCPServerIds = getProviderMCPServerIds;
+exports.getAllMCPServerIds = getAllMCPServerIds;
+exports.isProviderServer = isProviderServer;
+exports.isHTTPServer = isHTTPServer;
+exports.buildAllBaseServers = buildAllBaseServers;
+const provider_registry_1 = require("../providers/provider-registry");
+exports.BASE_MCP_SERVERS = [
+    {
+        id: 'git',
+        name: 'Git',
+        description: 'Git repository operations (commit, branch, merge, etc.)',
+        buildServer: () => ({
+            command: 'npx',
+            args: ['-y', '@cyanheads/git-mcp-server']
+        })
+    },
+    {
+        id: 'playwright',
+        name: 'Playwright',
+        description: 'Browser automation and testing',
+        buildServer: () => ({
+            command: 'npx',
+            args: ['-y', '@playwright/mcp']
+        })
+    },
+    {
+        id: 'fraim',
+        name: 'FRAIM',
+        description: 'FRAIM job orchestration and mentoring',
+        buildServer: (fraimKey) => ({
+            command: 'npx',
+            args: ['-y', 'fraim-framework@latest', 'mcp'],
+            env: {
+                // Include API key for IDE configs (Codex, VSCode, etc.)
+                // The stdio-server will use this if set, otherwise falls back to ~/.fraim/config.json
+                FRAIM_API_KEY: fraimKey,
+                FRAIM_REMOTE_URL: 'https://fraim.wellnessatwork.me'
+            }
+        })
+    }
+];
+// ============================================================================
+// PROVIDER MCP SERVER BUILDER (uses provider registry)
+// ============================================================================
+/**
+ * Build an MCP server for a provider using its definition from the registry
+ */
+async function buildProviderMCPServer(providerId, token, config) {
+    // Get provider definition from registry (server or local fallback)
+    const provider = await (0, provider_registry_1.getProvider)(providerId);
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    if (!provider.mcpServer) {
+        throw new Error(`Provider ${providerId} does not have an MCP server configuration`);
+    }
+    const mcpConfig = provider.mcpServer;
+    // Validate config if provider requires additional config
+    if (provider.hasAdditionalConfig) {
+        const validation = await (0, provider_registry_1.validateProviderConfig)(providerId, config || {});
+        if (!validation.valid) {
+            throw new Error(`${provider.displayName} requires additional configuration: ${validation.missing.join(', ')}`);
+        }
+    }
+    // Build MCP server based on type
+    if (mcpConfig.type === 'http') {
+        return buildHTTPServer(mcpConfig, token);
+    }
+    else {
+        return buildStdioServer(mcpConfig, token, config);
+    }
+}
+/**
+ * Build an HTTP MCP server
+ */
+function buildHTTPServer(mcpConfig, token) {
+    if (!mcpConfig.url) {
+        throw new Error('HTTP MCP server requires url');
+    }
+    const authHeader = mcpConfig.authHeaderTemplate?.replace('{token}', token) || `Bearer ${token}`;
+    return {
+        url: mcpConfig.url,
+        headers: {
+            Authorization: authHeader
+        }
+    };
+}
+/**
+ * Build a stdio MCP server
+ */
+function buildStdioServer(mcpConfig, token, config) {
+    if (!mcpConfig.command) {
+        throw new Error('Stdio MCP server requires command');
+    }
+    const resolveTemplate = (template) => {
+        let value = template.replace('{token}', token);
+        if (config) {
+            for (const [configKey, configValue] of Object.entries(config)) {
+                value = value.replace(`{config.${configKey}}`, String(configValue));
+            }
+        }
+        return value;
+    };
+    // Build environment variables from template
+    const env = {};
+    if (mcpConfig.envTemplate) {
+        for (const [key, template] of Object.entries(mcpConfig.envTemplate)) {
+            let value = resolveTemplate(template);
+            // Handle URL normalization for Jira
+            if (key === 'JIRA_URL' && value && !value.startsWith('http')) {
+                value = `https://${value}`;
+            }
+            env[key] = value;
+        }
+    }
+    return {
+        command: mcpConfig.command,
+        args: (mcpConfig.args || []).map(resolveTemplate),
+        env
+    };
+}
+// ============================================================================
+// REGISTRY LOOKUP FUNCTIONS
+// ============================================================================
+function getBaseMCPServer(id) {
+    return exports.BASE_MCP_SERVERS.find(server => server.id === id);
+}
+async function getProviderMCPServerIds() {
+    // This would need to fetch all providers and filter those with MCP servers
+    // For now, return empty array - this function is not critical
+    return [];
+}
+function getAllMCPServerIds() {
+    // Return only base server IDs
+    // Provider server IDs are dynamic and come from the registry
+    return exports.BASE_MCP_SERVERS.map(s => s.id);
+}
+async function isProviderServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider !== undefined && provider.mcpServer !== undefined;
+}
+async function isHTTPServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider?.mcpServer?.type === 'http';
+}
+// ============================================================================
+// BUILDER HELPERS
+// ============================================================================
+function buildAllBaseServers(fraimKey) {
+    const servers = new Map();
+    for (const def of exports.BASE_MCP_SERVERS) {
+        servers.set(def.id, def.buildServer(fraimKey));
+    }
+    return servers;
+}

package/dist/src/cli/mcp/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Shared types for MCP configuration
+Object.defineProperty(exports, "__esModule", { value: true });