fraim-hub 2.0.204

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/command-resolution.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveManagedCommand = exports.getSystemCommandPath = exports.getPortableNpxCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const getPortableNodeRoot = () => path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'node');
+const getPortableNpxCandidates = () => {
+    const nodeRoot = getPortableNodeRoot();
+    if (process.platform === 'win32') {
+        const candidates = [path_1.default.join(nodeRoot, 'npx.cmd')];
+        if (fs_1.default.existsSync(nodeRoot)) {
+            const extractedDirs = fs_1.default.readdirSync(nodeRoot, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('node-v'))
+                .sort((a, b) => b.name.localeCompare(a.name));
+            for (const entry of extractedDirs) {
+                candidates.push(path_1.default.join(nodeRoot, entry.name, 'npx.cmd'));
+            }
+        }
+        return candidates;
+    }
+    return [
+        path_1.default.join(nodeRoot, 'bin', 'npx'),
+        path_1.default.join(nodeRoot, 'npx')
+    ];
+};
+const getPortableNpxCommand = () => {
+    for (const candidate of getPortableNpxCandidates()) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
+exports.getPortableNpxCommand = getPortableNpxCommand;
+const getPathEntries = () => {
+    const rawPath = process.env.PATH || '';
+    return rawPath
+        .split(path_1.default.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+};
+const getSystemCommandCandidates = (command) => {
+    if (!command || path_1.default.isAbsolute(command)) {
+        return command ? [command] : [];
+    }
+    const commandNames = process.platform === 'win32'
+        ? command.includes('.')
+            ? [command]
+            : [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`, `${command}.com`]
+        : [command];
+    return getPathEntries().flatMap((entry) => commandNames.map((name) => path_1.default.join(entry, name)));
+};
+const getSystemCommandPath = (command) => {
+    for (const candidate of getSystemCommandCandidates(command)) {
+        try {
+            const stats = fs_1.default.statSync(candidate);
+            if (stats.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Ignore missing or inaccessible PATH entries and keep scanning.
+        }
+    }
+    return null;
+};
+exports.getSystemCommandPath = getSystemCommandPath;
+const resolveManagedCommand = (command) => {
+    if (command !== 'npx') {
+        return command;
+    }
+    // Prefer system-installed npx so we don't install our own Node when the
+    // machine already has one. Fall back to the FRAIM-managed portable copy
+    // only when no system npx is found. Last resort: bare command name.
+    return (0, exports.getSystemCommandPath)(command) || (0, exports.getPortableNpxCommand)() || command;
+};
+exports.resolveManagedCommand = resolveManagedCommand;

package/dist/src/cli/mcp/fraim-mcp-latest-launcher.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFraimMcpLatestLauncherPath = getFraimMcpLatestLauncherPath;
+exports.ensureFraimMcpLatestLauncher = ensureFraimMcpLatestLauncher;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const LAUNCHER_VERSION = 1;
+const launcherSource = `#!/usr/bin/env node
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const LAUNCHER_VERSION = ${LAUNCHER_VERSION};
+const USER_DIR = process.env.FRAIM_USER_DIR || path.join(os.homedir(), '.fraim');
+const STATE_DIR = path.join(USER_DIR, 'mcp-launcher');
+const STATE_PATH = path.join(STATE_DIR, 'latest.json');
+const CACHE_ROOT = path.join(USER_DIR, 'npm-cache', 'mcp');
+
+const commandName = (name) => process.platform === 'win32' ? name + '.cmd' : name;
+const npmCommand = commandName('npm');
+const npxCommand = commandName('npx');
+const cliArgs = process.argv.slice(2).length > 0 ? process.argv.slice(2) : ['mcp'];
+
+function quoteCmdArg(arg) {
+  const value = String(arg);
+  return /[\\s"&|<>^]/.test(value) ? '"' + value.replace(/"/g, '""') + '"' : value;
+}
+
+function runCommand(command, args, options) {
+  if (process.platform !== 'win32') {
+    return spawnSync(command, args, options);
+  }
+
+  return spawnSync(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', [command, ...args.map(quoteCmdArg)].join(' ')], options);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeState(state) {
+  ensureDir(STATE_DIR);
+  fs.writeFileSync(STATE_PATH, JSON.stringify({ ...state, launcherVersion: LAUNCHER_VERSION, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+function resolveLatest(packageName) {
+  const result = runCommand(npmCommand, ['view', packageName, 'version', '--silent'], {
+    encoding: 'utf8',
+    env: process.env
+  });
+
+  if (result.status !== 0) {
+    return null;
+  }
+
+  const version = String(result.stdout || '').trim();
+  return /^\\d+\\.\\d+\\.\\d+/.test(version) ? version : null;
+}
+
+function resolvePackage() {
+  const fraimVersion = resolveLatest('fraim');
+  if (fraimVersion) {
+    const state = { packageName: 'fraim', binName: 'fraim', version: fraimVersion, fromCache: false };
+    writeState(state);
+    return state;
+  }
+
+  const cached = readState();
+  if (cached && cached.packageName === 'fraim' && cached.binName === 'fraim' && cached.version) {
+    console.error('[fraim-mcp-launcher] Could not resolve npm latest; using cached fraim@' + cached.version + '.');
+    return { packageName: 'fraim', binName: 'fraim', version: cached.version, fromCache: true };
+  }
+
+  console.error('[fraim-mcp-launcher] Could not resolve fraim latest from npm and no cached fraim version exists.');
+  process.exit(1);
+}
+
+function runPackage(plan, cacheDir) {
+  ensureDir(cacheDir);
+  const env = { ...process.env, npm_config_cache: cacheDir };
+  const result = runCommand(npxCommand, ['--yes', '--package', plan.packageName + '@' + plan.version, plan.binName, ...cliArgs], {
+    stdio: 'inherit',
+    env
+  });
+  return typeof result.status === 'number' ? result.status : 1;
+}
+
+const plan = resolvePackage();
+const versionCacheDir = path.join(CACHE_ROOT, plan.packageName + '-' + plan.version.replace(/[^a-zA-Z0-9._-]/g, '_'));
+let status = runPackage(plan, versionCacheDir);
+
+if (status !== 0 && process.platform === 'win32') {
+  const retryCache = path.join(CACHE_ROOT, 'retry-' + Date.now() + '-' + process.pid);
+  console.error('[fraim-mcp-launcher] Package execution failed; retrying once with a fresh npm cache.');
+  status = runPackage(plan, retryCache);
+}
+
+process.exit(status);
+`;
+function getFraimMcpLatestLauncherPath() {
+    return path_1.default.join(process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim'), 'bin', 'fraim-mcp-latest.js');
+}
+function ensureFraimMcpLatestLauncher() {
+    const launcherPath = getFraimMcpLatestLauncherPath();
+    const launcherDir = path_1.default.dirname(launcherPath);
+    fs_1.default.mkdirSync(launcherDir, { recursive: true });
+    if (!fs_1.default.existsSync(launcherPath) || fs_1.default.readFileSync(launcherPath, 'utf8') !== launcherSource) {
+        fs_1.default.writeFileSync(launcherPath, launcherSource, 'utf8');
+        if (process.platform !== 'win32') {
+            try {
+                fs_1.default.chmodSync(launcherPath, 0o755);
+            }
+            catch {
+                // Best effort only. IDE configs invoke this through node, so chmod is not required.
+            }
+        }
+    }
+    return {
+        command: process.execPath,
+        args: [launcherPath],
+        path: launcherPath
+    };
+}

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

@@ -0,0 +1,317 @@
+"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.GrokFormat = exports.CodexFormat = exports.WindsurfFormat = exports.ClaudeCodeFormat = exports.ClaudeFormat = exports.CopilotCliFormat = exports.GeminiCliFormat = 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");
+const command_resolution_1 = require("./command-resolution");
+// 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;
+class GeminiCliFormat {
+    constructor() {
+        this.name = 'gemini-cli';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                mcpServers[key] = {
+                    ...(server.type === 'sse'
+                        ? { url: server.url }
+                        : { httpUrl: server.httpUrl || server.url }),
+                    ...(server.headers && { headers: server.headers })
+                };
+            }
+            else {
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.GeminiCliFormat = GeminiCliFormat;
+class CopilotCliFormat {
+    constructor() {
+        this.name = 'copilot-cli';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            // GitHub MCP is built into Copilot CLI. Avoid a duplicate user-configured
+            // github entry and let Copilot handle its native GitHub auth path.
+            if (key === 'github') {
+                continue;
+            }
+            if (server.url) {
+                mcpServers[key] = {
+                    type: server.type === 'sse' ? 'sse' : 'http',
+                    url: server.url,
+                    ...(server.headers && { headers: server.headers }),
+                    tools: ['*']
+                };
+            }
+            else {
+                mcpServers[key] = {
+                    type: 'stdio',
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env }),
+                    tools: ['*']
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.CopilotCliFormat = CopilotCliFormat;
+// 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: (0, command_resolution_1.resolveManagedCommand)('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 authHeader = server.headers?.Authorization;
+                const escapedUrl = this.escapeToml(server.url);
+                sections.push(`[mcp_servers.${key}]`);
+                sections.push(`url = "${escapedUrl}"`);
+                // OAuth-first providers (e.g. GitHub) have no Authorization header — IDE manages auth
+                if (authHeader) {
+                    sections.push(`http_headers = { Authorization = "${this.escapeToml(authHeader)}" }`);
+                }
+                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;
+class GrokFormat extends CodexFormat {
+    constructor() {
+        super(...arguments);
+        this.name = 'grok';
+    }
+}
+exports.GrokFormat = GrokFormat;
+// Format registry
+exports.IDE_FORMATS = {
+    standard: new StandardFormat(),
+    kiro: new KiroFormat(),
+    vscode: new VSCodeFormat(),
+    'gemini-cli': new GeminiCliFormat(),
+    'copilot-cli': new CopilotCliFormat(),
+    claude: new ClaudeFormat(),
+    'claude-code': new ClaudeCodeFormat(),
+    windsurf: new WindsurfFormat(),
+    codex: new CodexFormat(),
+    grok: new GrokFormat()
+};
+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;