fraim-framework 2.0.26 → 2.0.30

package/dist/src/fraim-mcp-server.js

@@ -45,6 +45,8 @@ const path_1 = require("path");
 const git_utils_1 = require("./utils/git-utils");
 const config_loader_1 = require("./fraim/config-loader");
 const db_service_1 = require("./fraim/db-service");
+const issues_1 = require("./fraim/issues");
+const crypto_1 = require("crypto");
 const dotenv = __importStar(require("dotenv"));
 // Load environment variables
 dotenv.config();
@@ -62,17 +64,82 @@ console.log('🚀 FRAIM MCP Server starting up...');
 console.log(`📂 Working Directory: ${process.cwd()}`);
 console.log(`🏠 Dirname: ${__dirname}`);
 try {
-    const fs = require('fs');
-    const path = require('path');
-    console.log('files in current dir:', fs.readdirSync(process.cwd()).join(', '));
-    const distPath = path.join(process.cwd(), 'dist');
-    if (fs.existsSync(distPath)) {
-        console.log('files in dist:', fs.readdirSync(distPath).join(', '));
+    console.log('files in current dir:', (0, fs_1.readdirSync)(process.cwd()).join(', '));
+    const distPath = (0, path_1.join)(process.cwd(), 'dist');
+    if ((0, fs_1.existsSync)(distPath)) {
+        console.log('files in dist:', (0, fs_1.readdirSync)(distPath).join(', '));
     }
 }
 catch (e) {
     console.warn('⚠️ Could not log directory structure:', e.message);
 }
+class SessionManager {
+    constructor(dbService) {
+        this.sessions = new Map();
+        this.dbService = dbService;
+        // Default 1m, configurable for testing
+        this.FLUSH_INTERVAL_MS = process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL
+            ? parseInt(process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL)
+            : 60 * 1000;
+        // Flush on shutdown
+        const cleanup = async () => {
+            console.log('🛑 Flushing telemetry sessions before shutdown...');
+            // Race flush with a 2s timeout to guarantee exit
+            const timeout = new Promise(resolve => setTimeout(resolve, 2000));
+            await Promise.race([this.flushAll(), timeout]);
+            console.log('🛑 Shutdown flush complete (or timed out). Exiting.');
+            process.exit(0);
+        };
+        process.on('SIGTERM', cleanup);
+        process.on('SIGINT', cleanup);
+    }
+    registerSession(apiKey, sessionId) {
+        const now = Date.now();
+        this.sessions.set(apiKey, { sessionId, lastWrite: now, lastActive: now });
+    }
+    async updateActivity(apiKey) {
+        let session = this.sessions.get(apiKey);
+        const now = Date.now();
+        if (!session) {
+            // Re-hydration: Check DB for an active session for this API Key
+            try {
+                const dbSession = await this.dbService.getActiveSessionByApiKey(apiKey);
+                if (dbSession) {
+                    console.log(`🔄 Re-hydrating session for API Key: ${apiKey}`);
+                    session = {
+                        sessionId: dbSession.sessionId,
+                        lastWrite: now,
+                        lastActive: now
+                    };
+                    this.sessions.set(apiKey, session);
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (e) {
+                console.error('⚠️ Failed to re-hydrate session from DB:', e);
+                return false;
+            }
+        }
+        session.lastActive = now;
+        // Write-behind: Only flush to DB if > Interval elapsed
+        if (now - session.lastWrite > this.FLUSH_INTERVAL_MS) {
+            // Async write
+            this.dbService.updateSessionActivity(session.sessionId, new Date(now)).catch(e => console.error('⚠️ Failed to flush session activity:', e));
+            session.lastWrite = now;
+        }
+        return true;
+    }
+    async flushAll() {
+        const promises = [];
+        for (const [_, data] of this.sessions) {
+            // Flush the memory lastActive time
+            promises.push(this.dbService.updateSessionActivity(data.sessionId, new Date(data.lastActive)));
+        }
+        await Promise.allSettled(promises);
+    }
+}
 class FraimMCPServer {
     constructor() {
         this.fileIndex = new Map();
@@ -101,6 +168,7 @@ class FraimMCPServer {
         }
         // Initialize database service
         this.dbService = new db_service_1.FraimDbService();
+        this.sessionManager = new SessionManager(this.dbService);
         // Load FRAIM configuration
         this.config = (0, config_loader_1.loadFraimConfig)();
         // Find registry directory (check dist first for production, then source)
@@ -121,6 +189,7 @@ class FraimMCPServer {
             });
         });
         this.app.use(this.authMiddleware.bind(this));
+        this.app.use(this.telemetryMiddleware.bind(this));
         this.setupRoutes();
     }
     /**
@@ -139,16 +208,19 @@ class FraimMCPServer {
                 console.info(`${keyStr} ${method} ${path} ${status} ${duration}ms ${params}`);
             }
             // Log usage if authenticated
+            // DISABLE: Granular logging disabled in favor of Session Keep-Alive
+            /*
             if (apiKey) {
-                this.dbService.logUsage({
-                    keyId: apiKey.key,
-                    userId: apiKey.userId,
-                    method,
-                    path,
-                    status,
-                    duration
-                }).catch(e => console.error('⚠️ Failed to log usage:', e.message));
+              this.dbService.logUsage({
+                keyId: apiKey.key,
+                userId: apiKey.userId,
+                method,
+                path,
+                status,
+                duration
+              }).catch(e => console.error('⚠️ Failed to log usage:', (e as Error).message));
             }
+            */
         });
         next();
     }
