fraim-framework 2.0.47 → 2.0.48

package/dist/tests/test-first-run-journey.js

@@ -43,39 +43,24 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 /**
- * Helper to run the interactive first-run experience within 'fraim init'
+ * Helper to run init with TEST_MODE to avoid hanging on prompts
  */
-async function runInteractiveInit(cwd, interactions) {
+async function runNonInteractiveInit(cwd) {
     const cliScript = (0, test_utils_1.resolveProjectPath)('dist/src/cli/fraim.js');
-    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
     return new Promise(resolve => {
-        const ps = (0, node_child_process_1.spawn)(npx, ['node', `"${cliScript}"`, 'init'], {
+        const ps = (0, node_child_process_1.spawn)('node', [cliScript, 'init'], {
             cwd,
-            env: { ...process.env, CI: 'false', TEST_MODE: 'false' },
-            shell: true,
-            stdio: ['pipe', 'pipe', 'pipe']
+            env: { ...process.env, TEST_MODE: 'true' }, // Use TEST_MODE to skip prompts
+            shell: false,
+            stdio: 'pipe'
         });
         let stdout = '';
         let stderr = '';
-        let currentPromptIndex = 0;
         const timeout = setTimeout(() => {
-            console.error('   ❌ Interactive init timed out');
-            ps.kill('SIGKILL');
+            ps.kill('SIGTERM');
             resolve({ stdout, stderr, code: -1 });
-        }, 45000);
-        ps.stdout.on('data', d => {
-            const chunk = d.toString();
-            stdout += chunk;
-            if (currentPromptIndex < interactions.length) {
-                const target = interactions[currentPromptIndex];
-                if (chunk.includes(target.prompt)) {
-                    currentPromptIndex++;
-                    setTimeout(() => {
-                        ps.stdin.write(target.response + '\n');
-                    }, 500);
-                }
-            }
-        });
+        }, 10000);
+        ps.stdout.on('data', d => stdout += d.toString());
         ps.stderr.on('data', d => stderr += d.toString());
         ps.on('close', code => {
             clearTimeout(timeout);
@@ -83,24 +68,113 @@ async function runInteractiveInit(cwd, interactions) {
         });
     });
 }
+/**
+ * Helper to run first-run experience directly to test configuration detection
+ */
+async function runFirstRunExperience(cwd, clearGlobalConfig = false) {
+    const globalConfigPath = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+    const backupPath = globalConfigPath + '.backup-test';
+    let configMoved = false;
+    // Temporarily move global config if needed
+    if (clearGlobalConfig && fs_1.default.existsSync(globalConfigPath)) {
+        try {
+            fs_1.default.renameSync(globalConfigPath, backupPath);
+            configMoved = true;
+        }
+        catch (e) {
+            // Ignore if we can't move it
+        }
+    }
+    return new Promise(resolve => {
+        // Import and run the first-run experience directly
+        const { runFirstRunExperience } = require((0, test_utils_1.resolveProjectPath)('dist/src/cli/setup/first-run.js'));
+        // Capture console output
+        let stdout = '';
+        const originalLog = console.log;
+        const originalWarn = console.warn;
+        console.log = (...args) => {
+            stdout += args.join(' ') + '\n';
+            originalLog(...args);
+        };
+        console.warn = (...args) => {
+            stdout += args.join(' ') + '\n';
+            originalWarn(...args);
+        };
+        const timeout = setTimeout(() => {
+            console.log = originalLog;
+            console.warn = originalWarn;
+            resolve({ stdout, stderr: '', code: -1 });
+        }, 5000);
+        // Set TEST_MODE to avoid interactive prompts
+        const originalTestMode = process.env.TEST_MODE;
+        process.env.TEST_MODE = 'true';
+        runFirstRunExperience()
+            .then(() => {
+            clearTimeout(timeout);
+            console.log = originalLog;
+            console.warn = originalWarn;
+            process.env.TEST_MODE = originalTestMode;
+            // Restore global config if we moved it
+            if (configMoved && fs_1.default.existsSync(backupPath)) {
+                try {
+                    fs_1.default.renameSync(backupPath, globalConfigPath);
+                }
+                catch (e) {
+                    // Ignore restore errors
+                }
+            }
+            resolve({ stdout, stderr: '', code: 0 });
+        })
+            .catch((error) => {
+            clearTimeout(timeout);
+            console.log = originalLog;
+            console.warn = originalWarn;
+            process.env.TEST_MODE = originalTestMode;
+            // Restore global config if we moved it
+            if (configMoved && fs_1.default.existsSync(backupPath)) {
+                try {
+                    fs_1.default.renameSync(backupPath, globalConfigPath);
+                }
+                catch (e) {
+                    // Ignore restore errors
+                }
+            }
+            resolve({ stdout, stderr: error.message, code: 1 });
+        });
+    });
+}
 const testCases = [
     {
-        name: 'Journey: Setup with Key, No Arch Doc',
+        name: 'Journey: Non-Interactive Init Works',
         testFunction: async () => {
             const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-1-'));
             try {
                 // Set up git repository with remote (required for new init logic)
                 const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-                execSync('git init', { cwd: tempDir });
-                execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir });
-                const res = await runInteractiveInit(tempDir, [
-                    { prompt: 'Do you have a FRAIM key?', response: 'key-123' },
-                    { prompt: 'Do you have an architecture document', response: 'n' }
-                ]);
-                node_assert_1.default.strictEqual(res.code, 0);
-                node_assert_1.default.ok(res.stdout.includes('Key received'));
-                node_assert_1.default.ok(res.stdout.includes('Run the bootstrap/create-architecture workflow'));
-                // VERIFY STUBS EXIST
+                execSync('git init', { cwd: tempDir, stdio: 'ignore' });
+                execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir, stdio: 'ignore' });
+                // Create a dummy commit and set up the remote HEAD
+                try {
+                    execSync('git config user.email "test@example.com"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git config user.name "Test User"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('echo "# Test" > README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git add README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git commit -m "Initial commit"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git branch -M master', { cwd: tempDir, stdio: 'ignore' });
+                }
+                catch (e) {
+                    // Ignore git setup errors for test
+                }
+                const res = await runNonInteractiveInit(tempDir);
+                node_assert_1.default.strictEqual(res.code, 0, `Init failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+                node_assert_1.default.ok(res.stdout.includes('FRAIM initialized successfully'), 'Expected success message');
+                // VERIFY CONFIG EXISTS
+                const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+                node_assert_1.default.ok(fs_1.default.existsSync(configPath), 'Config file missing');
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                node_assert_1.default.strictEqual(config.repository.owner, 'test-owner', 'Owner not detected correctly');
+                node_assert_1.default.strictEqual(config.repository.name, 'test-repo', 'Repo name not detected correctly');
+                // VERIFY WORKFLOWS EXIST
                 const workflowsDir = path_1.default.join(tempDir, '.fraim', 'workflows');
                 node_assert_1.default.ok(fs_1.default.existsSync(workflowsDir), 'Workflows dir missing');
                 const stubs = fs_1.default.readdirSync(workflowsDir);
@@ -108,41 +182,187 @@ const testCases = [
                 return true;
             }
             finally {
-                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                // Better cleanup for Windows
+                try {
+                    if (fs_1.default.existsSync(tempDir)) {
+                        // Try to remove read-only attributes on Windows
+                        if (process.platform === 'win32') {
+                            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                            try {
+                                execSync(`attrib -R "${tempDir}\\*.*" /S /D`, { stdio: 'ignore' });
+                            }
+                            catch (e) {
+                                // Ignore attrib errors
+                            }
+                        }
+                        fs_1.default.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+                    }
+                }
+                catch (e) {
+                    console.warn(`Warning: Could not clean up temp dir ${tempDir}:`, e instanceof Error ? e.message : String(e));
+                }
             }
         },
         tags: ['cli', 'journey', 'init']
     },
     {
-        name: 'Journey: Setup with Arch Doc Path',
+        name: 'Journey: Config Structure is Clean',
         testFunction: async () => {
             const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-2-'));
-            const archPath = 'docs/my-architecture.md';
             try {
                 // Set up git repository with remote (required for new init logic)
                 const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-                execSync('git init', { cwd: tempDir });
-                execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir });
-                fs_1.default.mkdirSync(path_1.default.join(tempDir, '.fraim'), { recursive: true });
-                fs_1.default.writeFileSync(path_1.default.join(tempDir, '.fraim', 'config.json'), JSON.stringify({ version: '1.0.0' }));
-                fs_1.default.mkdirSync(path_1.default.join(tempDir, 'docs'), { recursive: true });
-                fs_1.default.writeFileSync(path_1.default.join(tempDir, archPath), '# Arch');
-                const res = await runInteractiveInit(tempDir, [
-                    { prompt: 'Do you have a FRAIM key?', response: '' },
-                    { prompt: 'Do you have an architecture document', response: 'y' },
-                    { prompt: 'provide the relative path', response: archPath }
-                ]);
-                node_assert_1.default.strictEqual(res.code, 0);
-                node_assert_1.default.ok(res.stdout.includes(`Linked architecture document: ${archPath}`));
-                const config = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tempDir, '.fraim', 'config.json'), 'utf8'));
-                node_assert_1.default.strictEqual(config.customizations.architectureDoc, archPath);
+                execSync('git init', { cwd: tempDir, stdio: 'ignore' });
+                execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir, stdio: 'ignore' });
+                // Create a dummy commit and set up the remote HEAD
+                try {
+                    execSync('git config user.email "test@example.com"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git config user.name "Test User"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('echo "# Test" > README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git add README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git commit -m "Initial commit"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git branch -M master', { cwd: tempDir, stdio: 'ignore' });
+                }
+                catch (e) {
+                    // Ignore git setup errors for test
+                }
+                const res = await runNonInteractiveInit(tempDir);
+                node_assert_1.default.strictEqual(res.code, 0, `Init failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+                const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+                node_assert_1.default.ok(fs_1.default.existsSync(configPath), 'Config file missing');
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                // Verify clean structure
+                node_assert_1.default.ok(config.version, 'Version missing');
+                node_assert_1.default.ok(config.project, 'Project section missing');
+                node_assert_1.default.ok(config.repository, 'Repository section missing');
+                node_assert_1.default.ok(config.customizations, 'Customizations section missing');
+                // Verify no optional fields are present unless needed
+                node_assert_1.default.strictEqual(config.persona, undefined, 'Persona should not be present in clean config');
+                node_assert_1.default.strictEqual(config.marketing, undefined, 'Marketing should not be present in clean config');
+                node_assert_1.default.strictEqual(config.database, undefined, 'Database should not be present in clean config');
                 return true;
             }
             finally {
-                fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                // Better cleanup for Windows
+                try {
+                    if (fs_1.default.existsSync(tempDir)) {
+                        // Try to remove read-only attributes on Windows
+                        if (process.platform === 'win32') {
+                            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                            try {
+                                execSync(`attrib -R "${tempDir}\\*.*" /S /D`, { stdio: 'ignore' });
+                            }
+                            catch (e) {
+                                // Ignore attrib errors
+                            }
+                        }
+                        fs_1.default.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+                    }
+                }
+                catch (e) {
+                    console.warn(`Warning: Could not clean up temp dir ${tempDir}:`, e instanceof Error ? e.message : String(e));
+                }
             }
         },
         tags: ['cli', 'journey', 'init']
+    },
+    {
+        name: 'Journey: First Run Detects Existing Global Config',
+        testFunction: async () => {
+            // This test verifies that when a global FRAIM config exists,
+            // the first-run experience detects it and skips key setup
+            const res = await runFirstRunExperience('', false); // Don't clear global config
+            node_assert_1.default.strictEqual(res.code, 0, `First-run failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+            // Should detect existing configuration
+            node_assert_1.default.ok(res.stdout.includes('Found existing FRAIM configuration') ||
+                res.stdout.includes('Found FRAIM MCP configuration') ||
+                res.stdout.includes('Skipping interactive first-run experience'), 'Should detect existing configuration');
+            // Should NOT ask for FRAIM key
+            node_assert_1.default.ok(!res.stdout.includes('Do you have a FRAIM key?'), 'Should not ask for FRAIM key when config exists');
+            return true;
+        },
+        tags: ['cli', 'journey', 'first-run', 'config-detection']
+    },
+    {
+        name: 'Journey: First Run From Scratch (No Existing Config)',
+        testFunction: async () => {
+            // This test verifies the first-run experience when no configuration exists
+            const res = await runFirstRunExperience('', true); // Clear global config
+            node_assert_1.default.strictEqual(res.code, 0, `First-run failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+            // In TEST_MODE, should skip interactive setup
+            node_assert_1.default.ok(res.stdout.includes('Skipping interactive first-run experience'), 'Should skip interactive setup in TEST_MODE');
+            return true;
+        },
+        tags: ['cli', 'journey', 'first-run', 'fresh-install']
+    },
+    {
+        name: 'Journey: First Run Detects MCP Configuration',
+        testFunction: async () => {
+            // This test verifies that MCP configuration detection works
+            const kiroConfigPath = path_1.default.join(os_1.default.homedir(), '.kiro', 'settings', 'mcp.json');
+            // Check if Kiro MCP config exists (it should in this environment)
+            if (fs_1.default.existsSync(kiroConfigPath)) {
+                const res = await runFirstRunExperience('', true); // Clear global config but keep MCP
+                node_assert_1.default.strictEqual(res.code, 0, `First-run failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+                // In TEST_MODE, should skip but we can verify the detection logic works
+                // by checking that the function completes without errors
+                node_assert_1.default.ok(res.stdout.includes('Skipping interactive first-run experience'), 'Should skip interactive setup in TEST_MODE');
+            }
+            return true;
+        },
+        tags: ['cli', 'journey', 'first-run', 'mcp-detection']
+    },
+    {
+        name: 'Journey: Default Branch Detection Works',
+        testFunction: async () => {
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'fraim-jour-branch-'));
+            try {
+                // Set up git repository with master branch (not main)
+                const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                execSync('git init', { cwd: tempDir, stdio: 'ignore' });
+                execSync('git remote add origin https://github.com/test-owner/test-repo.git', { cwd: tempDir, stdio: 'ignore' });
+                try {
+                    execSync('git config user.email "test@example.com"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git config user.name "Test User"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('echo "# Test" > README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git add README.md', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git commit -m "Initial commit"', { cwd: tempDir, stdio: 'ignore' });
+                    execSync('git branch -M master', { cwd: tempDir, stdio: 'ignore' });
+                }
+                catch (e) {
+                    // Ignore git setup errors for test
+                }
+                const res = await runNonInteractiveInit(tempDir);
+                node_assert_1.default.strictEqual(res.code, 0, `Init failed with code ${res.code}. Stdout: ${res.stdout}. Stderr: ${res.stderr}`);
+                const configPath = path_1.default.join(tempDir, '.fraim', 'config.json');
+                node_assert_1.default.ok(fs_1.default.existsSync(configPath), 'Config file missing');
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                // Should detect master as default branch (not main)
+                node_assert_1.default.strictEqual(config.repository.defaultBranch, 'master', 'Should detect master as default branch');
+                return true;
+            }
+            finally {
+                // Better cleanup for Windows
+                try {
+                    if (fs_1.default.existsSync(tempDir)) {
+                        if (process.platform === 'win32') {
+                            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                            try {
+                                execSync(`attrib -R "${tempDir}\\*.*" /S /D`, { stdio: 'ignore' });
+                            }
+                            catch (e) {
+                                // Ignore attrib errors
+                            }
+                        }
+                        fs_1.default.rmSync(tempDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+                    }
+                }
+                catch (e) {
+                    console.warn(`Warning: Could not clean up temp dir ${tempDir}:`, e instanceof Error ? e.message : String(e));
+                }
+            }
+        },
+        tags: ['cli', 'journey', 'git', 'branch-detection']
     }
 ];
 (0, test_utils_1.runTests)(testCases, (tc) => tc.testFunction(), 'Fraim Setup Journeys');

package/dist/tests/test-fraim-issues.js

@@ -29,7 +29,7 @@ async function testMissingToken() {
             body: 'Test Body'
         });
         node_assert_1.default.strictEqual(result.success, false, 'Should fail without token');
-        node_assert_1.default.strictEqual(result.message, 'GITHUB_TOKEN environment variable is required', 'Should return correct error message');
+        node_assert_1.default.ok(result.message && result.message.includes('GitHub integration requires GITHUB_TOKEN environment variable'), 'Should return correct error message');
         return true;
     }
     finally {

package/dist/tests/test-genericization.js

@@ -6,11 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const test_utils_1 = require("./test-utils");
 const node_assert_1 = __importDefault(require("node:assert"));
 const types_1 = require("../src/fraim/types");
-const template_processor_1 = require("../src/fraim/template-processor");
 async function testConfigDefaults() {
     console.log('   🧪 Testing DEFAULT_FRAIM_CONFIG placeholders...');
     try {
-        node_assert_1.default.strictEqual(types_1.DEFAULT_FRAIM_CONFIG.persona.name, 'AI Agent', 'Default persona name should be "AI Agent"');
         node_assert_1.default.ok(types_1.DEFAULT_FRAIM_CONFIG.customizations?.workflowsPath, 'workflowsPath should exist');
         // Architecture and Testing sections removed
         return true;
@@ -21,28 +19,10 @@ async function testConfigDefaults() {
     }
 }
 async function testTemplateProcessor() {
-    console.log('   🧪 Testing Template Processor with new config fields...');
-    try {
-        const mockConfig = {
-            ...types_1.DEFAULT_FRAIM_CONFIG,
-            project: { ...types_1.DEFAULT_FRAIM_CONFIG.project, name: 'Generic Bot' },
-            persona: { ...types_1.DEFAULT_FRAIM_CONFIG.persona, name: 'Ava' },
-            marketing: {
-                ...types_1.DEFAULT_FRAIM_CONFIG.marketing,
-                websiteUrl: 'https://ava.ai',
-                chatUrl: 'https://chat.ava.ai'
-            }
-        };
-        const template = 'Welcome to {{config.project.name}}. I am {{config.persona.name}}. Visit {{config.marketing.websiteUrl}} or chat at {{config.marketing.chatUrl}}.';
-        const processed = (0, template_processor_1.processTemplateVariables)(template, mockConfig);
-        const expected = 'Welcome to Generic Bot. I am Ava. Visit https://ava.ai or chat at https://chat.ava.ai.';
-        node_assert_1.default.strictEqual(processed, expected, 'Template variables should be correctly replaced');
-        return true;
-    }
-    catch (e) {
-        console.error('   ❌ Template processing verification failed:', e);
-        return false;
-    }
+    console.log('   🧪 Testing Template Processor (removed - no longer needed)...');
+    // Template processing has been removed since no workflows use {{config.*}} variables
+    // and personalization happens when agents read .fraim/config.json directly
+    return true;
 }
 const testCases = [
     {
@@ -53,7 +33,7 @@ const testCases = [
     },
     {
         name: 'Template Processor',
-        description: 'Verify template variables for new config fields',
+        description: 'Verify template processing has been simplified (no longer processes config variables)',
         testFunction: testTemplateProcessor,
         tags: ['templates', 'genericization']
     }

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

@@ -70,6 +70,10 @@ async function testFileIssueToolAPI() {
             params: {
                 name: 'fraim_connect',
                 arguments: {
+                    agent: {
+                        name: 'Claude',
+                        model: 'claude-3.5-sonnet'
+                    },
                     machine: { hostname: 'test-host', platform: process.platform },
                     repo: { url: 'https://github.com/test/repo' }
                 }
@@ -102,8 +106,8 @@ async function testFileIssueToolAPI() {
         // The server may prepend a warning message if versions don't match
         let contentText = response.data.result.content[0].text;
         // If first content is a version warning, use the second content item
-        if (contentText.includes('[FRAIM VERSION MISMATCH]')) {
-            console.log('   ℹ️  Version mismatch warning detected (expected in test environment)');
+        if (contentText.includes('FRAIM Update Available')) {
+            console.log('   ℹ️  Version update notice detected (expected in test environment)');
             node_assert_1.default.ok(response.data.result.content.length > 1, 'Should have result after warning');
             contentText = response.data.result.content[1].text;
         }

package/dist/tests/test-mcp-template-processing.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Test MCP Server Template Processing
+ *
+ * Verifies that the MCP server correctly processes workflow templates
+ * with provider-specific actions when serving workflows.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMcpTemplateProcessing = testMcpTemplateProcessing;
+const axios_1 = __importDefault(require("axios"));
+const db_service_1 = require("../src/fraim/db-service");
+const shared_server_utils_1 = require("./shared-server-utils");
+const MCP_URL = (0, shared_server_utils_1.getMcpEndpoint)();
+const TEST_API_KEY = 'test-mcp-template-key';
+async function testMcpTemplateProcessing() {
+    console.log('🧪 Testing MCP Server Template Processing...');
+    const dbService = new db_service_1.FraimDbService();
+    try {
+        // Wait for server to be ready
+        await (0, shared_server_utils_1.waitForServer)();
+        await dbService.connect();
+        // Set up test API key in database
+        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-template',
+            orgId: 'test-org',
+            isActive: true,
+            createdAt: new Date()
+        });
+        // First connect to establish session
+        console.log('   Setting up session...');
+        await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 0,
+            method: 'tools/call',
+            params: {
+                name: 'fraim_connect',
+                arguments: {
+                    agent: {
+                        name: 'Claude',
+                        model: 'claude-3.5-sonnet'
+                    },
+                    machine: {
+                        hostname: 'test-machine',
+                        platform: 'linux'
+                    },
+                    repo: {
+                        url: 'https://github.com/test/repo.git'
+                    }
+                }
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        // Test 1: Get a real workflow (spec)
+        console.log('   Test 1: Get spec workflow...');
+        const workflowResponse = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/call',
+            params: {
+                name: 'get_fraim_workflow',
+                arguments: {
+                    workflow: 'spec'
+                }
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        if (workflowResponse.status !== 200) {
+            throw new Error(`Expected 200, got ${workflowResponse.status}`);
+        }
+        const workflowContent = workflowResponse.data.result.content[0].text;
+        // Should contain the workflow content
+        if (!workflowContent.includes('Specification Phase')) {
+            throw new Error('Spec workflow content not found');
+        }
+        // Should show platform info
+        if (!workflowContent.includes('**Platform:** GITHUB')) {
+            throw new Error('Template processing failed - missing platform info');
+        }
+        console.log('   ✅ Spec workflow processed correctly');
+        // Test 2: Verify template actions are replaced
+        console.log('   Test 2: Verify template actions are replaced...');
+        // Should NOT contain raw template actions
+        if (workflowContent.includes('{{get_issue}}')) {
+            throw new Error('Template processing incomplete - raw template actions still present');
+        }
+        console.log('   ✅ Template actions properly replaced');
+        // Test 3: Test workflow list still works
+        console.log('   Test 3: Test workflow list functionality...');
+        const listResponse = await axios_1.default.post(MCP_URL, {
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'tools/call',
+            params: {
+                name: 'list_fraim_workflows',
+                arguments: {}
+            }
+        }, {
+            headers: { 'x-api-key': TEST_API_KEY }
+        });
+        if (listResponse.status !== 200) {
+            throw new Error(`Expected 200, got ${listResponse.status}`);
+        }
+        const listContent = listResponse.data.result.content[0].text;
+        // Should include spec workflow
+        if (!listContent.includes('spec')) {
+            throw new Error('Spec workflow not found in workflow list');
+        }
+        console.log('   ✅ Workflow list functionality works');
+        console.log('✅ All MCP Server Template Processing tests passed!');
+        console.log(`
+📋 **Template Processing Verified**: 
+- ✅ Workflow content retrieved correctly
+- ✅ Platform detection working
+- ✅ Workflow discovery still functional
+        `);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ MCP Server Template Processing test failed:', error.message);
+        if (error.response?.data) {
+            console.error('   Response data:', JSON.stringify(error.response.data, null, 2));
+        }
+        return false;
+    }
+    finally {
+        // Clean up
+        if (dbService) {
+            try {
+                const db = dbService.db;
+                await db.collection('fraim_api_keys').deleteOne({ key: TEST_API_KEY });
+                await db.collection('fraim_telemetry_sessions').deleteMany({ userId: 'test-user-mcp-template' });
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+            await dbService.close();
+        }
+    }
+}
+// Run if called directly
+if (require.main === module) {
+    testMcpTemplateProcessing()
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+        console.error('Test runner error:', err);
+        process.exit(1);
+    });
+}