@agilemonster/mcp-server 1.0.14 → 1.0.15

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.14";
+export declare const MCP_SERVER_VERSION = "1.0.15";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;

package/dist/client.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-export const MCP_SERVER_VERSION = '1.0.14';
+export const MCP_SERVER_VERSION = '1.0.15';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;

package/dist/server.js

@@ -988,15 +988,29 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             await client.addProgress(card.id, provider, `Card is now **In Progress**, but no matching source files were found in \`${projectPath}\`.`);
             return false;
         }
-        // 3. Ask Agile Monster Autonomous Step to pick the 1-4 most relevant files
+        // 3. Ask Agile Monster Autonomous Step to pick the 1-6 most relevant files
         const selectionRes = await client.autonomousStep({
             card_id: card.id,
             action: 'select_files',
             file_index: fileIndex,
         });
-        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || []).slice(0, 4);
+        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || []).slice(0, 6);
         if (selectedFiles.length === 0) {
-            selectedFiles.push(...fileIndex.slice(0, 3));
+            selectedFiles.push(...fileIndex.slice(0, 4));
+        }
+        // Automatically include project type definition files (e.g. types.ts,frontend/src/lib/types.ts) so the model knows exact schemas
+        for (const candidateTypeFile of [
+            'frontend/src/lib/types.ts',
+            'src/lib/types.ts',
+            'src/types.ts',
+            'src/types/index.ts',
+            'frontend/src/types.ts',
+        ]) {
+            if (fileIndex.includes(candidateTypeFile) &&
+                !selectedFiles.includes(candidateTypeFile) &&
+                selectedFiles.length < 7) {
+                selectedFiles.push(candidateTypeFile);
+            }
         }
         const filesPayload = {};
         for (const rel of selectedFiles) {
@@ -1015,93 +1029,135 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             .map((f) => `\`${f}\``)
             .join(', ')}. Generating code changes...`);
         // 4. Generate surgical code edits
-        const editsRes = await client.autonomousStep({
+        let editsRes = await client.autonomousStep({
             card_id: card.id,
             action: 'generate_edits',
             files: filesPayload,
         });
-        const edits = editsRes.edits || [];
-        const modifiedFiles = [];
-        const originalContents = new Map();
-        for (const edit of edits) {
-            const relPath = edit.file || edit.path;
-            if (!relPath || !edit.search || typeof edit.replace !== 'string')
-                continue;
-            const fullPath = path.resolve(projectPath, relPath);
-            if (!fullPath.startsWith(path.resolve(projectPath)))
-                continue;
-            if (!fs.existsSync(fullPath))
-                continue;
-            const currentContent = fs.readFileSync(fullPath, 'utf8');
-            if (!originalContents.has(fullPath)) {
-                originalContents.set(fullPath, currentContent);
-            }
-            if (currentContent.includes(edit.search)) {
-                const updatedContent = currentContent.replace(edit.search, edit.replace);
-                if (updatedContent !== currentContent) {
-                    // Guard against unbalanced braces/parens/brackets introduced by partial block replacement
-                    const countChar = (s, ch) => s.split(ch).length - 1;
-                    const searchBraceDelta = countChar(edit.search, '{') - countChar(edit.search, '}');
-                    const replaceBraceDelta = countChar(edit.replace, '{') - countChar(edit.replace, '}');
-                    const searchParenDelta = countChar(edit.search, '(') - countChar(edit.search, ')');
-                    const replaceParenDelta = countChar(edit.replace, '(') - countChar(edit.replace, ')');
-                    if (searchBraceDelta !== replaceBraceDelta || searchParenDelta !== replaceParenDelta) {
-                        continue;
-                    }
-                    fs.writeFileSync(fullPath, updatedContent, 'utf8');
-                    // Pre-submit static analysis gate for Dart/Flutter and PHP files
-                    if (relPath.endsWith('.dart')) {
-                        try {
-                            execSync(`dart analyze "${fullPath}"`, {
-                                cwd: projectPath,
-                                stdio: ['ignore', 'pipe', 'pipe'],
-                                timeout: 25000,
-                            });
+        const applyEditsPass = (editsList) => {
+            const modFiles = [];
+            for (const edit of editsList) {
+                const relPath = edit.file || edit.path;
+                if (!relPath || !edit.search || typeof edit.replace !== 'string')
+                    continue;
+                const fullPath = path.resolve(projectPath, relPath);
+                if (!fullPath.startsWith(path.resolve(projectPath)))
+                    continue;
+                if (!fs.existsSync(fullPath))
+                    continue;
+                const currentContent = fs.readFileSync(fullPath, 'utf8');
+                if (!originalContents.has(fullPath)) {
+                    originalContents.set(fullPath, currentContent);
+                }
+                if (currentContent.includes(edit.search)) {
+                    const updatedContent = currentContent.replace(edit.search, edit.replace);
+                    if (updatedContent !== currentContent) {
+                        const countChar = (s, ch) => s.split(ch).length - 1;
+                        const searchBraceDelta = countChar(edit.search, '{') - countChar(edit.search, '}');
+                        const replaceBraceDelta = countChar(edit.replace, '{') - countChar(edit.replace, '}');
+                        const searchParenDelta = countChar(edit.search, '(') - countChar(edit.search, ')');
+                        const replaceParenDelta = countChar(edit.replace, '(') - countChar(edit.replace, ')');
+                        if (searchBraceDelta !== replaceBraceDelta || searchParenDelta !== replaceParenDelta) {
+                            continue;
                         }
-                        catch (analyzeErr) {
-                            const out = String(analyzeErr?.stdout || '') + String(analyzeErr?.stderr || '');
-                            if (/\berror\s+[•-]/i.test(out)) {
-                                // Revert broken Dart edit so it never breaks the build
+                        fs.writeFileSync(fullPath, updatedContent, 'utf8');
+                        if (relPath.endsWith('.dart')) {
+                            try {
+                                execSync(`dart analyze "${fullPath}"`, {
+                                    cwd: projectPath,
+                                    stdio: ['ignore', 'pipe', 'pipe'],
+                                    timeout: 25000,
+                                });
+                            }
+                            catch (analyzeErr) {
+                                const out = String(analyzeErr?.stdout || '') + String(analyzeErr?.stderr || '');
+                                if (/\berror\s+[•-]/i.test(out)) {
+                                    fs.writeFileSync(fullPath, currentContent, 'utf8');
+                                    continue;
+                                }
+                            }
+                        }
+                        else if (relPath.endsWith('.php')) {
+                            try {
+                                execSync(`php -l "${fullPath}"`, {
+                                    cwd: projectPath,
+                                    stdio: ['ignore', 'pipe', 'pipe'],
+                                    timeout: 10000,
+                                });
+                            }
+                            catch {
                                 fs.writeFileSync(fullPath, currentContent, 'utf8');
                                 continue;
                             }
                         }
-                    }
-                    else if (relPath.endsWith('.php')) {
-                        try {
-                            execSync(`php -l "${fullPath}"`, {
-                                cwd: projectPath,
-                                stdio: ['ignore', 'pipe', 'pipe'],
-                                timeout: 10000,
-                            });
-                        }
-                        catch {
-                            fs.writeFileSync(fullPath, currentContent, 'utf8');
-                            continue;
+                        if (!modFiles.includes(relPath)) {
+                            modFiles.push(relPath);
                         }
                     }
-                    if (!modifiedFiles.includes(relPath)) {
-                        modifiedFiles.push(relPath);
+                }
+            }
+            return modFiles;
+        };
+        const originalContents = new Map();
+        const modifiedFiles = applyEditsPass(editsRes.edits || []);
+        // Pre-submit frontend build verification gate for root AND monorepo subdirectories (frontend/, web/, client/)
+        const verifyFrontendBuilds = () => {
+            const hasFrontendEdits = modifiedFiles.some((f) => /\.(tsx?|jsx?|vue|css)$/i.test(f));
+            if (!hasFrontendEdits)
+                return { ok: true };
+            const candidateDirs = [
+                projectPath,
+                path.join(projectPath, 'frontend'),
+                path.join(projectPath, 'web'),
+                path.join(projectPath, 'client'),
+            ];
+            for (const dir of candidateDirs) {
+                const pkgJsonPath = path.join(dir, 'package.json');
+                if (!fs.existsSync(pkgJsonPath) || !fs.existsSync(path.join(dir, 'node_modules')))
+                    continue;
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+                    if (pkg?.scripts?.build) {
+                        const buildCmd = fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))
+                            ? 'pnpm run build'
+                            : 'npm run build';
+                        execSync(buildCmd, {
+                            cwd: dir,
+                            stdio: ['ignore', 'pipe', 'pipe'],
+                            timeout: 60000,
+                        });
                     }
                 }
+                catch (buildErr) {
+                    const errOut = (String(buildErr?.stdout || '') + '\n' + String(buildErr?.stderr || '')).trim();
+                    return { ok: false, errorOutput: errOut.slice(-1500) };
+                }
             }
-        }
-        // Pre-submit frontend build verification gate for JS/TS/React/Vite/Next.js projects
-        const hasFrontendEdits = modifiedFiles.some((f) => /\.(tsx?|jsx?|vue)$/i.test(f));
-        const pkgJsonPath = path.join(projectPath, 'package.json');
-        if (hasFrontendEdits && fs.existsSync(pkgJsonPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-                if (pkg?.scripts?.build && fs.existsSync(path.join(projectPath, 'node_modules'))) {
-                    execSync('npm run build', {
-                        cwd: projectPath,
-                        stdio: ['ignore', 'pipe', 'pipe'],
-                        timeout: 45000,
-                    });
+            return { ok: true };
+        };
+        let buildCheck = verifyFrontendBuilds();
+        if (!buildCheck.ok) {
+            // Revert first pass, attach compiler error context, and do 1 self-correction pass
+            for (const [fPath, orig] of originalContents.entries()) {
+                try {
+                    fs.writeFileSync(fPath, orig, 'utf8');
                 }
+                catch { }
             }
-            catch (buildErr) {
-                // Revert broken frontend edits so we never leave the project with a broken build
+            modifiedFiles.length = 0;
+            const retryFiles = {
+                ...filesPayload,
+                '__COMPILER_ERROR_TO_FIX__.txt': `The previous edit failed to compile with:\n${buildCheck.errorOutput}\nPlease fix the TypeScript/build error using the exact property names from types.ts.`,
+            };
+            editsRes = await client.autonomousStep({
+                card_id: card.id,
+                action: 'generate_edits',
+                files: retryFiles,
+            });
+            const retryMods = applyEditsPass(editsRes.edits || []);
+            modifiedFiles.push(...retryMods);
+            buildCheck = verifyFrontendBuilds();
+            if (!buildCheck.ok) {
                 for (const [fPath, orig] of originalContents.entries()) {
                     try {
                         fs.writeFileSync(fPath, orig, 'utf8');
@@ -1122,19 +1178,21 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 }).trim();
             }
             catch { }
+            // Automatically commit, push, and run the project's defined deployment pipeline (e.g. deploy/deploy.sh, GitHub Actions, or Docker)
+            // so changes are live for testing as soon as the card moves to Testing / QA!
+            const deployInfo = runProjectDeploymentPipeline(projectPath, card.title || 'update', card.id.slice(0, 8));
             const baseSummary = editsRes.summary ||
                 `Updated ${modifiedFiles.join(', ')} to complete "${card.title}".`;
-            // Keep card comment concise plain English (no raw code diffs on the card!)
-            const cleanPlainSummary = baseSummary
-                .replace(/```[\s\S]*?```/g, '')
-                .trim();
+            const cleanPlainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() +
+                (deployInfo.deployedNote ? `\n\n${deployInfo.deployedNote}` : '');
             const verificationSteps = editsRes.verification_steps ||
-                `1. Check the updated behavior for "${card.title}".\n2. Click **Approve & Move to Done** to deploy and confirm.`;
+                `1. Check the live update for "${card.title}".\n2. Click **Approve & Deploy to Done** when verified.`;
             const logLines = [
                 `Claimed card "${card.title}" (${card.id}) in ${projectPath}`,
                 `Agent: ${workerLabel} | Model: ${card.agent_model || 'auto'}`,
                 `Selected files: ${Object.keys(filesPayload).join(', ')}`,
                 `Modified & verified files: ${modifiedFiles.join(', ')}`,
+                ...(deployInfo.deployedNote ? [`Deployment: ${deployInfo.deployedNote}`] : []),
                 `Summary: ${cleanPlainSummary}`,
             ];
             appendIdeActivityLog(projectPath, {
@@ -1192,46 +1250,28 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         activeAutonomousCards.delete(card.id);
     }
 }
-export async function deployApprovedCardIfNeeded(client, card, projectPath) {
-    if (!projectPath || !fs.existsSync(projectPath))
-        return false;
-    const shortId = card.id.slice(0, 8);
-    const deployLock = path.join(getAgileMonsterLocksDir(), `deployed-${shortId}.json`);
-    const cardUpdatedAt = card.updated_at || '';
-    if (fs.existsSync(deployLock)) {
-        try {
-            const existing = JSON.parse(fs.readFileSync(deployLock, 'utf8'));
-            if (!cardUpdatedAt || existing?.card_updated_at === cardUpdatedAt) {
-                return false;
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    const provider = card.agent_provider || 'cursor';
-    const cleanTitle = (card.title || 'update').replace(/["`\r\n]+/g, ' ').trim();
+/**
+ * Detect and execute the project's defined deployment pipeline:
+ * 1. Commits any modified tracked files and pushes to `origin/<branch>`.
+ * 2. Runs `deploy/deploy.sh` (or `scripts/deploy.sh`) if present in the repo (e.g. Meerlink cPanel SSH deploy).
+ * 3. Or triggers GitHub Actions CI/CD via `git push`.
+ */
+function runProjectDeploymentPipeline(projectPath, rawTitle, shortId, forceEmptyCommit = false) {
+    const cleanTitle = (rawTitle || 'update').replace(/["`\r\n]+/g, ' ').trim();
+    let branch = 'main';
+    let commitHash = '';
+    const actions = [];
     try {
-        fs.writeFileSync(deployLock, JSON.stringify({
-            card_id: card.id,
-            card_updated_at: cardUpdatedAt,
-            title: card.title,
-            started_at: new Date().toISOString(),
-        }), 'utf8');
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+        branch = execSync('git rev-parse --abbrev-ref HEAD', {
             cwd: projectPath,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-        if (!branch || branch === 'HEAD')
-            return false;
+        }).trim() || 'main';
         const statusOut = execSync('git status --porcelain -uno', {
             cwd: projectPath,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
         }).trim();
-        const rawText = `${card.title || ''} ${card.description || ''}`;
-        const isContainerRestartCard = /\b(restart|redeploy|rebuild)\b.*\b(container|docker|server|prod)/i.test(rawText);
         if (statusOut.length > 0) {
             execSync('git add -u', { cwd: projectPath, stdio: 'ignore' });
             execSync(`git commit -m "feat: ${cleanTitle} [AM-${shortId}]"`, {
@@ -1241,26 +1281,16 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             execSync(`git push origin ${branch}`, {
                 cwd: projectPath,
                 stdio: 'ignore',
+                timeout: 45000,
             });
-            const commitHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Deployment confirmed! Committed and pushed \`${commitHash}\` to \`origin/${branch}\`, and moved card to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            appendIdeActivityLog(projectPath, {
-                cardId: card.id,
-                cardTitle: card.title,
-                agentName: card.agent_display_name || provider,
-                model: card.agent_model || 'auto',
-                status: 'done',
-                summary: `Deployment confirmed (${commitHash} -> origin/${branch}). Moved card to Done.`,
-            });
-            sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${commitHash}) and moved to Done!`);
-            return true;
+            actions.push(`pushed \`${commitHash}\` to \`origin/${branch}\``);
         }
-        else if (isContainerRestartCard) {
+        else if (forceEmptyCommit) {
             execSync(`git commit --allow-empty -m "chore: trigger container redeploy [AM-${shortId}]"`, {
                 cwd: projectPath,
                 stdio: 'ignore',
@@ -1268,39 +1298,97 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             execSync(`git push origin ${branch}`, {
                 cwd: projectPath,
                 stdio: 'ignore',
+                timeout: 45000,
             });
-            const commitHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Triggered production container rebuild & restart (\`${commitHash}\` on \`origin/${branch}\`) and confirmed move to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            appendIdeActivityLog(projectPath, {
-                cardId: card.id,
-                cardTitle: card.title,
-                agentName: card.agent_display_name || provider,
-                model: card.agent_model || 'auto',
-                status: 'done',
-                summary: `Triggered container restart (${commitHash}) and moved card to Done.`,
-            });
-            sendDesktopNotification(`Agile Monster -> Container Redeploy`, `Triggered container restart (${commitHash}) on origin/${branch}!`);
-            return true;
+            actions.push(`triggered redeploy commit \`${commitHash}\` on \`origin/${branch}\``);
         }
         else {
-            const headHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Confirmed latest commit \`${headHash}\` is pushed to \`origin/${branch}\` and live in production. Moved card to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            return true;
+        }
+        // Check if the project has a dedicated deploy script (e.g. deploy/deploy.sh in Meerlink)
+        const deployScript = path.join(projectPath, 'deploy', 'deploy.sh');
+        if (fs.existsSync(deployScript)) {
+            const scriptContent = fs.readFileSync(deployScript, 'utf8');
+            const flag = scriptContent.includes('--skip-preflight') ? ' --skip-preflight' : '';
+            execSync(`bash "${deployScript}"${flag}`, {
+                cwd: projectPath,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 180000,
+            });
+            actions.push('deployed live via `deploy/deploy.sh`');
+        }
+        else if (fs.existsSync(path.join(projectPath, '.github', 'workflows'))) {
+            actions.push('triggered GitHub Actions CI/CD deployment');
+        }
+        const deployedNote = actions.length > 0
+            ? `🚀 **Deployed**: Automatically ${actions.join(' and ')}.`
+            : `🚀 **Deployed**: Verified commit \`${commitHash}\` is live on \`origin/${branch}\`.`;
+        return { ok: true, commitHash, branch, deployedNote };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            commitHash,
+            branch,
+            deployedNote: '',
+        };
+    }
+}
+export async function deployApprovedCardIfNeeded(client, card, projectPath) {
+    if (!projectPath || !fs.existsSync(projectPath))
+        return false;
+    const shortId = card.id.slice(0, 8);
+    const deployLock = path.join(getAgileMonsterLocksDir(), `deployed-${shortId}.json`);
+    const cardUpdatedAt = card.updated_at || '';
+    if (fs.existsSync(deployLock)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(deployLock, 'utf8'));
+            if (!cardUpdatedAt || existing?.card_updated_at === cardUpdatedAt) {
+                return false;
+            }
+        }
+        catch {
+            return false;
         }
     }
+    const provider = card.agent_provider || 'cursor';
+    const rawText = `${card.title || ''} ${card.description || ''}`;
+    const isContainerRestartCard = /\b(restart|redeploy|rebuild)\b.*\b(container|docker|server|prod)/i.test(rawText);
+    try {
+        fs.writeFileSync(deployLock, JSON.stringify({
+            card_id: card.id,
+            card_updated_at: cardUpdatedAt,
+            title: card.title,
+            started_at: new Date().toISOString(),
+        }), 'utf8');
+        const res = runProjectDeploymentPipeline(projectPath, card.title || 'update', shortId, isContainerRestartCard);
+        const msg = res.deployedNote
+            ? `${res.deployedNote} Confirmed and moved card to **Done**.`
+            : `🚀 **Deployed**: Confirmed latest commit \`${res.commitHash}\` is live on \`origin/${res.branch}\` and moved card to **Done**.`;
+        await client.completeTask(card.id, provider, msg);
+        appendIdeActivityLog(projectPath, {
+            cardId: card.id,
+            cardTitle: card.title,
+            agentName: card.agent_display_name || provider,
+            model: card.agent_model || 'auto',
+            status: 'done',
+            summary: msg,
+        });
+        sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${res.commitHash}) and moved to Done!`);
+        return true;
+    }
     catch (err) {
         try {
-            await client.addProgress(card.id, provider, `⚠️ **[Auto-Deploy Note]** Attempted to auto-push approved changes in \`${projectPath}\`: ${err?.message || String(err)}`);
+            await client.addProgress(card.id, provider, `⚠️ **[Auto-Deploy Note]** Attempted to deploy approved changes in \`${projectPath}\`: ${err?.message || String(err)}`);
         }
         catch { }
         return false;
@@ -1446,6 +1534,23 @@ export async function runBackgroundPulseDaemon(intervalMs = 20000) {
     const client = new AgileMonsterClient();
     console.log(`[Agile Monster Pulse Daemon v${MCP_SERVER_VERSION}] Listening for queued agent tasks across all bound repositories (interval: ${intervalMs / 1000}s)...`);
     startBuiltInPullPulse(null, client, intervalMs);
-    // Keep process alive
-    setInterval(() => { }, 60000);
+    const selfScript = process.argv[1] || '';
+    const initialMtime = selfScript && fs.existsSync(selfScript) ? fs.statSync(selfScript).mtimeMs : 0;
+    // Auto-restart daemon if mcp-server binary/dist on disk is updated so it never runs stale code in memory
+    setInterval(() => {
+        try {
+            if (selfScript && initialMtime > 0 && fs.existsSync(selfScript)) {
+                const curMtime = fs.statSync(selfScript).mtimeMs;
+                if (curMtime > initialMtime + 1000) {
+                    const child = spawn(process.execPath, process.argv.slice(1), {
+                        detached: true,
+                        stdio: 'ignore',
+                    });
+                    child.unref();
+                    process.exit(0);
+                }
+            }
+        }
+        catch { }
+    }, 30000);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilemonster/mcp-server",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "type": "module",
   "description": "Official Model Context Protocol (MCP) server & Orchestrator for Agile Monster (Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf)",
   "main": "dist/server.js",