fraim-framework 2.0.27 → 2.0.33

package/dist/tests/test-hybrid-script-execution.js

@@ -0,0 +1,369 @@
+"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 });
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testSelfContainedScriptDetection() {
+    console.log('   🚀 Testing Self-Contained Script Detection...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-hybrid-test-'));
+    const scriptsDir = path_1.default.join(tempDir, 'scripts');
+    fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+    try {
+        // Create a self-contained shell script
+        const shellScript = `#!/bin/bash
+set -e
+echo "This is a self-contained shell script"
+echo "Working directory: $(pwd)"
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'self-contained.sh'), shellScript);
+        // Create a self-contained TypeScript script (no relative imports)
+        const selfContainedTS = `#!/usr/bin/env node
+console.log('This is a self-contained TypeScript script');
+console.log('Working directory:', process.cwd());
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'self-contained.ts'), selfContainedTS);
+        // Create a dependent TypeScript script (has relative imports to src/)
+        const dependentTS = `#!/usr/bin/env node
+import { loadFraimConfig } from '../../src/fraim/config-loader';
+import { someUtility } from '../../src/utils/helper';
+
+const config = loadFraimConfig();
+console.log('This script depends on FRAIM source code');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'dependent.ts'), dependentTS);
+        // Create another dependent script with require syntax
+        const dependentJS = `#!/usr/bin/env node
+const { loadFraimConfig } = require('../../src/fraim/config-loader');
+const helper = require('../../src/utils/helper');
+
+console.log('This script also depends on FRAIM source code');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'dependent.js'), dependentJS);
+        // Test the detection logic
+        const { isScriptSelfContained, getRegistryScripts, getDependentRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        // Test individual script detection
+        node_assert_1.default.ok(isScriptSelfContained(path_1.default.join(scriptsDir, 'self-contained.sh')), 'Shell script should be self-contained');
+        node_assert_1.default.ok(isScriptSelfContained(path_1.default.join(scriptsDir, 'self-contained.ts')), 'Self-contained TS should be detected');
+        node_assert_1.default.ok(!isScriptSelfContained(path_1.default.join(scriptsDir, 'dependent.ts')), 'Dependent TS should not be self-contained');
+        node_assert_1.default.ok(!isScriptSelfContained(path_1.default.join(scriptsDir, 'dependent.js')), 'Dependent JS should not be self-contained');
+        // Test batch detection
+        const selfContainedScripts = getRegistryScripts(tempDir);
+        const dependentScripts = getDependentRegistryScripts(tempDir);
+        node_assert_1.default.strictEqual(selfContainedScripts.length, 2, 'Should find 2 self-contained scripts');
+        node_assert_1.default.strictEqual(dependentScripts.length, 2, 'Should find 2 dependent scripts');
+        // Verify correct categorization
+        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p)).sort();
+        const dependentNames = dependentScripts.map(p => path_1.default.basename(p)).sort();
+        node_assert_1.default.deepStrictEqual(selfContainedNames, ['self-contained.sh', 'self-contained.ts'], 'Self-contained scripts correctly identified');
+        node_assert_1.default.deepStrictEqual(dependentNames, ['dependent.js', 'dependent.ts'], 'Dependent scripts correctly identified');
+        console.log('   ✅ Self-contained script detection verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Script detection test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
+async function testHybridSyncBehavior() {
+    console.log('   🚀 Testing Hybrid Sync Behavior...');
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-hybrid-sync-test-'));
+    const userFraimDir = path_1.default.join(os_1.default.homedir(), '.fraim-hybrid-test');
+    const userScriptsDir = path_1.default.join(userFraimDir, 'scripts');
+    try {
+        // Clean up any existing test user directory
+        if (fs_1.default.existsSync(userFraimDir)) {
+            fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+        }
+        // Set up test registry with mixed scripts
+        const registryDir = path_1.default.join(tempDir, 'registry');
+        const scriptsDir = path_1.default.join(registryDir, 'scripts');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        // Create self-contained scripts
+        const shellScript = `#!/bin/bash
+echo "Self-contained shell script"
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'shell-script.sh'), shellScript);
+        const selfContainedTS = `#!/usr/bin/env node
+console.log('Self-contained TypeScript script');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'self-contained.ts'), selfContainedTS);
+        // Create dependent scripts
+        const dependentTS = `#!/usr/bin/env node
+import { loadFraimConfig } from '../../src/fraim/config-loader';
+console.log('Dependent TypeScript script');
+`;
+        fs_1.default.writeFileSync(path_1.default.join(scriptsDir, 'dependent.ts'), dependentTS);
+        // Test sync behavior
+        const { syncScriptsToUserDirectory } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        // Override user directory for testing
+        process.env.FRAIM_USER_DIR = userFraimDir;
+        const syncResult = syncScriptsToUserDirectory(registryDir);
+        // Verify sync results
+        node_assert_1.default.strictEqual(syncResult.synced, 2, 'Should sync 2 self-contained scripts');
+        node_assert_1.default.strictEqual(syncResult.ephemeral, 1, 'Should identify 1 dependent script for ephemeral execution');
+        // Verify only self-contained scripts were copied
+        node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'shell-script.sh')), 'Shell script should be synced');
+        node_assert_1.default.ok(fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'self-contained.ts')), 'Self-contained TS should be synced');
+        node_assert_1.default.ok(!fs_1.default.existsSync(path_1.default.join(userScriptsDir, 'dependent.ts')), 'Dependent TS should NOT be synced');
+        // Verify executable permissions on Unix
+        if (process.platform !== 'win32') {
+            const shellScriptPath = path_1.default.join(userScriptsDir, 'shell-script.sh');
+            const stats = fs_1.default.statSync(shellScriptPath);
+            node_assert_1.default.ok(stats.mode & 0o111, 'Shell script should be executable');
+        }
+        console.log('   ✅ Hybrid sync behavior verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Hybrid sync test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            if (fs_1.default.existsSync(userFraimDir)) {
+                fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+            }
+        }
+        catch (e) { }
+        delete process.env.FRAIM_USER_DIR;
+    }
+}
+async function testActualRegistryScriptCategorization() {
+    console.log('   🚀 Testing Actual Registry Script Categorization...');
+    try {
+        const registryPath = path_1.default.resolve(__dirname, '../../registry');
+        if (!fs_1.default.existsSync(registryPath)) {
+            console.log('   ⚠️ Registry not found, skipping actual script categorization test');
+            return true;
+        }
+        const { getRegistryScripts, getDependentRegistryScripts } = await Promise.resolve().then(() => __importStar(require('../src/utils/script-sync-utils')));
+        const selfContainedScripts = getRegistryScripts(registryPath);
+        const dependentScripts = getDependentRegistryScripts(registryPath);
+        console.log(`   📊 Found ${selfContainedScripts.length} self-contained scripts:`);
+        for (const script of selfContainedScripts) {
+            console.log(`     ✅ ${path_1.default.basename(script)}`);
+        }
+        console.log(`   📊 Found ${dependentScripts.length} dependent scripts:`);
+        for (const script of dependentScripts) {
+            console.log(`     🔗 ${path_1.default.basename(script)}`);
+        }
+        // Verify expected scripts are categorized correctly
+        const selfContainedNames = selfContainedScripts.map(p => path_1.default.basename(p));
+        const dependentNames = dependentScripts.map(p => path_1.default.basename(p));
+        // prep-issue.sh should be self-contained (it's a shell script)
+        node_assert_1.default.ok(selfContainedNames.includes('prep-issue.sh'), 'prep-issue.sh should be self-contained');
+        // Scripts with FRAIM imports should be dependent
+        const expectedDependentScripts = [
+            'fraim-config.ts',
+            'build-scripts-generator.ts'
+        ];
+        for (const expectedDependent of expectedDependentScripts) {
+            if (fs_1.default.existsSync(path_1.default.join(registryPath, 'scripts', expectedDependent))) {
+                node_assert_1.default.ok(dependentNames.includes(expectedDependent), `${expectedDependent} should be dependent`);
+            }
+        }
+        // Scripts that should be self-contained
+        const expectedSelfContainedScripts = [
+            'prep-issue.sh',
+            'evaluate-code-quality.ts', // This only uses __dirname and standard modules
+            'code-quality-check.sh'
+        ];
+        for (const expectedSelfContained of expectedSelfContainedScripts) {
+            if (fs_1.default.existsSync(path_1.default.join(registryPath, 'scripts', expectedSelfContained))) {
+                node_assert_1.default.ok(selfContainedNames.includes(expectedSelfContained), `${expectedSelfContained} should be self-contained`);
+            }
+        }
+        // Verify we have a reasonable split
+        const totalScripts = selfContainedScripts.length + dependentScripts.length;
+        node_assert_1.default.ok(totalScripts > 0, 'Should find some scripts in registry');
+        node_assert_1.default.ok(selfContainedScripts.length > 0, 'Should have some self-contained scripts');
+        console.log('   ✅ Actual registry script categorization verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Registry script categorization test failed:', error);
+        return false;
+    }
+}
+async function testSelfContainedScriptExecution() {
+    console.log('   🚀 Testing Self-Contained Script Execution...');
+    const tempProjectDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-self-contained-test-'));
+    const userFraimDir = path_1.default.join(os_1.default.homedir(), '.fraim-self-contained-test');
+    const userScriptsDir = path_1.default.join(userFraimDir, 'scripts');
+    try {
+        // Clean up and setup
+        if (fs_1.default.existsSync(userFraimDir)) {
+            fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+        }
+        fs_1.default.mkdirSync(userScriptsDir, { recursive: true });
+        // Create a self-contained script that mimics prep-issue.sh behavior
+        const selfContainedScript = `#!/bin/bash
+set -e
+
+echo "=== Self-Contained Script Test ==="
+
+# Validate we can find .fraim/config.json in working directory
+if [ ! -f ".fraim/config.json" ]; then
+    echo "ERROR: Cannot find .fraim/config.json in working directory"
+    exit 1
+fi
+
+# Read project name from config using node
+PROJECT_NAME=$(node -e "
+const fs = require('fs');
+const config = JSON.parse(fs.readFileSync('.fraim/config.json', 'utf8'));
+console.log(config.project.name);
+")
+
+echo "Project name from config: $PROJECT_NAME"
+
+# Validate we can create files in working directory
+echo "test content" > self-contained-test-output.txt
+if [ -f "self-contained-test-output.txt" ]; then
+    echo "File creation: SUCCESS"
+    rm self-contained-test-output.txt
+else
+    echo "File creation: FAILED"
+    exit 1
+fi
+
+echo "Working directory: $(pwd)"
+echo "Script directory: $(dirname "$0")"
+
+# Validate they are different
+if [ "$(pwd)" = "$(dirname "$0")" ]; then
+    echo "ERROR: Working directory should not be same as script directory"
+    exit 1
+fi
+
+echo "Self-contained script execution: SUCCESS"
+`;
+        const scriptPath = path_1.default.join(userScriptsDir, 'self-contained-test.sh');
+        fs_1.default.writeFileSync(scriptPath, selfContainedScript);
+        if (process.platform !== 'win32') {
+            fs_1.default.chmodSync(scriptPath, 0o755);
+        }
+        // Set up project directory
+        const projectFraimDir = path_1.default.join(tempProjectDir, '.fraim');
+        fs_1.default.mkdirSync(projectFraimDir, { recursive: true });
+        const testConfig = {
+            project: { name: 'self-contained-test' },
+            git: { repoOwner: 'test', repoName: 'self-contained-test' }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(projectFraimDir, 'config.json'), JSON.stringify(testConfig, null, 2));
+        // Execute script from project directory
+        console.log('   Executing self-contained script...');
+        const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const bashCommand = process.platform === 'win32'
+            ? `"C:\\Program Files\\Git\\bin\\bash.exe" "${scriptPath}"`
+            : `"${scriptPath}"`;
+        let output;
+        try {
+            output = execSync(bashCommand, {
+                cwd: tempProjectDir,
+                encoding: 'utf-8'
+            });
+        }
+        catch (error) {
+            if (process.platform === 'win32' && error.message.includes('not recognized')) {
+                console.log('   ⚠️ Git Bash not found on Windows, skipping self-contained script test');
+                return true;
+            }
+            throw error;
+        }
+        // Validate output
+        node_assert_1.default.ok(output.includes('Self-contained script execution: SUCCESS'), 'Script should execute successfully');
+        node_assert_1.default.ok(output.includes('Project name from config: self-contained-test'), 'Should read config correctly');
+        node_assert_1.default.ok(output.includes('File creation: SUCCESS'), 'Should be able to create files in working directory');
+        console.log('   ✅ Self-contained script execution verified!');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Self-contained script execution test failed:', error);
+        return false;
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempProjectDir, { recursive: true, force: true });
+            if (fs_1.default.existsSync(userFraimDir)) {
+                fs_1.default.rmSync(userFraimDir, { recursive: true, force: true });
+            }
+        }
+        catch (e) { }
+    }
+}
+async function runHybridScriptTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Self-Contained Script Detection',
+        description: 'Tests the logic that determines which scripts are self-contained vs dependent',
+        testFunction: testSelfContainedScriptDetection,
+        tags: ['hybrid', 'detection']
+    },
+    {
+        name: 'Hybrid Sync Behavior',
+        description: 'Tests that sync only copies self-contained scripts to user directory',
+        testFunction: testHybridSyncBehavior,
+        tags: ['hybrid', 'sync']
+    },
+    {
+        name: 'Actual Registry Script Categorization',
+        description: 'Tests categorization of real scripts in the registry',
+        testFunction: testActualRegistryScriptCategorization,
+        tags: ['hybrid', 'registry']
+    },
+    {
+        name: 'Self-Contained Script Execution',
+        description: 'Tests that self-contained scripts work correctly when executed from user directory',
+        testFunction: testSelfContainedScriptExecution,
+        tags: ['hybrid', 'execution']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runHybridScriptTest, 'Hybrid Script Execution Tests');

