fraim 2.0.100

package/dist/src/cli/doctor/checks/mcp-connectivity-checks.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * MCP connectivity checks for FRAIM doctor command
+ * Tests FRAIM server connectivity and validates IDE MCP configurations
+ * Issue #144: Enhanced doctor command
+ */
+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.getMCPConnectivityChecks = getMCPConnectivityChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const axios_1 = __importDefault(require("axios"));
+const toml = __importStar(require("toml"));
+const ide_detector_1 = require("../../setup/ide-detector");
+/**
+ * Test FRAIM connectivity by calling fraim_connect
+ */
+async function testFraimConnectivity() {
+    try {
+        // Skip network calls in test environment
+        if (process.env.NODE_ENV === 'test') {
+            return {
+                status: 'passed',
+                message: 'FRAIM connectivity check skipped (test mode)',
+                details: {
+                    testMode: true,
+                    skipped: true
+                }
+            };
+        }
+        const globalConfigPath = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+        let apiKey;
+        try {
+            const config = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+            apiKey = config.apiKey || '';
+            if (!apiKey) {
+                return {
+                    status: 'error',
+                    message: 'FRAIM API key not found',
+                    suggestion: 'Add apiKey to ~/.fraim/config.json'
+                };
+            }
+            // Warn if using special bypass keys
+            if (apiKey === 'local-dev') {
+                return {
+                    status: 'warning',
+                    message: 'Using local-dev API key (bypasses validation)',
+                    suggestion: 'This key is for local development only. Get a real API key from https://fraim.wellnessatwork.me',
+                    details: {
+                        apiKey: 'local-dev',
+                        bypassMode: true
+                    }
+                };
+            }
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                message: 'Failed to read FRAIM config',
+                suggestion: 'Check ~/.fraim/config.json is valid JSON'
+            };
+        }
+        // Test connectivity by making a request to the FRAIM server
+        const startTime = Date.now();
+        const remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+        // Debug: Log what we're testing (helpful for troubleshooting)
+        if (process.env.DEBUG_DOCTOR) {
+            console.log('[DOCTOR DEBUG] Testing FRAIM connectivity:');
+            console.log('  URL:', remoteUrl);
+            console.log('  API Key:', apiKey.substring(0, 15) + '...');
+            console.log('  NODE_ENV:', process.env.NODE_ENV || 'not set');
+        }
+        // Warn if testing against localhost (might be in test mode)
+        if (remoteUrl.includes('localhost') || remoteUrl.includes('127.0.0.1')) {
+            return {
+                status: 'warning',
+                message: 'Testing against local server (may bypass validation)',
+                suggestion: 'Unset FRAIM_REMOTE_URL to test against production server',
+                details: {
+                    url: remoteUrl,
+                    localServer: true
+                }
+            };
+        }
+        // First, test with the correct API key
+        try {
+            const response = await axios_1.default.post(`${remoteUrl}/mcp`, {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/list',
+                params: {}
+            }, {
+                headers: {
+                    'x-api-key': apiKey,
+                    'Content-Type': 'application/json'
+                },
+                timeout: 5000
+            });
+            const latency = Date.now() - startTime;
+            if (response.status === 200 && response.data?.result) {
+                // Now verify that an invalid key would actually fail
+                // This ensures we're not in test mode where all keys are accepted
+                try {
+                    const invalidResponse = await axios_1.default.post(`${remoteUrl}/mcp`, {
+                        jsonrpc: '2.0',
+                        id: 1,
+                        method: 'tools/list',
+                        params: {}
+                    }, {
+                        headers: {
+                            'x-api-key': 'invalid-key-for-testing-' + Date.now(),
+                            'Content-Type': 'application/json'
+                        },
+                        timeout: 5000
+                    });
+                    // If invalid key succeeds, server is in test mode
+                    if (invalidResponse.status === 200 && invalidResponse.data?.result) {
+                        return {
+                            status: 'warning',
+                            message: `FRAIM server connected but not validating API keys (test mode?)`,
+                            suggestion: 'Server may be in test mode - API key validation is bypassed',
+                            details: {
+                                latency,
+                                url: remoteUrl,
+                                authenticated: false,
+                                testMode: true
+                            }
+                        };
+                    }
+                }
+                catch (invalidError) {
+                    // Good! Invalid key was rejected (401/403)
+                    if (invalidError.response?.status === 401 || invalidError.response?.status === 403) {
+                        return {
+                            status: 'passed',
+                            message: `FRAIM server connected and validating API keys (${latency}ms)`,
+                            details: {
+                                latency,
+                                url: remoteUrl,
+                                authenticated: true,
+                                validationWorking: true
+                            }
+                        };
+                    }
+                }
+                // If we get here, invalid key didn't fail with 401/403
+                return {
+                    status: 'passed',
+                    message: `FRAIM server connected (${latency}ms)`,
+                    details: {
+                        latency,
+                        url: remoteUrl,
+                        authenticated: true
+                    }
+                };
+            }
+            return {
+                status: 'error',
+                message: `FRAIM server returned unexpected response`,
+                suggestion: 'Check FRAIM server status'
+            };
+        }
+        catch (error) {
+            const latency = Date.now() - startTime;
+            if (error.response?.status === 401 || error.response?.status === 403) {
+                return {
+                    status: 'error',
+                    message: 'FRAIM API key is invalid',
+                    suggestion: 'Get a valid API key from https://fraim.wellnessatwork.me and update ~/.fraim/config.json',
+                    details: {
+                        statusCode: error.response?.status,
+                        responseData: error.response?.data
+                    }
+                };
+            }
+            if (error.code === 'ECONNREFUSED') {
+                return {
+                    status: 'error',
+                    message: 'Cannot connect to FRAIM server',
+                    suggestion: `Check network connection and server status: ${remoteUrl}`
+                };
+            }
+            if (error.code === 'ETIMEDOUT' || error.message.includes('timeout')) {
+                return {
+                    status: 'error',
+                    message: 'FRAIM server timeout',
+                    suggestion: 'Check network connection or try again later'
+                };
+            }
+            return {
+                status: 'error',
+                message: `FRAIM server error: ${error.message}`,
+                suggestion: 'Check network connection and FRAIM server status',
+                details: {
+                    error: error.message,
+                    code: error.code,
+                    statusCode: error.response?.status,
+                    latency
+                }
+            };
+        }
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            message: `Failed to test FRAIM connectivity: ${error.message}`,
+            suggestion: 'Check FRAIM configuration'
+        };
+    }
+}
+/**
+ * Validate IDE MCP configuration format
+ */
+async function validateIDEMCPConfig(ide) {
+    const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+    if (!fs_1.default.existsSync(configPath)) {
+        return {
+            status: 'warning',
+            message: `${ide.name} MCP config not found`,
+            suggestion: `Run: fraim add-ide --ide "${ide.name.toLowerCase()}"`,
+            details: { configPath }
+        };
+    }
+    try {
+        let servers = {};
+        // Parse based on format
+        if (ide.configFormat === 'toml') {
+            const content = fs_1.default.readFileSync(configPath, 'utf8');
+            const config = toml.parse(content);
+            servers = config.mcp_servers || {};
+            // Debug: Log what we found
+            if (process.env.DEBUG_DOCTOR) {
+                console.log(`[DOCTOR DEBUG] ${ide.name} TOML config:`, {
+                    configPath,
+                    hasConfig: !!config,
+                    hasMcpServers: !!config.mcp_servers,
+                    serverKeys: Object.keys(servers),
+                    hasFraim: !!servers['fraim']
+                });
+            }
+        }
+        else {
+            // JSON format
+            const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            // Get servers - prefer mcpServers if it has content, otherwise use servers
+            servers = config.mcpServers || {};
+            if (Object.keys(servers).length === 0 && config.servers) {
+                servers = config.servers;
+            }
+            // Debug: Log what we found
+            if (process.env.DEBUG_DOCTOR) {
+                console.log(`[DOCTOR DEBUG] ${ide.name} config:`, {
+                    configPath,
+                    hasConfig: !!config,
+                    hasMcpServers: !!config.mcpServers,
+                    hasServers: !!config.servers,
+                    mcpServersKeys: config.mcpServers ? Object.keys(config.mcpServers) : [],
+                    serversKeys: config.servers ? Object.keys(config.servers) : [],
+                    finalServerKeys: Object.keys(servers),
+                    hasFraim: !!servers['fraim']
+                });
+            }
+        }
+        // Check if FRAIM server is configured
+        const fraimServer = servers['fraim'];
+        if (!fraimServer) {
+            return {
+                status: 'warning',
+                message: `${ide.name} missing FRAIM MCP server`,
+                suggestion: `Run: fraim add-ide --ide "${ide.name.toLowerCase()}"`,
+                details: { configPath, serverKeys: Object.keys(servers) }
+            };
+        }
+        // Validate FRAIM server config format
+        if (!fraimServer.command && !fraimServer.url) {
+            return {
+                status: 'error',
+                message: `${ide.name} FRAIM server config invalid`,
+                suggestion: `FRAIM server must have 'command' or 'url' field`,
+                details: { configPath }
+            };
+        }
+        // Check for API key in env (for stdio servers)
+        if (fraimServer.command && !fraimServer.env?.FRAIM_API_KEY) {
+            return {
+                status: 'error',
+                message: `${ide.name} FRAIM server missing API key`,
+                suggestion: `Add FRAIM_API_KEY to env section in ${configPath}`,
+                details: { configPath }
+            };
+        }
+        // Check for auth header (for HTTP servers)
+        if (fraimServer.url) {
+            const hasAuth = fraimServer.headers?.Authorization || fraimServer.http_headers?.Authorization;
+            if (!hasAuth) {
+                return {
+                    status: 'error',
+                    message: `${ide.name} FRAIM server missing authorization`,
+                    suggestion: `Add Authorization header in ${configPath}`,
+                    details: { configPath }
+                };
+            }
+        }
+        return {
+            status: 'passed',
+            message: `${ide.name} MCP config valid`,
+            details: {
+                configPath,
+                serverCount: Object.keys(servers).length
+            }
+        };
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            message: `${ide.name} MCP config parse error`,
+            suggestion: `Fix ${ide.configFormat.toUpperCase()} syntax in ${configPath}`,
+            details: { configPath, error: error.message }
+        };
+    }
+}
+/**
+ * Get all MCP connectivity checks
+ */
+function getMCPConnectivityChecks() {
+    const checks = [];
+    // Check 1: Test FRAIM server connectivity with actual API key
+    checks.push({
+        name: 'FRAIM server connectivity',
+        category: 'mcpConnectivity',
+        critical: true,
+        run: testFraimConnectivity
+    });
+    // Check 2: Validate each installed IDE's MCP config
+    const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    for (const ide of installedIDEs) {
+        checks.push({
+            name: `${ide.name} MCP configuration`,
+            category: 'mcpConnectivity',
+            critical: false,
+            run: async () => validateIDEMCPConfig(ide)
+        });
+    }
+    return checks;
+}

