fraim-framework 2.0.26 → 2.0.30

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, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${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);
+});

package/dist/tests/test-mcp-issue-integration.js

@@ -0,0 +1,144 @@
+"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 db_service_js_1 = require("../src/fraim/db-service.js");
+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"));
+async function testFileIssueToolAPI() {
+    console.log('   🚀 Testing File Issue Tool via MCP API...');
+    let fraimProcess;
+    let dbService;
+    const PORT = 10002; // Different port
+    const TEST_API_KEY = 'test-fraim-key-issues';
+    const BASE_URL = `http://localhost:${PORT}`;
+    try {
+        // 1. Seed API key
+        dbService = new db_service_js_1.FraimDbService();
+        await dbService.connect();
+        const db = dbService.db;
+        await db.collection('fraim_api_keys').updateOne({ key: TEST_API_KEY }, {
+            $set: {
+                userId: 'test-user@ashley.ai',
+                orgId: 'test-org',
+                isActive: true,
+                createdAt: new Date()
+            }
+        }, { upsert: true });
+        // 2. Start server
+        console.log(`   Starting server on port ${PORT}...`);
+        const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const serverScript = path_1.default.resolve(__dirname, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${serverScript}"`], {
+            env: {
+                ...process.env,
+                FRAIM_MCP_PORT: PORT.toString(),
+                FRAIM_SKIP_INDEX_ON_START: 'true'
+            },
+            stdio: 'pipe', // Using pipe to keep output cleaner, assuming debug isn't needed unless failure
+            shell: true
+        });
+        // 3. Wait for start
+        console.log('   Waiting for server to start...');
+        let started = false;
+        for (let i = 0; i < 20; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`, { timeout: 1000 });
+                started = true;
+                console.log('   Server started!');
+                break;
+            }
+            catch (e) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+        if (!started) {
+            console.error('   ❌ Server failed to start');
+            return false;
+        }
+        // 4. Perform Handshake (Required for Session)
+        console.log('   Performing Handshake (fraim_connect)...');
+        await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            id: 0,
+            method: 'tools/call',
+            params: {
+                name: 'fraim_connect',
+                arguments: {
+                    machine: { hostname: 'test-host', platform: process.platform },
+                    repo: { url: 'https://github.com/test/repo' }
+                }
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        // 5. Test file_issue tool call (Dry Run)
+        console.log('   Testing file_issue tool (dry run)...');
+        const response = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: {
+                name: 'file_issue',
+                arguments: {
+                    title: 'Integration Test Issue',
+                    body: 'This is an integration test',
+                    dryRun: true
+                }
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY },
+            timeout: 10000
+        });
+        node_assert_1.default.strictEqual(response.status, 200);
+        node_assert_1.default.ok(response.data.result, 'Should have result');
+        node_assert_1.default.ok(response.data.result.content, 'Should have content');
+        const contentText = response.data.result.content[0].text;
+        const resultJson = JSON.parse(contentText);
+        node_assert_1.default.strictEqual(resultJson.success, true);
+        node_assert_1.default.strictEqual(resultJson.dryRun, true);
+        node_assert_1.default.ok(resultJson.message.includes('[DRY RUN]'));
+        node_assert_1.default.ok(resultJson.message.includes('Integration Test Issue'));
+        console.log('   ✅ file_issue tool verified successfully');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error);
+        if (axios_1.default.isAxiosError(error) && error.response) {
+            console.error('   Response data:', error.response.data);
+        }
+        return false;
+    }
+    finally {
+        console.log('   Cleaning up...');
+        if (dbService) {
+            const db = dbService.db;
+            if (db) {
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY }).catch(() => { });
+            }
+            await dbService.close().catch(() => { });
+        }
+        if (fraimProcess && fraimProcess.pid) {
+            const pid = fraimProcess.pid;
+            await new Promise((resolve) => (0, tree_kill_1.default)(pid, 'SIGKILL', () => resolve()));
+            console.log(`   Terminated server process ${pid}`);
+        }
+    }
+}
+async function runTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'File Issue Integration Test',
+        description: 'Tests file_issue tool via real MCP server request',
+        testFunction: testFileIssueToolAPI,
+        tags: ['integration', 'issues']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runTest, 'Fraim Issue API Integration');

package/dist/tests/test-mcp-lifecycle-methods.js

@@ -0,0 +1,312 @@
+"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");
+/**
+ * Test that resources/list and prompts/list work without session
+ * This verifies the fix for the MCP telemetry blocking issue
+ */
+async function testMcpLifecycleMethods() {
+    console.log('   🚀 Testing MCP Lifecycle Methods (resources/list, prompts/list)...');
+    let fraimProcess;
+    let dbService;
+    const PORT = Math.floor(Math.random() * 1000) + 13000;
+    const BASE_URL = `http://localhost:${PORT}`;
+    const TEST_API_KEY = 'test-fraim-key-lifecycle';
+    const TEST_ADMIN_KEY = 'test-admin-key-lifecycle';
+    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-lifecycle',
+            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, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${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 initialize (should work without session)
+        console.log('   Testing initialize...');
+        const initRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            method: 'initialize',
+            params: {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'test-client', version: '1.0.0' }
+            },
+            id: 1
+        }, { headers: authHeaders });
+        node_assert_1.default.strictEqual(initRes.status, 200, 'initialize should return 200');
+        node_assert_1.default.ok(initRes.data.result, 'initialize should return result');
+        node_assert_1.default.ok(initRes.data.result.serverInfo, 'initialize should return serverInfo');
+        console.log('   ✅ initialize works without session');
+        // 3. Test tools/list (should work without session)
+        console.log('   Testing tools/list...');
+        const toolsRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            method: 'tools/list',
+            params: {},
+            id: 2
+        }, { headers: authHeaders });
+        node_assert_1.default.strictEqual(toolsRes.status, 200, 'tools/list should return 200');
+        node_assert_1.default.ok(toolsRes.data.result, 'tools/list should return result');
+        node_assert_1.default.ok(Array.isArray(toolsRes.data.result.tools), 'tools/list should return tools array');
+        node_assert_1.default.ok(toolsRes.data.result.tools.length > 0, 'tools/list should return at least one tool');
+        console.log(`   ✅ tools/list works without session (${toolsRes.data.result.tools.length} tools)`);
+        // 4. Test resources/list (THE FIX - should work without session)
+        console.log('   Testing resources/list (THE FIX)...');
+        const resourcesRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            method: 'resources/list',
+            params: {},
+            id: 3
+        }, { headers: authHeaders });
+        node_assert_1.default.strictEqual(resourcesRes.status, 200, 'resources/list should return 200');
+        node_assert_1.default.ok(resourcesRes.data.result, 'resources/list should return result');
+        node_assert_1.default.ok(Array.isArray(resourcesRes.data.result.resources), 'resources/list should return resources array');
+        node_assert_1.default.strictEqual(resourcesRes.data.result.resources.length, 0, 'resources/list should return empty array');
+        console.log('   ✅ resources/list works without session (returns empty array)');
+        // 5. Test prompts/list (THE FIX - should work without session)
+        console.log('   Testing prompts/list (THE FIX)...');
+        const promptsRes = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            method: 'prompts/list',
+            params: {},
+            id: 4
+        }, { headers: authHeaders });
+        node_assert_1.default.strictEqual(promptsRes.status, 200, 'prompts/list should return 200');
+        node_assert_1.default.ok(promptsRes.data.result, 'prompts/list should return result');
+        node_assert_1.default.ok(Array.isArray(promptsRes.data.result.prompts), 'prompts/list should return prompts array');
+        node_assert_1.default.strictEqual(promptsRes.data.result.prompts.length, 0, 'prompts/list should return empty array');
+        console.log('   ✅ prompts/list works without session (returns empty array)');
+        // 6. Test that non-lifecycle methods still require session
+        console.log('   Testing that non-lifecycle methods require session...');
+        try {
+            await axios_1.default.post(`${BASE_URL}/mcp`, {
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                params: {
+                    name: 'get_fraim_workflow',
+                    arguments: { workflow: 'spec' }
+                },
+                id: 5
+            }, { headers: authHeaders, timeout: 2000 });
+            console.error('   ❌ Should have failed with 400 (Session Not Started)');
+            return false;
+        }
+        catch (error) {
+            if (error.response) {
+                node_assert_1.default.strictEqual(error.response.status, 400, 'Should return 400 for tool call without session');
+                node_assert_1.default.match(error.response.data?.error?.message, /Session Not Started/, 'Should mention Session Not Started');
+                console.log('   ✅ Non-lifecycle methods still require session');
+            }
+            else {
+                throw error;
+            }
+        }
+        // 7. Test complete MCP initialization sequence
+        console.log('   Testing complete MCP initialization sequence...');
+        const sequence = [
+            { method: 'initialize', id: 10 },
+            { method: 'notifications/initialized', id: 11 },
+            { method: 'tools/list', id: 12 },
+            { method: 'resources/list', id: 13 },
+            { method: 'prompts/list', id: 14 }
+        ];
+        for (const step of sequence) {
+            const res = await axios_1.default.post(`${BASE_URL}/mcp`, {
+                jsonrpc: '2.0',
+                method: step.method,
+                params: {},
+                id: step.id
+            }, { headers: authHeaders });
+            node_assert_1.default.strictEqual(res.status, 200, `${step.method} should return 200 in sequence`);
+            console.log(`   ✅ ${step.method} succeeded in sequence`);
+        }
+        console.log('   ✅ Complete MCP initialization sequence works without session');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error.message);
+        if (error.response?.data) {
+            console.error('   🔍 Server Error Detail:', JSON.stringify(error.response.data, null, 2));
+        }
+        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()));
+        }
+    }
+}
+/**
+ * Test that bootstrap tools work without session
+ */
+async function testBootstrapTools() {
+    console.log('   🚀 Testing Bootstrap Tools (without session)...');
+    let fraimProcess;
+    let dbService;
+    const PORT = Math.floor(Math.random() * 1000) + 14000;
+    const BASE_URL = `http://localhost:${PORT}`;
+    const TEST_API_KEY = 'test-fraim-key-bootstrap';
+    const TEST_ADMIN_KEY = 'test-admin-key-bootstrap';
+    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-bootstrap',
+            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, '../src/fraim-mcp-server.ts');
+        fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['tsx', `"${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 };
+        // Test bootstrap tools that should work without session
+        const bootstrapTools = [
+            { name: 'get_fraim_init', args: {} },
+            { name: 'list_fraim_workflows', args: {} },
+            { name: 'fraim_get_local_config', args: {} }
+        ];
+        for (const tool of bootstrapTools) {
+            console.log(`   Testing ${tool.name}...`);
+            const res = await axios_1.default.post(`${BASE_URL}/mcp`, {
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                params: {
+                    name: tool.name,
+                    arguments: tool.args
+                },
+                id: 1
+            }, { headers: authHeaders });
+            node_assert_1.default.strictEqual(res.status, 200, `${tool.name} should return 200 without session`);
+            node_assert_1.default.ok(res.data.result, `${tool.name} should return result`);
+            console.log(`   ✅ ${tool.name} works without session`);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed:', error.message);
+        if (error.response?.data) {
+            console.error('   🔍 Server Error Detail:', JSON.stringify(error.response.data, null, 2));
+        }
+        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 Lifecycle Methods',
+        description: 'Tests that resources/list and prompts/list work without session (fix for telemetry blocking)',
+        testFunction: testMcpLifecycleMethods,
+        tags: ['mcp', 'lifecycle', 'telemetry']
+    },
+    {
+        name: 'Bootstrap Tools',
+        description: 'Tests that bootstrap tools work without session',
+        testFunction: testBootstrapTools,
+        tags: ['mcp', 'bootstrap', 'telemetry']
+    }
+];
+(0, test_utils_1.runTests)(testCases, async (t) => t.testFunction(), 'MCP Lifecycle Methods & Bootstrap Tools')
+    .then(() => process.exit(0))
+    .catch((err) => {
+    console.error('Test runner failed:', err);
+    process.exit(1);
+});