@@ -246,6 +318,60 @@ class FraimMCPServer {
         }
         return next();
     }
+    /**
+     * Middleware to enforce Session Handshake and track activity
+     */
+    async telemetryMiddleware(req, res, next) {
+        // Skip for non-authenticated or exempt paths
+        const exemptPaths = ['/health', '/admin', '/mcp'];
+        if (exemptPaths.some(p => req.path.startsWith(p)) && req.method === 'GET') {
+            return next();
+        }
+        // 1. Standard MCP Lifecycle & Discovery methods (Initialize, List Tools/Resources/Prompts, etc.)
+        const exemptMethods = [
+            'initialize',
+            'notifications/initialized',
+            'tools/list',
+            'resources/list',
+            'prompts/list',
+            'logging/setLevel'
+        ];
+        if (req.body && exemptMethods.includes(req.body.method)) {
+            return next();
+        }
+        // 2. FRAIM Bootstrap/Discovery Tools that don't need an active session
+        if (req.body && req.body.method === 'tools/call') {
+            const toolName = req.body.params?.name;
+            const safeTools = [
+                'fraim_connect',
+                'get_fraim_init',
+                'list_fraim_workflows',
+                'fraim_get_local_config'
+            ];
+            if (safeTools.includes(toolName))
+                return next();
+        }
+        const apiKey = req.apiKeyData?.key;
+        if (!apiKey)
+            return next(); // Auth middleware handles 401 earlier
+        // Check Session
+        const isActive = await this.sessionManager.updateActivity(apiKey);
+        if (!isActive) {
+            console.log(`⛔ Telemetry blocked request: ${req.method} ${req.path} (No Session for ${apiKey})`);
+            // Enforce Handshake
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32600,
+                    message: "⛔ Session Not Started. Please call the 'fraim_connect' tool first to register your environment and begin the session."
+                },
+                id: req.body?.id || null
+            });
+            return;
+        }
+        console.log(`✅ Telemetry active for ${apiKey}`);
+        return next();
+    }
     /**
      * Get the Express application for mounting in another server
      * This allows FRAIM routes to be accessible on the main server port (e.g., on Azure)
@@ -584,8 +710,18 @@ class FraimMCPServer {
                     'Connection': 'keep-alive',
                     'Access-Control-Allow-Origin': '*'
                 });
-                res.write(': FRAIM MCP Server\n\n');
-                res.write('data: connected\n\n');
+                // Handle client disconnects to prevent server crash
+                res.on('error', (err) => {
+                    console.error('⚠️ SSE stream error:', err);
+                });
+                res.write('event: endpoint\n');
+                // Use absolute URL to be safe
+                const protocol = req.protocol;
+                const host = req.get('host');
+                res.write(`data: ${protocol}://${host}/mcp\n\n`);
+                // Remove confusing "connected" message that might interfere with protocol
+                // res.write(': FRAIM MCP Server\n\n'); 
+                // res.write('data: connected\n\n');
                 return;
             }
             // Regular GET request
@@ -631,8 +767,23 @@ class FraimMCPServer {
                 else if (method === 'tools/list') {
                     result = this.handleListTools();
                 }
+                else if (method === 'resources/list') {
+                    result = this.handleListResources();
+                }
+                else if (method === 'prompts/list') {
+                    result = this.handleListPrompts();
+                }
                 else if (method === 'tools/call') {
-                    result = await this.handleToolCall(params);
+                    // Pass API Key context to handleToolCall
+                    const context = {
+                        apiKey: req.apiKeyData?.key,
+                        userId: req.apiKeyData?.userId
+                    };
+                    result = await this.handleToolCall(params, context);
+                }
+                else if (method === 'notifications/initialized') {
+                    // Client initialized notification - no response needed but must not error
+                    return res.json({ jsonrpc: '2.0', id: id || null, result: true });
                 }
                 else {
                     throw new Error(`Unknown method: ${method}`);
@@ -699,6 +850,28 @@ Call this before fetching any workflow or file to understand the system.`,
                         required: []
                     }
                 },
+                {
+                    name: 'fraim_connect',
+                    description: `Handshake to start a FRAIM session. MUST be called at the start of every session.
+Registers your environment (machine/repo) for telemetry and unlocks other tools.`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            machine: {
+                                type: 'object',
+                                description: 'Machine specs (hostname, platform, memory, cpus)',
+                                additionalProperties: true
+                            },
+                            repo: {
+                                type: 'object',
+                                description: 'Repository context (owner, name, url)',
+                                required: ['url'],
+                                additionalProperties: true
+                            }
+                        },
+                        required: ['machine', 'repo']
+                    }
+                },
                 {
                     name: 'get_fraim_file',
                     description: `Get a specific file from FRAIM by path.
@@ -776,11 +949,51 @@ Use this to discover which workflow to call with get_fraim_workflow.`,
                         properties: {},
                         required: []
                     }
+                },
+                {
+                    name: 'file_issue',
+                    description: `Create a GitHub issue in the FRAIM repository.
+          
+Use this tool when you need to report a bug, request a feature, or track a task.
+Supports dry-run mode to preview the operation.`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            title: {
+                                type: 'string',
+                                description: 'Title of the issue'
+                            },
+                            body: {
+                                type: 'string',
+                                description: 'Body/Content of the issue'
+                            },
+                            labels: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'List of labels to apply'
+                            },
+                            dryRun: {
+                                type: 'boolean',
+                                description: 'If true, simulates the creation without actually notifying GitHub'
+                            }
+                        },
+                        required: ['title', 'body']
+                    }
                 }
             ]
         };
     }
-    async handleToolCall(params) {
+    handleListResources() {
+        return {
+            resources: []
+        };
+    }
+    handleListPrompts() {
+        return {
+            prompts: []
+        };
+    }
+    async handleToolCall(params, context = {}) {
         const { name: toolName, arguments: toolArgs } = params;
         switch (toolName) {
             case 'get_fraim_init':
@@ -793,6 +1006,16 @@ Use this to discover which workflow to call with get_fraim_workflow.`,
                 return await this.handleListWorkflows();
             case 'fraim_get_local_config':
                 return await this.handleGetLocalConfig();
+            case 'file_issue':
+                const result = await (0, issues_1.fileFraimIssue)(toolArgs);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2)
+                        }]
+                };
+            case 'fraim_connect':
+                return await this.handleFraimConnect(toolArgs, context.apiKey, context.userId);
             default:
                 throw new Error(`Unknown tool: ${toolName} `);
         }
@@ -1196,6 +1419,37 @@ If \`.fraim/config.json\` doesn't exist:
             ]
         };
     }
+    async handleFraimConnect(args, apiKey, userId) {
+        if (!apiKey) {
+            throw new Error('No API Key found in context for fraim_connect');
+        }
+        // 1. Generate Session ID
+        const sessionId = (0, crypto_1.randomUUID)();
+        // userId passed from context
+        const finalUserId = userId || 'unknown';
+        // 2. Create Session in DB
+        const session = {
+            sessionId,
+            userId: finalUserId,
+            machine: args.machine || {},
+            repo: args.repo || {},
+            startTime: new Date(),
+            lastActive: new Date()
+        };
+        const keyData = await this.dbService.verifyApiKey(apiKey);
+        if (keyData)
+            session.userId = keyData.userId;
+        await this.dbService.createSession(session);
+        // 3. Register in SessionManager
+        this.sessionManager.registerSession(apiKey, sessionId);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Connected! Session ID: ${sessionId}. Telemetry active.`
+                }],
+            sessionId: sessionId
+        };
+    }
     async start(port = 3002) {
         try {
             // Connect to database before starting server

package/dist/src/utils/git-utils.js

@@ -40,7 +40,7 @@ function determineDatabaseName() {
     catch (e) {
         // Silently fail
     }
-    return process.env.MONGODB_DB_NAME || 'fraim_dev';
+    return process.env.MONGODB_DB_NAME || (process.env.NODE_ENV === 'production' ? 'fraim_prod' : 'fraim_dev');
 }
 /**
  * Gets the current git branch name

package/dist/src/utils/version-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFraimVersion = getFraimVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getFraimVersion() {
+    // Try reliable paths to find package.json relative to this file
+    // locally: src/utils/version-utils.ts -> package.json is ../../package.json
+    // dist: dist/src/utils/version-utils.js -> package.json is ../../../package.json
+    const possiblePaths = [
+        path_1.default.join(__dirname, '../../package.json'), // Local dev (src)
+        path_1.default.join(__dirname, '../../../package.json'), // Dist (dist/src)
+        path_1.default.join(process.cwd(), 'package.json') // Fallback to CWD (unlikely to be correct for global install but safe fallback)
+    ];
+    for (const pkgPath of possiblePaths) {
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'fraim-framework') {
+                    return pkg.version;
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+    }
+    return '1.0.0'; // Fallback
+}

package/dist/tests/debug-tools.js

@@ -0,0 +1,79 @@
+"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 tree_kill_1 = __importDefault(require("tree-kill"));
+const path_1 = __importDefault(require("path"));
+async function debugListTools() {
+    console.log('   🔍 Debugging Available Tools...');
+    let fraimProcess;
+    let dbService;
+    const PORT = 10003;
+    const TEST_API_KEY = 'debug-tools-key';
+    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: 'debug@test.com', orgId: 'debug-org', isActive: true, createdAt: new Date() } }, { upsert: true });
+        // 2. Start server
+        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' },
+            shell: true
+        });
+        // 3. Wait for start
+        let started = false;
+        for (let i = 0; i < 15; i++) {
+            try {
+                await axios_1.default.get(`${BASE_URL}/health`, { timeout: 1000 });
+                started = true;
+                break;
+            }
+            catch (e) {
+                await new Promise(r => setTimeout(r, 1000));
+            }
+        }
+        if (!started)
+            return false;
+        // 4. Call tools/list
+        const response = await axios_1.default.post(`${BASE_URL}/mcp`, {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'tools/list',
+            params: {}
+        }, { headers: { 'x-api-key': TEST_API_KEY } });
+        console.log('   🛠️  Tools found:');
+        response.data.result.tools.forEach((t) => {
+            console.log(`   - ${t.name}: ${t.description.split('\n')[0]}`);
+        });
+        const hasFraimConnect = response.data.result.tools.some((t) => t.name === 'fraim_connect');
+        console.log(`   ❓ Has fraim_connect: ${hasFraimConnect}`);
+        return true;
+    }
+    catch (e) {
+        console.error(e);
+        return false;
+    }
+    finally {
+        if (dbService)
+            await dbService.close().catch(() => { });
+        if (fraimProcess && fraimProcess.pid)
+            (0, tree_kill_1.default)(fraimProcess.pid);
+    }
+}
+async function runTest(testCase) {
+    return await testCase.testFunction();
+}
+(0, test_utils_1.runTests)([{
+        name: 'Debug Tools List',
+        testFunction: debugListTools,
+        tags: ['debug']
+    }], runTest, 'Debug Tools');

package/dist/tests/esm-compat.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * ESM Compatibility Helper
+ * Provides __dirname and __filename for ESM modules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__dirname = exports.__filename = void 0;
+const url_1 = require("url");
+const path_1 = require("path");
+exports.__filename = (0, url_1.fileURLToPath)(import.meta.url);
+exports.__dirname = (0, path_1.dirname)(exports.__filename);

package/dist/tests/test-chalk-esm-issue.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Test to reproduce the ERR_REQUIRE_ESM issue with chalk
+ *
+ * This test simulates what happens when npm resolves chalk to v5 (ESM-only)
+ * while the code tries to use require() (CommonJS)
+ */
+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 test_utils_1 = require("./test-utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+async function testChalkESMIssue() {
+    console.log('   🧪 Testing Chalk ESM Issue Reproduction...');
+    // Create a temp directory for the test
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'chalk-esm-test-'));
+    console.log(`   📂 Created temp dir: ${tempDir}`);
+    try {
+        // 1. Create a minimal package.json that forces chalk v5
+        const packageJson = {
+            name: 'chalk-esm-test',
+            version: '1.0.0',
+            type: 'commonjs', // Using CommonJS
+            dependencies: {
+                'chalk': '^5.0.0' // Force chalk v5 (ESM-only)
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+        // 2. Create a test script that uses require('chalk')
+        const testScript = `
+const chalk = require('chalk');
+console.log(chalk.blue('This should fail with ERR_REQUIRE_ESM'));
+`;
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'test.js'), testScript);
+        // 3. Install dependencies
+        console.log('   📦 Installing chalk v5...');
+        const installResult = await new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)('npm', ['install', '--silent'], {
+                cwd: tempDir,
+                stdio: 'pipe',
+                shell: true
+            });
+            proc.on('close', (code) => {
+                resolve({ code });
+            });
+        });
+        if (installResult.code !== 0) {
+            console.log('   ⚠️  npm install failed (expected in some environments)');
+            return true; // Skip test if npm install fails
+        }
+        // 4. Try to run the script - should fail with ERR_REQUIRE_ESM
+        console.log('   🔥 Attempting to require() chalk v5 (should fail)...');
+        const runResult = await new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)('node', ['test.js'], {
+                cwd: tempDir,
+                stdio: 'pipe',
+                shell: true
+            });
+            let stderr = '';
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({ code, stderr });
+            });
+        });
+        // 5. Verify we got the ERR_REQUIRE_ESM error
+        console.log('   📋 Checking for ERR_REQUIRE_ESM error...');
+        if (runResult.code === 0) {
+            console.log('   ❌ Script succeeded when it should have failed!');
+            return false;
+        }
+        if (!runResult.stderr.includes('ERR_REQUIRE_ESM')) {
+            console.log('   ❌ Got wrong error. Expected ERR_REQUIRE_ESM');
+            console.log(`   Stderr: ${runResult.stderr.substring(0, 200)}`);
+            return false;
+        }
+        console.log('   ✅ Successfully reproduced ERR_REQUIRE_ESM error!');
+        console.log('   ✅ This confirms chalk v5 cannot be used with require()');
+        // 6. Now test with chalk v4 (should work)
+        console.log('   🔄 Testing with chalk v4 (should work)...');
+        const packageJsonV4 = {
+            name: 'chalk-esm-test',
+            version: '1.0.0',
+            type: 'commonjs',
+            dependencies: {
+                'chalk': '4.1.2' // Exact version 4.1.2
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(tempDir, 'package.json'), JSON.stringify(packageJsonV4, null, 2));
+        // Remove node_modules and reinstall
+        fs_1.default.rmSync(path_1.default.join(tempDir, 'node_modules'), { recursive: true, force: true });
+        const installV4Result = await new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)('npm', ['install', '--silent'], {
+                cwd: tempDir,
+                stdio: 'pipe',
+                shell: true
+            });
+            proc.on('close', (code) => {
+                resolve({ code });
+            });
+        });
+        if (installV4Result.code !== 0) {
+            console.log('   ⚠️  npm install v4 failed');
+            return true; // Skip this part
+        }
+        const runV4Result = await new Promise((resolve) => {
+            const proc = (0, node_child_process_1.spawn)('node', ['test.js'], {
+                cwd: tempDir,
+                stdio: 'pipe',
+                shell: true
+            });
+            let stdout = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({ code, stdout });
+            });
+        });
+        if (runV4Result.code !== 0) {
+            console.log('   ❌ Chalk v4 failed when it should have worked!');
+            return false;
+        }
+        console.log('   ✅ Chalk v4 works correctly with require()');
+        console.log('   ✅ Test confirms: pinning to 4.1.2 prevents the issue');
+        return true;
+    }
+    catch (error) {
+        console.error('   ❌ Test failed with error:', error);
+        return false;
+    }
+    finally {
+        // Cleanup
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+            console.log('   🧹 Cleaned up temp directory');
+        }
+        catch (e) {
+            console.log('   ⚠️  Could not clean up temp directory');
+        }
+    }
+}
+async function runChalkTest(testCase) {
+    return await testCase.testFunction();
+}
+const testCases = [
+    {
+        name: 'Chalk ESM Issue Reproduction',
+        description: 'Reproduces the ERR_REQUIRE_ESM error when chalk v5 is used with require()',
+        testFunction: testChalkESMIssue,
+        tags: ['chalk', 'esm', 'reproduction']
+    }
+];
+(0, test_utils_1.runTests)(testCases, runChalkTest, 'Chalk ESM Issue Test');