package/dist/tests/test-mcp-connection.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const axios_1 = __importDefault(require("axios"));
+const test_utils_1 = require("./test-utils");
+const node_assert_1 = __importDefault(require("node:assert"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const path_1 = __importDefault(require("path"));
+const db_service_js_1 = require("../src/fraim/db-service.js");
+async function testMcpConnection() {
+    console.log('   🚀 Testing MCP Connection Reliability...');
+    let fraimProcess;
+    let dbService;
+    const PORT = Math.floor(Math.random() * 1000) + 12000;
+    const BASE_URL = `http://localhost:${PORT}`;
+    const TEST_API_KEY = 'test-fraim-key-mcp-conn';
+    const TEST_ADMIN_KEY = 'test-admin-key-mcp-conn';
+    try {
+        // 0. Setup DB and Key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        const db = dbService.db;
+        await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+        await db.collection('fraim_api_keys').insertOne({
+            key: TEST_API_KEY,
+            userId: 'test-user-mcp',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        // 1. Start Server
+        console.log(`   Starting server on port ${PORT}...`);
+        const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const serverScript = path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
+            env: {
+                ...process.env,
+                FRAIM_MCP_PORT: PORT.toString(),
+                FRAIM_ADMIN_KEY: TEST_ADMIN_KEY,
+                FRAIM_SKIP_INDEX_ON_START: 'true'
+            },
+            stdio: 'pipe',
+            shell: true
+        });
+        if (fraimProcess.stdout)
+            fraimProcess.stdout.pipe(process.stdout);
+        if (fraimProcess.stderr)
+            fraimProcess.stderr.pipe(process.stderr);
+        // Wait for start
+        let started = false;
+        for (let i = 0; i < 15; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`, { timeout: 500 });
+                started = true;
+                break;
+            }
+            catch (e) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        if (!started)
+            throw new Error('Server failed to start');
+        console.log('   Server started!');
+        const authHeaders = { 'x-api-key': TEST_API_KEY };
+        // 2. Test notifications/initialized (Fix 1 verification)
+        console.log('   Testing notifications/initialized...');
+        try {
+            const res = await axios_1.default.post(`${BASE_URL}/mcp`, {
+                jsonrpc: '2.0',
+                method: 'notifications/initialized',
+                params: {}
+            }, { headers: authHeaders });
+            // Should be 200 OK now, not 500
+            node_assert_1.default.strictEqual(res.status, 200, 'Should return 200 OK for notifications/initialized');
+            node_assert_1.default.strictEqual(res.data.result, true, 'Should return result: true');
+            console.log('   ✅ notifications/initialized handled correctly.');
+        }
+        catch (error) {
+            console.error('   ❌ Notification failed:', error.message);
+            if (error.response) {
+                console.error('   Response:', JSON.stringify(error.response.data));
+            }
+            throw error;
+        }
+        // 3. Test DELETE request crash (Fix 2 verification)
+        console.log('   Testing DELETE request (simulate disconnect crash)...');
+        try {
+            // DELETE requests often have no body. 
+            // The bug was reading req.body.id => crash if req.body is undefined/empty
+            await axios_1.default.delete(`${BASE_URL}/mcp`, {
+                headers: authHeaders,
+                validateStatus: (status) => true // Accept any status
+            });
+            console.log('   ✅ DELETE request completed without network error (Server survived).');
+        }
+        catch (error) {
+            console.error('   ❌ Server likely crashed on DELETE:', error.message);
+            throw error;
+        }
+        // Verify Server is STILL ALIVE after DELETE
+        const healthRes = await axios_1.default.get(`${BASE_URL}/health`);
+        node_assert_1.default.strictEqual(healthRes.status, 200, 'Server should be alive after DELETE request');
+        console.log('   ✅ Server verified alive after malformed request.');
+        // 4. Test SSE Endpoint Handshake
+        console.log('   Testing SSE Handshake...');
+        const sseRes = await axios_1.default.get(`${BASE_URL}/mcp`, {
+            headers: {
+                'Accept': 'text/event-stream',
+                ...authHeaders
+            },
+            responseType: 'stream'
+        });
+        const stream = sseRes.data;
+        let dataReceived = '';
+        await new Promise((resolve, reject) => {
+            stream.on('data', (chunk) => {
+                dataReceived += chunk.toString();
+                if (dataReceived.includes('event: endpoint')) {
+                    stream.destroy();
+                    resolve();
+                }
+            });
+            stream.on('error', reject);
+            setTimeout(() => { stream.destroy(); resolve(); }, 2000);
+        });
+        node_assert_1.default.ok(dataReceived.includes('event: endpoint'), 'Should receive endpoint event');
+        // Verify absolute URL format
+        const endpointLine = dataReceived.split('\n').find(l => l.startsWith('data: http'));
+        node_assert_1.default.ok(endpointLine, 'Should find data line with absolute URL starting with http');
+        node_assert_1.default.ok(endpointLine?.includes(`localhost:${PORT}/mcp`), 'Absolute URL should point to correct port/path');
+        console.log('   ✅ SSE Handshake verified with absolute URL.');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error.message);
+        return false;
+    }
+    finally {
+        if (dbService) {
+            const db = dbService.db;
+            await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY }).catch(() => { });
+            await dbService.close();
+        }
+        if (fraimProcess && fraimProcess.pid) {
+            console.log('   Cleanup: Killing server...');
+            await new Promise(resolve => (0, tree_kill_1.default)(fraimProcess.pid, 'SIGKILL', () => resolve()));
+        }
+    }
+}
+const testCases = [
+    {
+        name: 'MCP Connection & Stability',
+        description: 'Verifies connection protocol, notification handling, and crash resilience',
+        testFunction: testMcpConnection,
+        tags: ['mcp', 'connection']
+    }
+];
+(0, test_utils_1.runTests)(testCases, async (t) => t.testFunction(), 'MCP Connection Reliability')
+    .then(() => process.exit(0))
+    .catch((err) => {
+    console.error('Test runner failed:', err);
+    process.exit(1);
+});