package/dist/src/cli/doctor/checks/project-setup-checks.js

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * Project setup checks for FRAIM doctor command
+ * Validates project configuration and initialization
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectSetupChecks = getProjectSetupChecks;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const project_fraim_paths_1 = require("../../../core/utils/project-fraim-paths");
+/**
+ * Check if project is initialized
+ */
+function checkProjectInitialized() {
+    return {
+        name: 'Project initialized',
+        category: 'projectSetup',
+        critical: true,
+        run: async () => {
+            const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(process.cwd());
+            if ((0, project_fraim_paths_1.workspaceFraimExists)(process.cwd())) {
+                return {
+                    status: 'passed',
+                    message: 'Project initialized',
+                    details: { path: fraimDir }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Project not initialized',
+                suggestion: 'Initialize project with fraim init-project',
+                command: 'fraim init-project'
+            };
+        }
+    };
+}
+/**
+ * Check if project config is valid
+ */
+function checkProjectConfigValid() {
+    return {
+        name: 'Project config valid',
+        category: 'projectSetup',
+        critical: true,
+        run: async () => {
+            const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd());
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Project config missing',
+                    suggestion: 'Initialize project with fraim init-project',
+                    command: 'fraim init-project'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                if (!config.project || !config.project.name) {
+                    return {
+                        status: 'warning',
+                        message: 'Project config incomplete',
+                        suggestion: `Add project name to ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`
+                    };
+                }
+                return {
+                    status: 'passed',
+                    message: 'Project config valid',
+                    details: { projectName: config.project.name }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Project config corrupted',
+                    suggestion: `Fix JSON syntax in ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`,
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if git remote is detected
+ */
+function checkGitRemoteDetected() {
+    return {
+        name: 'Git remote detected',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            try {
+                const remote = (0, child_process_1.execSync)('git remote get-url origin', {
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                if (remote) {
+                    return {
+                        status: 'passed',
+                        message: `Git remote: ${remote}`,
+                        details: { remote }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No git remote configured',
+                    suggestion: 'Add git remote with: git remote add origin <url>'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'warning',
+                    message: 'Not a git repository',
+                    suggestion: 'Initialize git with: git init',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if repository provider matches config
+ */
+function checkProviderMatches() {
+    return {
+        name: 'Repository provider matches',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd());
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check provider - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                if (!config.repository?.provider) {
+                    return {
+                        status: 'passed',
+                        message: 'No repository provider configured (conversational mode)',
+                        details: { mode: config.mode || 'conversational' }
+                    };
+                }
+                // Try to get git remote
+                try {
+                    const remote = (0, child_process_1.execSync)('git remote get-url origin', {
+                        encoding: 'utf8',
+                        stdio: ['pipe', 'pipe', 'pipe']
+                    }).trim();
+                    const provider = config.repository.provider;
+                    const remoteMatches = remote.includes(provider);
+                    if (remoteMatches) {
+                        return {
+                            status: 'passed',
+                            message: `Repository provider: ${provider}`,
+                            details: { provider, remote }
+                        };
+                    }
+                    return {
+                        status: 'warning',
+                        message: `Provider mismatch: config says ${provider} but remote is ${remote}`,
+                        suggestion: `Update repository.provider in ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`
+                    };
+                }
+                catch {
+                    return {
+                        status: 'warning',
+                        message: 'Cannot verify provider - no git remote',
+                        details: { configuredProvider: config.repository.provider }
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check provider',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if config matches mode
+ */
+function checkConfigMatchesMode() {
+    return {
+        name: 'Config matches mode',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd());
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check mode - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                const mode = config.mode || 'conversational';
+                if (mode === 'conversational') {
+                    // No repository or issue tracking required
+                    return {
+                        status: 'passed',
+                        message: 'Conversational mode (no platform required)',
+                        details: { mode }
+                    };
+                }
+                if (mode === 'integrated') {
+                    // Repository required, issue tracking should match
+                    if (!config.repository?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Integrated mode requires repository configuration',
+                            suggestion: `Add repository config to ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`
+                        };
+                    }
+                    return {
+                        status: 'passed',
+                        message: 'Integrated mode configured',
+                        details: { mode, provider: config.repository.provider }
+                    };
+                }
+                if (mode === 'split') {
+                    // Both repository and issue tracking required
+                    if (!config.repository?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Split mode requires repository configuration',
+                            suggestion: `Add repository config to ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`
+                        };
+                    }
+                    if (!config.issueTracking?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Split mode requires issue tracking configuration',
+                            suggestion: `Add issueTracking config to ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`
+                        };
+                    }
+                    return {
+                        status: 'passed',
+                        message: 'Split mode configured',
+                        details: {
+                            mode,
+                            repository: config.repository.provider,
+                            issueTracking: config.issueTracking.provider
+                        }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `Unknown mode: ${mode}`,
+                    suggestion: 'Mode must be conversational, integrated, or split'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check mode configuration',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all project setup checks
+ */
+function getProjectSetupChecks() {
+    return [
+        checkProjectInitialized(),
+        checkProjectConfigValid(),
+        checkGitRemoteDetected(),
+        checkProviderMatches(),
+        checkConfigMatchesMode()
+    ];
+}