fraim-hub 2.0.204

package/dist/src/cli/api/provider-client.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderClient = void 0;
+// CLI client for fetching provider metadata from server
+const axios_1 = __importDefault(require("axios"));
+class ProviderClient {
+    constructor(fraimKey, serverUrl) {
+        this.serverUrl = serverUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        this.client = axios_1.default.create({
+            baseURL: this.serverUrl,
+            headers: {
+                'x-api-key': fraimKey,
+                'Content-Type': 'application/json'
+            },
+            timeout: 10000 // 10 second timeout
+        });
+    }
+    /**
+     * Get all providers from server
+     */
+    async getAllProviders() {
+        try {
+            const response = await this.client.get('/api/providers');
+            return response.data.providers;
+        }
+        catch (error) {
+            if (error.response) {
+                // Server responded with error status
+                throw new Error(`Failed to fetch providers: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+            }
+            else if (error.request) {
+                // Request was made but no response
+                throw new Error(`Failed to fetch providers: No response from server`);
+            }
+            else {
+                // Something else happened
+                throw new Error(`Failed to fetch providers: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Get a specific provider by ID
+     */
+    async getProvider(id) {
+        const providers = await this.getAllProviders();
+        return providers.find(p => p.id === id) || null;
+    }
+    /**
+     * Get provider config schema
+     */
+    async getProviderSchema(id) {
+        try {
+            const response = await this.client.get(`/api/providers/${id}/schema`);
+            return response.data;
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new Error(`Provider '${id}' not found`);
+            }
+            throw new Error(`Failed to fetch provider schema: ${error.message}`);
+        }
+    }
+    /**
+     * Validate provider config
+     */
+    async validateProviderConfig(id, config) {
+        try {
+            const response = await this.client.post(`/api/providers/${id}/validate`, config);
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to validate provider config: ${error.message}`);
+        }
+    }
+    /**
+     * Get all provider IDs
+     */
+    async getAllProviderIds() {
+        const providers = await this.getAllProviders();
+        return providers.map(p => p.id);
+    }
+    /**
+     * Get providers with a specific capability
+     */
+    async getProvidersWithCapability(capability) {
+        const providers = await this.getAllProviders();
+        return providers.filter(p => p.capabilities.includes(capability));
+    }
+    /**
+     * Check if a provider has a specific capability
+     */
+    async providerHasCapability(providerId, capability) {
+        const provider = await this.getProvider(providerId);
+        return provider ? provider.capabilities.includes(capability) : false;
+    }
+    /**
+     * Check if provider requires additional config
+     */
+    async requiresAdditionalConfig(providerId) {
+        const provider = await this.getProvider(providerId);
+        return provider?.hasAdditionalConfig || false;
+    }
+}
+exports.ProviderClient = ProviderClient;

package/dist/src/cli/commands/add-ide.js

@@ -0,0 +1,462 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveProviderTokenToConfig = exports.loadGlobalConfig = exports.addIDECommand = exports.runAddIDE = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ide_detector_1 = require("../setup/ide-detector");
+const mcp_config_generator_1 = require("../setup/mcp-config-generator");
+const codex_local_config_1 = require("../setup/codex-local-config");
+const claude_code_telemetry_1 = require("../setup/claude-code-telemetry");
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+const mcp_server_registry_1 = require("../mcp/mcp-server-registry");
+const get_provider_client_1 = require("../api/get-provider-client");
+const provider_prompts_1 = require("../setup/provider-prompts");
+const provider_registry_1 = require("../providers/provider-registry");
+const user_config_1 = require("../utils/user-config");
+const loadGlobalConfig = async () => {
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    if (!fs_1.default.existsSync(globalConfigPath)) {
+        return null;
+    }
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+        // Support both old and new token format
+        const tokens = config.tokens || {};
+        // Backward compatibility: map old format to new
+        // Only try to fetch provider IDs if we have a valid FRAIM key
+        if (config.apiKey) {
+            try {
+                const client = (0, get_provider_client_1.getProviderClient)();
+                const providerIds = await client.getAllProviderIds();
+                for (const id of providerIds) {
+                    const oldKey = `${id}Token`;
+                    if (config[oldKey] && !tokens[id]) {
+                        tokens[id] = config[oldKey];
+                    }
+                }
+            }
+            catch (e) {
+                // If provider client fails (network error, invalid key, etc.), 
+                // skip backward compatibility mapping and use local fallback
+                // This is fine - the config will still work with the new format
+            }
+        }
+        // Load all provider configs
+        const providerConfigs = {};
+        // New format: providerConfigs object
+        if (config.providerConfigs) {
+            Object.entries(config.providerConfigs).forEach(([key, value]) => {
+                const providerId = key.replace('Config', '');
+                providerConfigs[providerId] = value;
+            });
+        }
+        return {
+            fraimKey: config.apiKey,
+            tokens,
+            mode: config.mode,
+            providerConfigs
+        };
+    }
+    catch (e) {
+        return null;
+    }
+};
+exports.loadGlobalConfig = loadGlobalConfig;
+const promptForProviderTokenIfNeeded = async (providerId, isOptional = false) => {
+    const client = (0, get_provider_client_1.getProviderClient)();
+    const provider = await client.getProvider(providerId);
+    if (!provider)
+        return '';
+    if (isOptional) {
+        console.log(chalk_1.default.yellow(`\n🔑 ${provider.displayName} token (optional for conversational mode)`));
+        console.log(chalk_1.default.gray(`${provider.displayName} token enables ${provider.displayName}-specific MCP features.\n`));
+        const wantsToken = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'addToken',
+            message: `Do you want to add a ${provider.displayName} token?`,
+            initial: false
+        });
+        if (!wantsToken.addToken) {
+            console.log(chalk_1.default.blue(`ℹ️  Skipping ${provider.displayName} token - ${provider.displayName} MCP server will not be configured`));
+            return '';
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow(`\n🔑 ${provider.displayName} token needed for MCP configuration`));
+        console.log(chalk_1.default.gray(`This is required for ${provider.displayName} MCP servers to function properly.\n`));
+    }
+    try {
+        return await (0, provider_prompts_1.promptForProviderToken)(client, providerId);
+    }
+    catch (error) {
+        if (isOptional) {
+            console.log(chalk_1.default.blue(`ℹ️  No ${provider.displayName} token provided - ${provider.displayName} MCP server will not be configured`));
+            return '';
+        }
+        console.log(chalk_1.default.red(`${provider.displayName} token is required. Exiting.`));
+        process.exit(1);
+    }
+};
+const saveProviderTokenToConfig = async (providerId, token) => {
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    if (fs_1.default.existsSync(globalConfigPath)) {
+        try {
+            const config = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+            // Use new tokens structure
+            if (!config.tokens) {
+                config.tokens = {};
+            }
+            config.tokens[providerId] = token;
+            fs_1.default.writeFileSync(globalConfigPath, JSON.stringify(config, null, 2));
+            const { getProvider } = await Promise.resolve().then(() => __importStar(require('../providers/provider-registry')));
+            const provider = await getProvider(providerId);
+            console.log(chalk_1.default.green(`✅ ${provider?.displayName || providerId} token saved to global config`));
+        }
+        catch (e) {
+            const { getProvider } = await Promise.resolve().then(() => __importStar(require('../providers/provider-registry')));
+            const provider = await getProvider(providerId);
+            console.log(chalk_1.default.yellow(`⚠️ Could not save ${provider?.displayName || providerId} token to config`));
+        }
+    }
+};
+exports.saveProviderTokenToConfig = saveProviderTokenToConfig;
+const configureIDEMCP = async (ide, fraimKey, tokens, providerConfigs) => {
+    const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+    console.log(chalk_1.default.blue(`🔧 Configuring ${ide.name}...`));
+    // Create backup if config exists
+    if (fs_1.default.existsSync(configPath)) {
+        const backupPath = `${configPath}.fraim-backup-${Date.now()}`;
+        fs_1.default.copyFileSync(configPath, backupPath);
+        console.log(chalk_1.default.gray(`  📁 Backup created: ${backupPath}`));
+    }
+    // Ensure directory exists
+    const configDir = path_1.default.dirname(configPath);
+    if (!fs_1.default.existsSync(configDir)) {
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+        console.log(chalk_1.default.gray(`  📁 Created directory: ${configDir}`));
+    }
+    let existingConfig = {};
+    let existingMCPServers = {};
+    const serversKey = ide.configType === 'vscode' ? 'servers' : 'mcpServers';
+    if (fs_1.default.existsSync(configPath) && ide.configFormat === 'json') {
+        try {
+            existingConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            existingMCPServers = existingConfig[serversKey] || {};
+            console.log(chalk_1.default.gray(`  📋 Found existing config with ${Object.keys(existingMCPServers).length} MCP servers`));
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`  ⚠️ Could not parse existing ${ide.name} config, creating new one`));
+        }
+    }
+    if (ide.configFormat === 'toml') {
+        // Handle TOML format (e.g., Codex)
+        let existingTomlContent = '';
+        if (fs_1.default.existsSync(configPath)) {
+            existingTomlContent = fs_1.default.readFileSync(configPath, 'utf8');
+            console.log(chalk_1.default.gray(`  📋 Found existing TOML config`));
+        }
+        const newTomlContent = await (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens, providerConfigs);
+        const { getAllMCPServerIds } = await Promise.resolve().then(() => __importStar(require('../mcp/mcp-server-registry')));
+        const baseServerIds = getAllMCPServerIds();
+        // Add provider server IDs from tokens
+        const providerServerIds = Object.keys(tokens).filter(id => tokens[id]);
+        const serversToAdd = [...baseServerIds, ...providerServerIds];
+        const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingTomlContent, newTomlContent, serversToAdd);
+        fs_1.default.writeFileSync(configPath, mergeResult.content);
+        mergeResult.addedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Added ${server} MCP server`));
+        });
+        mergeResult.replacedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Updated ${server} MCP server`));
+        });
+        mergeResult.skippedServers.forEach(server => {
+            console.log(chalk_1.default.gray(`  ⏭️ Skipped ${server} (already configured or not requested)`));
+        });
+    }
+    else {
+        // For JSON configs - intelligent merging
+        const newConfig = await (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens, providerConfigs);
+        const newMCPServers = newConfig[serversKey] || newConfig.mcpServers || {};
+        // Merge MCP servers intelligently
+        const mergedMCPServers = { ...existingMCPServers };
+        const addedServers = [];
+        const updatedServers = [];
+        const skippedServers = [];
+        const alwaysUpdateServers = new Set(['fraim', 'github', 'gitlab', 'jira', 'ado', 'linear']);
+        for (const [serverName, serverConfig] of Object.entries(newMCPServers)) {
+            if (!existingMCPServers[serverName]) {
+                mergedMCPServers[serverName] = serverConfig;
+                addedServers.push(serverName);
+            }
+            else if (alwaysUpdateServers.has(serverName)) {
+                mergedMCPServers[serverName] = serverConfig;
+                updatedServers.push(serverName);
+            }
+            else {
+                skippedServers.push(serverName);
+            }
+        }
+        // Merge with existing config
+        const mergedConfig = {
+            ...existingConfig,
+            ...newConfig,
+            [serversKey]: mergedMCPServers
+        };
+        // Write updated config
+        fs_1.default.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
+        addedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Added ${server} MCP server`));
+        });
+        updatedServers.forEach(server => {
+            console.log(chalk_1.default.blue(`  Updated ${server} MCP server`));
+        });
+        skippedServers.forEach(server => {
+            console.log(chalk_1.default.gray(`  ⏭️ Skipped ${server} (already exists)`));
+        });
+    }
+    console.log(chalk_1.default.green(`✅ Updated ${configPath}`));
+    // Handle IDE-specific local config (e.g., Codex needs project-level config)
+    if (ide.configType === 'codex') {
+        const localResult = (0, codex_local_config_1.ensureCodexLocalConfig)(process.cwd());
+        const status = localResult.created ? 'Created' : localResult.updated ? 'Updated' : 'Verified';
+        console.log(chalk_1.default.green(`  ✅ ${status} local ${ide.name} config: ${localResult.path}`));
+    }
+    // Enable token telemetry for Claude Code via project-level settings
+    if (ide.configType === 'claude-code') {
+        (0, claude_code_telemetry_1.ensureClaudeCodeTelemetryEnv)();
+    }
+};
+const listSupportedIDEs = () => {
+    const allIDEs = (0, ide_detector_1.getAllSupportedIDEs)();
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    console.log(chalk_1.default.blue('📋 Supported IDEs:\n'));
+    allIDEs.forEach(ide => {
+        const isDetected = detectedIDEs.some(detected => detected.name === ide.name);
+        const statusIcon = isDetected ? '✅' : '❌';
+        const statusText = isDetected ? 'detected' : 'not found';
+        console.log(chalk_1.default.white(`   ${statusIcon} ${ide.name} (${statusText})`));
+        console.log(chalk_1.default.gray(`      ${ide.description}`));
+        console.log(chalk_1.default.gray(`      Config: ${ide.configPath}\n`));
+    });
+    console.log(chalk_1.default.yellow('💡 Use "fraim add-ide --ide <name>" to configure a specific IDE'));
+    console.log(chalk_1.default.yellow('   Example: fraim add-ide --ide claude-code'));
+    console.log(chalk_1.default.yellow('   Anthropic aliases: claude, claude-code, claude-desktop, claude-cowork'));
+    console.log(chalk_1.default.yellow('   Gemini aliases: gemini, gemini-cli, gemini cli'));
+    console.log(chalk_1.default.yellow('   GitHub Copilot CLI aliases: copilot, copilot-cli, github copilot cli'));
+};
+const promptForIDESelection = async (availableIDEs, tokens) => {
+    console.log(chalk_1.default.green(`✅ Found ${availableIDEs.length} IDEs that can be configured:\n`));
+    availableIDEs.forEach((ide, index) => {
+        const configExists = fs_1.default.existsSync((0, ide_detector_1.expandPath)(ide.configPath));
+        const statusIcon = configExists ? '📝' : '📄';
+        const statusText = configExists ? 'has config' : 'new config';
+        console.log(chalk_1.default.white(`   ${index + 1}. ${ide.name} ${statusIcon} (${statusText})`));
+    });
+    console.log(chalk_1.default.blue('\nFRAIM will add these MCP servers:'));
+    // Show base servers
+    for (const server of mcp_server_registry_1.BASE_MCP_SERVERS) {
+        console.log(chalk_1.default.gray(`   • ${server.id} (${server.description})`));
+    }
+    // Show provider servers (only if tokens exist)
+    const allProviders = await (0, provider_registry_1.getAllProviders)();
+    for (const provider of allProviders) {
+        const hasToken = tokens?.[provider.id];
+        if (hasToken && provider.mcpServer) {
+            console.log(chalk_1.default.gray(`   - ${provider.id} (${provider.description})`));
+        }
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'selection',
+        message: 'Configure which IDEs? (Enter \'all\' or numbers like \'1,3\')',
+        initial: 'all',
+        validate: (value) => {
+            if (value.toLowerCase() === 'all')
+                return true;
+            if (value.toLowerCase() === 'none')
+                return true;
+            const numbers = value.split(',').map(n => parseInt(n.trim()));
+            const valid = numbers.every(n => n >= 1 && n <= availableIDEs.length && !isNaN(n));
+            return valid || 'Please enter "all", "none", or valid numbers (e.g., "1,3")';
+        }
+    });
+    if (response.selection.toLowerCase() === 'all') {
+        return availableIDEs;
+    }
+    if (response.selection.toLowerCase() === 'none') {
+        return [];
+    }
+    const selectedIndices = response.selection.split(',').map((n) => parseInt(n.trim()) - 1);
+    return selectedIndices.map((i) => availableIDEs[i]).filter(Boolean);
+};
+const runAddIDE = async (options) => {
+    if (options.list) {
+        listSupportedIDEs();
+        return;
+    }
+    console.log(chalk_1.default.blue('🔧 FRAIM IDE Configuration\n'));
+    // Load existing configuration
+    const globalConfig = await loadGlobalConfig();
+    if (!globalConfig || !globalConfig.fraimKey) {
+        console.log(chalk_1.default.red('❌ No FRAIM configuration found.'));
+        console.log(chalk_1.default.yellow('💡 Please run "fraim setup" first to configure your FRAIM keys.'));
+        process.exit(1);
+    }
+    const platformTokens = globalConfig.tokens || {};
+    const isConversationalMode = globalConfig.mode === 'conversational';
+    // Check if any provider tokens exist
+    const allProviderIds = await (0, provider_registry_1.getAllProviderIds)();
+    const hasAnyToken = allProviderIds.some(id => platformTokens[id]);
+    if (!hasAnyToken && !isConversationalMode && !options.skipTokenPrompts) {
+        console.log(chalk_1.default.yellow('⚠️ No provider tokens found in configuration.'));
+        // Prompt for first integrated provider as default
+        const integratedProviders = await (0, provider_registry_1.getProvidersWithCapability)('integrated');
+        const defaultProviderId = integratedProviders[0]?.id;
+        if (defaultProviderId) {
+            const token = await promptForProviderTokenIfNeeded(defaultProviderId, false);
+            if (token) {
+                await saveProviderTokenToConfig(defaultProviderId, token);
+                platformTokens[defaultProviderId] = token;
+            }
+        }
+    }
+    if (isConversationalMode && !hasAnyToken) {
+        console.log(chalk_1.default.blue('ℹ️  Conversational mode: Configuring MCP without platform integration\n'));
+    }
+    else {
+        console.log(chalk_1.default.green('✅ Using existing FRAIM configuration\n'));
+    }
+    let idesToConfigure;
+    if (options.ide) {
+        // Explicit IDE requested: configure it regardless of whether it is
+        // currently detected.  Use the detected path if available (may differ
+        // from the default), otherwise fall back to the default so the config
+        // can be pre-staged before the IDE is installed.
+        const requestedIDE = (0, ide_detector_1.findIDEByName)(options.ide);
+        if (!requestedIDE) {
+            console.log(chalk_1.default.red(`❌ IDE "${options.ide}" not supported.`));
+            console.log(chalk_1.default.yellow('💡 Use "fraim add-ide --list" to see supported IDEs.'));
+            return;
+        }
+        const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+        const detectedIDE = detectedIDEs.find(ide => ide.name === requestedIDE.name);
+        idesToConfigure = [detectedIDE || requestedIDE];
+    }
+    else {
+        // Auto-detect or interactive selection.
+        const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+        if (detectedIDEs.length === 0) {
+            console.log(chalk_1.default.yellow('⚠️ No supported IDEs detected on your system.'));
+            console.log(chalk_1.default.gray('Supported IDEs: Claude, Claude Code, Antigravity, Gemini CLI, GitHub Copilot CLI, Kiro, Cursor, VSCode, Codex, Grok, Windsurf'));
+            console.log(chalk_1.default.blue('\n💡 Install an IDE and run this command again.'));
+            return;
+        }
+        if (options.all) {
+            // Configure all detected IDEs
+            idesToConfigure = detectedIDEs;
+        }
+        else {
+            // Interactive selection
+            idesToConfigure = await promptForIDESelection(detectedIDEs, platformTokens);
+        }
+    }
+    if (idesToConfigure.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️ No IDEs selected for configuration.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`\n🚀 Configuring ${idesToConfigure.length} IDE(s)...\n`));
+    const results = {
+        successful: [],
+        failed: []
+    };
+    for (const ide of idesToConfigure) {
+        try {
+            await configureIDEMCP(ide, globalConfig.fraimKey, platformTokens, globalConfig.providerConfigs);
+            results.successful.push(ide.name);
+            (0, user_config_1.addInstalledIde)((0, ide_detector_1.getAdapterConfigType)(ide));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            results.failed.push({ ide: ide.name, error: errorMessage });
+            console.log(chalk_1.default.red(`❌ Failed to configure ${ide.name}: ${errorMessage}`));
+        }
+    }
+    // Summary
+    console.log(chalk_1.default.green(`\n🎉 Configuration Complete:`));
+    if (results.successful.length > 0) {
+        console.log(chalk_1.default.green(`   ✅ Successfully configured: ${results.successful.length} IDE(s)`));
+        results.successful.forEach(ide => {
+            console.log(chalk_1.default.green(`      • ${ide}`));
+        });
+    }
+    if (results.failed.length > 0) {
+        console.log(chalk_1.default.red(`   ❌ Failed to configure: ${results.failed.length} IDE(s)`));
+        results.failed.forEach(({ ide, error }) => {
+            console.log(chalk_1.default.red(`      • ${ide}: ${error}`));
+        });
+    }
+    if (results.successful.length > 0) {
+        const { installSlashCommands, installGlobalRules, describeConfiguredInvocationSurfaces } = await Promise.resolve().then(() => __importStar(require('../setup/ide-global-integration')));
+        try {
+            await installSlashCommands();
+            await installGlobalRules();
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`⚠️  IDE surface installation encountered issues: ${e.message}`));
+        }
+        const successfulIDEs = idesToConfigure.filter(ide => results.successful.includes(ide.name));
+        const invocationSummaries = describeConfiguredInvocationSurfaces(successfulIDEs);
+        console.log(chalk_1.default.blue('\n🔄 Next steps:'));
+        console.log(chalk_1.default.cyan('   1. Restart your configured IDEs'));
+        invocationSummaries.forEach((summary, index) => {
+            console.log(chalk_1.default.cyan(`   ${index + 2}. ${summary}`));
+        });
+        console.log(chalk_1.default.blue('\n💡 Use "fraim doctor --test-mcp" to verify the configuration.'));
+    }
+};
+exports.runAddIDE = runAddIDE;
+exports.addIDECommand = new commander_1.Command('add-ide')
+    .description('Add FRAIM configuration to additional IDEs')
+    .option('--ide <name>', 'Configure specific IDE (claude, claude-code, claude-desktop, claude-cowork, antigravity, gemini, gemini-cli, copilot, copilot-cli, kiro, cursor, vscode, codex, grok, windsurf)')
+    .option('--all', 'Configure all detected IDEs')
+    .option('--list', 'List all supported IDEs and their detection status')
+    .action(exports.runAddIDE);

