@tostudy-ai/mcp-setup 1.0.0

package/dist/__tests__/e2e-diagnostic-repair-flow.test.js

@@ -0,0 +1,720 @@
+/**
+ * E2E Test: Diagnostic and Repair Flow
+ *
+ * This test verifies the end-to-end diagnostic and repair flow:
+ * 1. Simulate common issues (port conflict, missing config, invalid JSON, etc.)
+ * 2. Run mcp-setup diagnose command
+ * 3. Verify issue detected with clear description
+ * 4. Run mcp-setup repair command
+ * 5. Verify issue fixed and MCP configuration is valid
+ *
+ * NOTE: Port conflict tests require elevated permissions on some systems.
+ * Run with: npx tsx src/__tests__/e2e-diagnostic-repair-flow.test.ts
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { platform, tmpdir } from 'node:os';
+import { createServer } from 'node:net';
+// Import the modules we're testing
+import { getClaudeConfigPath, readClaudeConfig, writeClaudeConfig, addTostudyMcpServer, isTostudyMcpConfigured, getTostudyMcpConfig, } from '../config.js';
+import { runDiagnostics } from '../diagnose.js';
+import { repairAllIssues, repairIssue, diagnoseAndRepair, issueRequiresUserInput, } from '../repair.js';
+// Test constants
+const TEST_API_KEY = 'test-diagnostic-repair-api-key-12345678901234567890';
+const TEST_PLATFORM_URL = 'https://tostudy.com';
+const DEFAULT_MCP_PORT = 3701;
+const results = [];
+const context = {
+    configBackup: null,
+    portServer: null,
+    tempDir: '',
+};
+// ==================================================
+// Utility Functions
+// ==================================================
+function log(message) {
+    process.stdout.write(`${message}\n`);
+}
+function logStep(step, description) {
+    log(`\n${'━'.repeat(60)}`);
+    log(`Step ${step}: ${description}`);
+    log('━'.repeat(60));
+}
+function logResult(name, passed, message) {
+    const icon = passed ? '✓' : '✗';
+    const color = passed ? '\x1b[32m' : '\x1b[31m';
+    const reset = '\x1b[0m';
+    log(`  ${color}${icon}${reset} ${name}: ${message}`);
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`Assertion failed: ${message}`);
+    }
+}
+async function runTest(name, testFn) {
+    const start = Date.now();
+    try {
+        await testFn();
+        const duration = Date.now() - start;
+        results.push({ name, passed: true, message: 'OK', duration });
+        logResult(name, true, `OK (${duration}ms)`);
+    }
+    catch (error) {
+        const duration = Date.now() - start;
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({ name, passed: false, message, duration });
+        logResult(name, false, message);
+    }
+}
+// ==================================================
+// Setup and Teardown
+// ==================================================
+function backupConfig() {
+    const configPath = getClaudeConfigPath();
+    if (existsSync(configPath)) {
+        context.configBackup = readFileSync(configPath, 'utf-8');
+        log(`  Backed up existing config from ${configPath}`);
+    }
+}
+function restoreConfig() {
+    const configPath = getClaudeConfigPath();
+    if (context.configBackup !== null) {
+        writeFileSync(configPath, context.configBackup, 'utf-8');
+        log(`  Restored original config to ${configPath}`);
+    }
+    else if (existsSync(configPath)) {
+        log(`  Test created new config at ${configPath}`);
+    }
+}
+function createTempDir() {
+    context.tempDir = join(tmpdir(), `mcp-e2e-test-${Date.now()}`);
+    mkdirSync(context.tempDir, { recursive: true });
+    log(`  Created temp directory: ${context.tempDir}`);
+}
+function cleanupTempDir() {
+    if (context.tempDir && existsSync(context.tempDir)) {
+        rmSync(context.tempDir, { recursive: true, force: true });
+        log(`  Cleaned up temp directory: ${context.tempDir}`);
+    }
+}
+async function startPortBlocker(port) {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            context.portServer = server;
+            resolve(server);
+        });
+    });
+}
+function stopPortBlocker() {
+    if (context.portServer) {
+        context.portServer.close();
+        context.portServer = null;
+    }
+}
+// ==================================================
+// Issue Simulation Helpers
+// ==================================================
+function simulateMissingConfig() {
+    const configPath = getClaudeConfigPath();
+    if (existsSync(configPath)) {
+        rmSync(configPath);
+    }
+}
+function simulateInvalidJsonConfig() {
+    const configPath = getClaudeConfigPath();
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(configPath, '{ invalid json content !!!', 'utf-8');
+}
+function simulateMissingMcpConfig() {
+    const configPath = getClaudeConfigPath();
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify({ mcpServers: {} }, null, 2), 'utf-8');
+}
+function simulateMissingApiKey() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {},
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+function simulateInvalidApiKeyFormat() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {
+                    Authorization: 'invalid-no-bearer-prefix', // Missing "Bearer "
+                },
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+function simulateMissingServerUrl() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                headers: {
+                    Authorization: `Bearer ${TEST_API_KEY}`,
+                },
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+function simulateInvalidServerUrlPath() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701', // Missing /mcp/sse path
+                headers: {
+                    Authorization: `Bearer ${TEST_API_KEY}`,
+                },
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+function simulateDuplicateServers() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {
+                    Authorization: `Bearer ${TEST_API_KEY}`,
+                },
+            },
+            'catalyst-mcp': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {
+                    Authorization: `Bearer ${TEST_API_KEY}`,
+                },
+            },
+            'ana-test': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {
+                    Authorization: `Bearer ${TEST_API_KEY}`,
+                },
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+function simulateShortApiKey() {
+    const config = {
+        mcpServers: {
+            'tostudy': {
+                type: 'sse',
+                url: 'https://tostudy.com:3701/mcp/sse',
+                headers: {
+                    Authorization: 'Bearer short', // Too short API key
+                },
+            },
+        },
+    };
+    writeClaudeConfig(config);
+}
+// ==================================================
+// Test Suites
+// ==================================================
+/**
+ * Step 1: Test detection of missing config file
+ */
+async function testMissingConfigDetection() {
+    logStep(1, 'Missing Config File Detection & Repair');
+    await runTest('Detect missing config file', async () => {
+        simulateMissingConfig();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'config-missing');
+        assert(issue !== undefined, 'Should detect config-missing issue');
+        assert(issue?.severity === 'warning', 'Missing config should be a warning');
+        assert(issue?.autoFixable === true, 'Missing config should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Severity: ${issue?.severity}`);
+    });
+    await runTest('Repair missing config file', async () => {
+        simulateMissingConfig();
+        const { diagnostic, repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'config-missing');
+        assert(result !== undefined, 'Should have repair result for config-missing');
+        assert(result?.success === true, 'Repair should succeed');
+        // Verify config file was created
+        const configPath = getClaudeConfigPath();
+        assert(existsSync(configPath), 'Config file should exist after repair');
+        log(`    Repair result: ${result?.message}`);
+        log(`    Action: ${result?.action}`);
+    });
+    await runTest('Verify config missing issue resolved', async () => {
+        // Config should have been created by previous repair
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'config-missing');
+        assert(issue === undefined, 'Config-missing issue should be resolved');
+        log(`    Config file verified to exist`);
+    });
+}
+/**
+ * Step 2: Test detection of invalid JSON config
+ */
+async function testInvalidJsonDetection() {
+    logStep(2, 'Invalid JSON Config Detection & Repair');
+    await runTest('Detect invalid JSON config', async () => {
+        simulateInvalidJsonConfig();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'config-invalid-json');
+        assert(issue !== undefined, 'Should detect config-invalid-json issue');
+        assert(issue?.severity === 'critical', 'Invalid JSON should be critical');
+        assert(issue?.autoFixable === true, 'Invalid JSON should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Description: ${issue?.description}`);
+    });
+    await runTest('Repair invalid JSON config', async () => {
+        simulateInvalidJsonConfig();
+        const { repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'config-invalid-json');
+        assert(result !== undefined, 'Should have repair result for config-invalid-json');
+        assert(result?.success === true, 'Repair should succeed');
+        // Verify config file is now valid JSON
+        const configPath = getClaudeConfigPath();
+        const content = readFileSync(configPath, 'utf-8');
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            throw new Error('Config file should be valid JSON after repair');
+        }
+        log(`    Repair result: ${result?.message}`);
+        log(`    Backup created: ${result?.action}`);
+    });
+    await runTest('Verify invalid JSON issue resolved', async () => {
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'config-invalid-json');
+        assert(issue === undefined, 'Invalid JSON issue should be resolved');
+        log(`    Config file is now valid JSON`);
+    });
+}
+/**
+ * Step 3: Test detection of missing MCP configuration
+ */
+async function testMissingMcpConfigDetection() {
+    logStep(3, 'Missing MCP Configuration Detection & Repair');
+    await runTest('Detect missing MCP config', async () => {
+        simulateMissingMcpConfig();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'mcp-not-configured');
+        assert(issue !== undefined, 'Should detect mcp-not-configured issue');
+        assert(issue?.autoFixable === true, 'Missing MCP config should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Requires user input: ${issueRequiresUserInput(issue?.id || '')}`);
+    });
+    await runTest('Repair missing MCP config (with API key)', async () => {
+        simulateMissingMcpConfig();
+        const { repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'mcp-not-configured');
+        assert(result !== undefined, 'Should have repair result for mcp-not-configured');
+        assert(result?.success === true, 'Repair should succeed with API key provided');
+        // Verify MCP is now configured
+        assert(isTostudyMcpConfigured() === true, 'MCP should be configured after repair');
+        log(`    Repair result: ${result?.message}`);
+        log(`    MCP configured: true`);
+    });
+    await runTest('Repair fails without API key', async () => {
+        simulateMissingMcpConfig();
+        const { repair } = await diagnoseAndRepair(); // No API key
+        const result = repair.results.find((r) => r.issueId === 'mcp-not-configured');
+        assert(result !== undefined, 'Should have repair result');
+        assert(result?.success === false, 'Repair should fail without API key');
+        assert(repair.requiresUserInput.includes('mcp-not-configured'), 'Should require user input');
+        log(`    Repair failed as expected (no API key)`);
+        log(`    Requires user input: true`);
+    });
+}
+/**
+ * Step 4: Test detection of API key issues
+ */
+async function testApiKeyIssuesDetection() {
+    logStep(4, 'API Key Issues Detection & Repair');
+    await runTest('Detect missing API key', async () => {
+        simulateMissingApiKey();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'api-key-missing');
+        assert(issue !== undefined, 'Should detect api-key-missing issue');
+        assert(issue?.severity === 'critical', 'Missing API key should be critical');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Severity: ${issue?.severity}`);
+    });
+    await runTest('Detect invalid API key format', async () => {
+        simulateInvalidApiKeyFormat();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'api-key-invalid-format');
+        assert(issue !== undefined, 'Should detect api-key-invalid-format issue');
+        assert(issue?.autoFixable === true, 'Invalid format should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Description: ${issue?.description}`);
+    });
+    await runTest('Repair invalid API key format', async () => {
+        simulateInvalidApiKeyFormat();
+        const { repair } = await diagnoseAndRepair();
+        const result = repair.results.find((r) => r.issueId === 'api-key-invalid-format');
+        assert(result !== undefined, 'Should have repair result');
+        assert(result?.success === true, 'Repair should succeed for format fix');
+        log(`    Repair result: ${result?.message}`);
+        log(`    Action: ${result?.action}`);
+    });
+    await runTest('Detect short API key', async () => {
+        simulateShortApiKey();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'api-key-too-short');
+        assert(issue !== undefined, 'Should detect api-key-too-short issue');
+        assert(issue?.severity === 'warning', 'Short API key should be a warning');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Description: ${issue?.description}`);
+    });
+}
+/**
+ * Step 5: Test detection of server URL issues
+ */
+async function testServerUrlIssuesDetection() {
+    logStep(5, 'Server URL Issues Detection & Repair');
+    await runTest('Detect missing server URL', async () => {
+        simulateMissingServerUrl();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'server-url-missing');
+        assert(issue !== undefined, 'Should detect server-url-missing issue');
+        assert(issue?.severity === 'critical', 'Missing URL should be critical');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Severity: ${issue?.severity}`);
+    });
+    await runTest('Repair missing server URL', async () => {
+        simulateMissingServerUrl();
+        const { repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'server-url-missing');
+        assert(result !== undefined, 'Should have repair result');
+        assert(result?.success === true, 'Repair should succeed');
+        const mcpConfig = getTostudyMcpConfig();
+        assert(mcpConfig?.url !== undefined, 'URL should be set after repair');
+        log(`    Repair result: ${result?.message}`);
+        log(`    Action: ${result?.action}`);
+    });
+    await runTest('Detect missing SSE path in URL', async () => {
+        simulateInvalidServerUrlPath();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'server-url-missing-sse-path');
+        assert(issue !== undefined, 'Should detect server-url-missing-sse-path issue');
+        assert(issue?.autoFixable === true, 'Missing path should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Description: ${issue?.description}`);
+    });
+    await runTest('Repair missing SSE path', async () => {
+        simulateInvalidServerUrlPath();
+        const { repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'server-url-missing-sse-path');
+        assert(result !== undefined, 'Should have repair result');
+        assert(result?.success === true, 'Repair should succeed');
+        const mcpConfig = getTostudyMcpConfig();
+        assert(mcpConfig?.url?.endsWith('/mcp/sse') === true, 'URL should end with /mcp/sse after repair');
+        log(`    Repair result: ${result?.message}`);
+        log(`    Final URL: ${mcpConfig?.url}`);
+    });
+}
+/**
+ * Step 6: Test detection of duplicate servers
+ */
+async function testDuplicateServersDetection() {
+    logStep(6, 'Duplicate Servers Detection & Repair');
+    await runTest('Detect duplicate servers', async () => {
+        simulateDuplicateServers();
+        const report = await runDiagnostics();
+        const issue = report.issues.find((i) => i.id === 'duplicate-servers');
+        assert(issue !== undefined, 'Should detect duplicate-servers issue');
+        assert(issue?.autoFixable === true, 'Duplicate servers should be auto-fixable');
+        log(`    Detected: ${issue?.title}`);
+        log(`    Description: ${issue?.description}`);
+    });
+    await runTest('Repair duplicate servers', async () => {
+        simulateDuplicateServers();
+        const { repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        const result = repair.results.find((r) => r.issueId === 'duplicate-servers');
+        assert(result !== undefined, 'Should have repair result');
+        assert(result?.success === true, 'Repair should succeed');
+        // Verify only one server remains
+        const config = readClaudeConfig();
+        const anaServers = Object.keys(config.mcpServers || {}).filter((key) => key.toLowerCase().includes('ana') ||
+            key.toLowerCase().includes('catalyst'));
+        assert(anaServers.length === 1, 'Should have only one Catalyst server after repair');
+        assert(anaServers[0] === 'tostudy', 'Should keep tostudy as the primary server');
+        log(`    Repair result: ${result?.message}`);
+        log(`    Action: ${result?.action}`);
+    });
+}
+/**
+ * Step 7: Test port conflict detection
+ */
+async function testPortConflictDetection() {
+    logStep(7, 'Port Conflict Detection');
+    await runTest('Detect port conflict', async () => {
+        // Try to start port blocker - might fail if port is already in use
+        let server = null;
+        try {
+            server = await startPortBlocker(DEFAULT_MCP_PORT);
+        }
+        catch {
+            log(`    Port ${DEFAULT_MCP_PORT} already in use - testing with existing blocker`);
+        }
+        try {
+            // Set up a valid config first
+            addTostudyMcpServer(TEST_API_KEY, TEST_PLATFORM_URL);
+            const report = await runDiagnostics();
+            const issue = report.issues.find((i) => i.id === 'port-conflict');
+            // Port conflict is detected if port is not available
+            if (issue) {
+                assert(issue.severity === 'warning', 'Port conflict should be a warning');
+                assert(issue.autoFixable === false, 'Port conflict is not auto-fixable');
+                log(`    Detected: ${issue.title}`);
+                log(`    Description: ${issue.description}`);
+            }
+            else {
+                log(`    No port conflict detected (port ${DEFAULT_MCP_PORT} is available)`);
+            }
+        }
+        finally {
+            if (server) {
+                server.close();
+            }
+            stopPortBlocker();
+        }
+    });
+}
+/**
+ * Step 8: Complete diagnostic and repair flow
+ */
+async function testCompleteFlow() {
+    logStep(8, 'Complete Diagnostic & Repair Flow Simulation');
+    await runTest('Full flow: detect multiple issues', async () => {
+        // Create a config with multiple issues
+        const configPath = getClaudeConfigPath();
+        const configDir = dirname(configPath);
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        // Config with missing API key and wrong URL path
+        const problematicConfig = {
+            mcpServers: {
+                'tostudy': {
+                    type: 'sse',
+                    url: 'https://tostudy.com:3701', // Missing /mcp/sse
+                    headers: {}, // Missing Authorization
+                },
+                'catalyst-duplicate': {
+                    type: 'sse',
+                    url: 'https://tostudy.com:3701/mcp/sse',
+                    headers: {
+                        Authorization: 'Bearer test-key',
+                    },
+                },
+            },
+        };
+        writeFileSync(configPath, JSON.stringify(problematicConfig, null, 2), 'utf-8');
+        const report = await runDiagnostics();
+        log(`    Total issues found: ${report.issues.length}`);
+        for (const issue of report.issues) {
+            const icon = issue.severity === 'critical' ? '🔴' :
+                issue.severity === 'warning' ? '🟡' : '🔵';
+            log(`      ${icon} ${issue.id}: ${issue.title}`);
+        }
+        assert(report.issues.length >= 2, 'Should detect multiple issues');
+    });
+    await runTest('Full flow: repair all issues', async () => {
+        const { diagnostic, repair } = await diagnoseAndRepair(TEST_API_KEY, TEST_PLATFORM_URL);
+        log(`    Repairs attempted: ${repair.repairsAttempted}`);
+        log(`    Repairs succeeded: ${repair.repairsSucceeded}`);
+        log(`    Repairs failed: ${repair.repairsFailed}`);
+        for (const result of repair.results) {
+            const icon = result.success ? '✓' : '✗';
+            log(`      ${icon} ${result.issueId}: ${result.message}`);
+        }
+        assert(repair.repairsSucceeded > 0, 'Should have at least one successful repair');
+    });
+    await runTest('Full flow: verify issues resolved', async () => {
+        const report = await runDiagnostics();
+        const criticalIssues = report.issues.filter((i) => i.severity === 'critical');
+        log(`    Remaining issues: ${report.issues.length}`);
+        log(`    Critical issues: ${criticalIssues.length}`);
+        log(`    Overall passed: ${report.passed}`);
+        assert(report.passed === true, 'Report should pass after repairs');
+        assert(criticalIssues.length === 0, 'Should have no critical issues');
+    });
+    await runTest('Verify final configuration state', async () => {
+        assert(isTostudyMcpConfigured() === true, 'MCP should be configured');
+        const mcpConfig = getTostudyMcpConfig();
+        assert(mcpConfig !== null, 'MCP config should exist');
+        assert(mcpConfig?.type === 'sse', 'Type should be sse');
+        assert(mcpConfig?.url?.endsWith('/mcp/sse') === true, 'URL should end with /mcp/sse');
+        assert(mcpConfig?.headers?.['Authorization']?.startsWith('Bearer ') === true, 'Should have Bearer token');
+        log(`    MCP configured: true`);
+        log(`    Type: ${mcpConfig?.type}`);
+        log(`    URL: ${mcpConfig?.url}`);
+        log(`    Has auth header: true`);
+    });
+}
+/**
+ * Step 9: Test issue helper functions
+ */
+async function testHelperFunctions() {
+    logStep(9, 'Helper Functions Verification');
+    await runTest('issueRequiresUserInput identifies correct issues', () => {
+        assert(issueRequiresUserInput('mcp-not-configured') === true, 'mcp-not-configured requires input');
+        assert(issueRequiresUserInput('api-key-missing') === true, 'api-key-missing requires input');
+        assert(issueRequiresUserInput('api-key-too-short') === true, 'api-key-too-short requires input');
+        assert(issueRequiresUserInput('auth-failed') === true, 'auth-failed requires input');
+        assert(issueRequiresUserInput('config-missing') === false, 'config-missing does not require input');
+        assert(issueRequiresUserInput('duplicate-servers') === false, 'duplicate-servers does not require input');
+        log(`    All input requirement checks passed`);
+    });
+    await runTest('repairIssue handles unknown issues gracefully', () => {
+        const unknownIssue = {
+            id: 'unknown-issue-xyz',
+            severity: 'warning',
+            title: 'Unknown Issue',
+            description: 'Test unknown issue',
+            suggestion: 'Test suggestion',
+            autoFixable: true,
+        };
+        const result = repairIssue(unknownIssue);
+        assert(result.success === false, 'Unknown issue repair should fail');
+        assert(result.message.includes('Sem funcao de reparo'), 'Should indicate no repair function');
+        log(`    Unknown issue handled: ${result.message}`);
+    });
+    await runTest('DiagnosticReport structure is correct', async () => {
+        addTostudyMcpServer(TEST_API_KEY, TEST_PLATFORM_URL);
+        const report = await runDiagnostics();
+        assert(typeof report.timestamp === 'string', 'Should have timestamp');
+        assert(typeof report.claudeInstalled === 'boolean', 'Should have claudeInstalled');
+        assert(typeof report.mcpConfigured === 'boolean', 'Should have mcpConfigured');
+        assert(Array.isArray(report.issues), 'Should have issues array');
+        assert(typeof report.passed === 'boolean', 'Should have passed status');
+        for (const issue of report.issues) {
+            assert(typeof issue.id === 'string', 'Issue should have id');
+            assert(typeof issue.severity === 'string', 'Issue should have severity');
+            assert(typeof issue.title === 'string', 'Issue should have title');
+            assert(typeof issue.description === 'string', 'Issue should have description');
+            assert(typeof issue.suggestion === 'string', 'Issue should have suggestion');
+            assert(typeof issue.autoFixable === 'boolean', 'Issue should have autoFixable');
+        }
+        log(`    Report structure validated`);
+        log(`    Timestamp: ${report.timestamp}`);
+        log(`    Issues: ${report.issues.length}`);
+    });
+    await runTest('RepairReport structure is correct', async () => {
+        const diagnostic = await runDiagnostics();
+        const repair = repairAllIssues(diagnostic, TEST_API_KEY, TEST_PLATFORM_URL);
+        assert(typeof repair.timestamp === 'string', 'Should have timestamp');
+        assert(typeof repair.repairsAttempted === 'number', 'Should have repairsAttempted');
+        assert(typeof repair.repairsSucceeded === 'number', 'Should have repairsSucceeded');
+        assert(typeof repair.repairsFailed === 'number', 'Should have repairsFailed');
+        assert(Array.isArray(repair.results), 'Should have results array');
+        assert(Array.isArray(repair.requiresUserInput), 'Should have requiresUserInput array');
+        for (const result of repair.results) {
+            assert(typeof result.issueId === 'string', 'Result should have issueId');
+            assert(typeof result.success === 'boolean', 'Result should have success');
+            assert(typeof result.message === 'string', 'Result should have message');
+        }
+        log(`    Repair report structure validated`);
+        log(`    Timestamp: ${repair.timestamp}`);
+        log(`    Results: ${repair.results.length}`);
+    });
+}
+// ==================================================
+// Summary and Main Runner
+// ==================================================
+function printSummary() {
+    log('\n' + '═'.repeat(60));
+    log('TEST SUMMARY: Diagnostic & Repair E2E Flow');
+    log('═'.repeat(60));
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.filter((r) => !r.passed).length;
+    const total = results.length;
+    log(`\nTotal: ${total} | Passed: ${passed} | Failed: ${failed}\n`);
+    if (failed > 0) {
+        log('FAILED TESTS:');
+        for (const result of results.filter((r) => !r.passed)) {
+            log(`  ✗ ${result.name}`);
+            log(`    ${result.message}`);
+        }
+        log('');
+    }
+    const totalTime = results.reduce((sum, r) => sum + r.duration, 0);
+    log(`Total time: ${totalTime}ms`);
+    log('');
+    if (failed === 0) {
+        log('\x1b[32m✓ All E2E diagnostic and repair tests passed!\x1b[0m');
+    }
+    else {
+        log(`\x1b[31m✗ ${failed} test(s) failed\x1b[0m`);
+        process.exitCode = 1;
+    }
+}
+async function main() {
+    log('═'.repeat(60));
+    log('E2E TEST: Diagnostic and Repair Flow');
+    log('═'.repeat(60));
+    log(`Platform: ${platform()}`);
+    log(`Node: ${process.version}`);
+    log(`Time: ${new Date().toISOString()}`);
+    try {
+        // Setup
+        log('\n--- Setup ---');
+        backupConfig();
+        createTempDir();
+        // Run all test steps
+        await testMissingConfigDetection();
+        await testInvalidJsonDetection();
+        await testMissingMcpConfigDetection();
+        await testApiKeyIssuesDetection();
+        await testServerUrlIssuesDetection();
+        await testDuplicateServersDetection();
+        await testPortConflictDetection();
+        await testCompleteFlow();
+        await testHelperFunctions();
+        // Cleanup
+        log('\n--- Cleanup ---');
+        restoreConfig();
+        cleanupTempDir();
+        stopPortBlocker();
+        // Print summary
+        printSummary();
+    }
+    catch (error) {
+        log(`\n\x1b[31mFATAL ERROR: ${error instanceof Error ? error.message : String(error)}\x1b[0m`);
+        restoreConfig();
+        cleanupTempDir();
+        stopPortBlocker();
+        process.exitCode = 1;
+    }
+}
+// Run if executed directly
+if (import.meta.url.endsWith(process.argv[1]?.replace(/^file:\/\//, '') || '')) {
+    main();
+}
+// Export for use as a module
+export { testMissingConfigDetection, testInvalidJsonDetection, testMissingMcpConfigDetection, testApiKeyIssuesDetection, testServerUrlIssuesDetection, testDuplicateServersDetection, testPortConflictDetection, testCompleteFlow, testHelperFunctions, main as runDiagnosticRepairE2ETests, };
+//# sourceMappingURL=e2e-diagnostic-repair-flow.test.js.map