package/dist/src/cli/fraim-hub.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFraimHubProgram = createFraimHubProgram;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../ai-hub/cli");
+function readPackageVersion() {
+    try {
+        let currentDir = __dirname;
+        for (let i = 0; i < 5; i++) {
+            const pkgPath = path_1.default.join(currentDir, 'package.json');
+            if (fs_1.default.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                return pkg.version || 'unknown';
+            }
+            currentDir = path_1.default.dirname(currentDir);
+        }
+    }
+    catch {
+        // Fall through to unknown.
+    }
+    return 'unknown';
+}
+function createFraimHubProgram(action = cli_1.runHub) {
+    const program = new commander_1.Command();
+    program
+        .name('fraim-hub')
+        .description('Start the FRAIM Hub local companion')
+        .version(readPackageVersion())
+        .option('--port <port>', 'Preferred local port for the hub', (value) => Number(value), 43091)
+        .option('--project-path <path>', 'Initial project path for job discovery', process.cwd())
+        .option('--no-open', 'Do not open the hub after startup')
+        .option('--browser', 'Open in the default browser instead of the desktop shell')
+        .option('--restart', 'Replace any running Hub instance with this build (even at the same version)')
+        .option('--keep-running', 'Do not replace a running Hub; keep single-instance focus (default replaces only an older/stale instance)')
+        .allowExcessArguments(false)
+        .action(action);
+    return program;
+}
+if (require.main === module) {
+    createFraimHubProgram().parseAsync(process.argv).catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}