funolio-agent 1.0.47 → 1.0.49

package/dist/mcp/manager.js

@@ -40,20 +40,22 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPManager = void 0;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const events_1 = require("events");
-const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../config");
 const registry_1 = require("./registry");
 const stdio_protocol_1 = require("./stdio-protocol");
-const tool_grouping_1 = require("./tool-grouping");
+const GOOGLE_INTEGRATION_SERVER_IDS = new Set([
+    'google-workspace',
+    'google-drive',
+    'google-calendar',
+    'google-chat',
+    'gmail',
+]);
 /**
  * MCP Manager — singleton per agent instance.
  */
@@ -140,104 +142,16 @@ class MCPManager extends events_1.EventEmitter {
             ? ['-y', config.npmPackage, ...config.args]
             : ['run', config.pipPackage, ...config.args];
         // Inject integration tokens for known MCP servers (e.g. google-drive → Google OAuth tokens)
-        const GOOGLE_MCP_IDS = new Set(['google-workspace', 'google-drive', 'google-calendar', 'gmail']);
         let integrationEnv = {};
         try {
-            const { getIntegrationEnvVars } = require('../integration-tokens');
-            if (GOOGLE_MCP_IDS.has(config.id)) {
+            const { getIntegrationEnvVars, writeGoogleWorkspaceFiles } = require('../integration-tokens');
+            if (GOOGLE_INTEGRATION_SERVER_IDS.has(config.id)) {
+                writeGoogleWorkspaceFiles();
                 integrationEnv = getIntegrationEnvVars('google');
             }
         }
         catch { }
-        // Merge all env var sources: process.env < integration-tokens.json < marketplace envVars
-        const mergedEnv = { ...process.env, ...integrationEnv, ...config.envVars };
-        // For Google MCP servers that use file-based auth (e.g. @piotr-agier/google-drive-mcp),
-        // write the credentials and tokens to the expected file locations. These packages read
-        // from gcp-oauth.keys.json + ~/.config/google-drive-mcp/tokens.json rather than env vars.
-        if (GOOGLE_MCP_IDS.has(config.id)) {
-            const clientId = mergedEnv.GOOGLE_CLIENT_ID;
-            const clientSecret = mergedEnv.GOOGLE_CLIENT_SECRET;
-            const refreshToken = mergedEnv.GOOGLE_REFRESH_TOKEN;
-            if (clientId && clientSecret && refreshToken) {
-                try {
-                    const os = require('os');
-                    const configDir = path.join(os.homedir(), '.config', 'google-drive-mcp');
-                    if (!fs.existsSync(configDir)) {
-                        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-                    }
-                    // Write credentials file (gcp-oauth.keys.json)
-                    const keysFile = path.join(configDir, 'gcp-oauth.keys.json');
-                    fs.writeFileSync(keysFile, JSON.stringify({
-                        installed: {
-                            client_id: clientId,
-                            client_secret: clientSecret,
-                            redirect_uris: ['http://localhost:3000/oauth2callback'],
-                        },
-                    }, null, 2), { mode: 0o600 });
-                    // Write tokens file — preserve existing valid access_token but
-                    // always ensure scopes and refresh_token are up to date.
-                    //
-                    // The configured scopes are the source of truth. The tokens.json
-                    // scope field is used by the MCP for internal checks (authGetStatus),
-                    // so it must always match the configured scopes — not whatever the
-                    // token file happened to have from a previous OAuth consent.
-                    const tokensFile = path.join(configDir, 'tokens.json');
-                    const incomingAccessToken = mergedEnv.GOOGLE_ACCESS_TOKEN;
-                    const CONFIGURED_SCOPES = 'https://www.googleapis.com/auth/drive https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/gmail.modify https://www.googleapis.com/auth/chat.spaces https://www.googleapis.com/auth/chat.messages';
-                    let tokenPayload = {
-                        access_token: incomingAccessToken || 'needs-refresh',
-                        refresh_token: refreshToken,
-                        scope: CONFIGURED_SCOPES,
-                        token_type: 'Bearer',
-                        expiry_date: incomingAccessToken ? (Date.now() + 3600 * 1000) : (Date.now() - 1000),
-                    };
-                    // If we have no server-side token and an existing file has a real
-                    // access_token, preserve it — but always update scope and refresh_token
-                    // to match the current configuration.
-                    if (!incomingAccessToken && fs.existsSync(tokensFile)) {
-                        try {
-                            const existing = JSON.parse(fs.readFileSync(tokensFile, 'utf-8'));
-                            if (existing.access_token && existing.access_token !== 'needs-refresh' && existing.refresh_token) {
-                                tokenPayload = {
-                                    ...existing,
-                                    refresh_token: refreshToken, // Always use configured refresh token
-                                    scope: CONFIGURED_SCOPES, // Always use configured scopes
-                                    token_type: 'Bearer',
-                                };
-                                console.log(chalk_1.default.gray(`  ℹ Preserving existing Google access_token, updated scope & refresh_token`));
-                            }
-                        }
-                        catch {
-                            // Can't parse existing file — use fresh payload
-                        }
-                    }
-                    fs.writeFileSync(tokensFile, JSON.stringify(tokenPayload, null, 2), { mode: 0o600 });
-                    // Also set the env var so the package can find its config
-                    mergedEnv.GOOGLE_DRIVE_MCP_TOKEN_PATH = tokensFile;
-                    mergedEnv.GOOGLE_CLIENT_SECRET_PATH = keysFile;
-                    // Gmail MCP (@gongrzhe/server-gmail-autoauth-mcp) reads from ~/.gmail-mcp/
-                    // instead of ~/.config/google-drive-mcp/, so duplicate the files there.
-                    if (config.id === 'gmail') {
-                        const gmailDir = path.join(os.homedir(), '.gmail-mcp');
-                        if (!fs.existsSync(gmailDir)) {
-                            fs.mkdirSync(gmailDir, { recursive: true, mode: 0o700 });
-                        }
-                        fs.copyFileSync(keysFile, path.join(gmailDir, 'gcp-oauth.keys.json'));
-                        fs.copyFileSync(tokensFile, path.join(gmailDir, 'tokens.json'));
-                        console.log(chalk_1.default.green(`  ✓ Also wrote Gmail credentials to ${gmailDir}`));
-                    }
-                    console.log(chalk_1.default.green(`  ✓ Wrote Google credentials for ${config.id} to ${configDir}`));
-                }
-                catch (err) {
-                    console.error(chalk_1.default.red(`  ✗ Failed to write Google credential files: ${err.message}`));
-                }
-            }
-            else {
-                console.warn(chalk_1.default.yellow(`  ⚠ Missing Google credentials for ${config.id} (need CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN)`));
-                console.warn(chalk_1.default.yellow(`    Install via the Funolio marketplace and provide your Google OAuth credentials.`));
-            }
-        }
-        const env = mergedEnv;
+        const env = { ...process.env, ...integrationEnv, ...config.envVars };
         const child = (0, child_process_1.spawn)(cmd, args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             env,
@@ -250,7 +164,6 @@ class MCPManager extends events_1.EventEmitter {
             ready: false,
             requestId: 0,
             pendingRequests: new Map(),
-            stderrBuffer: [],
         };
         this.servers.set(config.id, instance);
         const reader = new stdio_protocol_1.McpStdioMessageReader((msg) => {
@@ -268,19 +181,11 @@ class MCPManager extends events_1.EventEmitter {
         child.stdout?.on('data', (chunk) => {
             reader.feed(chunk);
         });
-        // Capture recent stderr for error enrichment (ring buffer, last 5 messages)
-        const stderrBuffer = [];
-        const MAX_STDERR_LINES = 5;
         child.stderr?.on('data', (data) => {
             const msg = data.toString().trim();
-            if (msg) {
+            if (msg)
                 console.error(`[MCP:${config.id}] ${msg}`);
-                stderrBuffer.push(msg);
-                if (stderrBuffer.length > MAX_STDERR_LINES)
-                    stderrBuffer.shift();
-            }
         });
-        instance.stderrBuffer = stderrBuffer;
         child.on('exit', (code) => {
             const error = new Error(`MCP server ${config.id} exited with code ${code}`);
             for (const [requestId, pending] of instance.pendingRequests.entries()) {
@@ -291,36 +196,6 @@ class MCPManager extends events_1.EventEmitter {
             this.servers.delete(config.id);
             this.rebuildToolList();
             this.emit('server-stopped', config.id);
-            // Fix 2: MCP crash recovery — attempt one restart for always-on servers
-            // Track restart attempts to prevent infinite crash loops
-            if (config.alwaysOn && entry) {
-                const key = `restart_${config.id}`;
-                const now = Date.now();
-                const restartState = this[key] || { count: 0, firstAttempt: now };
-                restartState.count++;
-                this[key] = restartState;
-                // Max 3 restart attempts within 5 minutes, then give up
-                const MAX_RESTARTS = 3;
-                const RESTART_WINDOW_MS = 5 * 60 * 1000;
-                if (now - restartState.firstAttempt > RESTART_WINDOW_MS) {
-                    restartState.count = 1;
-                    restartState.firstAttempt = now;
-                }
-                if (restartState.count <= MAX_RESTARTS) {
-                    console.log(`[MCP] Attempting auto-restart of ${config.id} (${restartState.count}/${MAX_RESTARTS})...`);
-                    this.launchServer(config, entry).then((tools) => {
-                        console.log(`[MCP] ✓ Auto-restarted ${config.id} — ${tools.length} tools recovered`);
-                        restartState.count = 0; // Reset on success
-                        this.emit('server-restarted', config.id, tools);
-                    }).catch((err) => {
-                        console.error(`[MCP] ✗ Auto-restart of ${config.id} failed: ${err.message}`);
-                        this.emit('server-restart-failed', config.id, err.message);
-                    });
-                }
-                else {
-                    console.error(`[MCP] ✗ ${config.id} crashed ${restartState.count} times in ${Math.round((now - restartState.firstAttempt) / 1000)}s — giving up on auto-restart`);
-                }
-            }
         });
         // MCP handshake: initialize
         try {
@@ -339,15 +214,10 @@ class MCPManager extends events_1.EventEmitter {
                 inputSchema: t.inputSchema || {},
                 serverId: config.id,
             }));
-            // Apply smart tool grouping for servers with many tools
-            const groupedTools = (0, tool_grouping_1.groupMcpTools)(tools, config.id, entry.name);
-            if (groupedTools.length < tools.length) {
-                console.log(`[MCP] ${entry.name}: grouped ${tools.length} tools into ${groupedTools.length} meta-tool(s)`);
-            }
-            instance.tools = groupedTools;
+            instance.tools = tools;
             instance.ready = true;
             this.rebuildToolList();
-            console.log(`[MCP] ${entry.name} launched — ${tools.length} tools discovered (${groupedTools.length} after grouping)`);
+            console.log(`[MCP] ${entry.name} launched — ${tools.length} tools discovered`);
             this.emit('server-ready', config.id, tools);
             return tools;
         }
@@ -365,14 +235,13 @@ class MCPManager extends events_1.EventEmitter {
             const msg = (0, stdio_protocol_1.encodeMcpStdioMessage)({ jsonrpc: '2.0', id, method, params });
             instance.pendingRequests.set(id, { resolve, reject });
             instance.process.stdin.write(msg);
-            // Timeout: 120s for initialize (first launch may download packages), 30s for other requests
-            const timeoutMs = method === 'initialize' ? 120_000 : 30_000;
+            // Timeout after 30s
             setTimeout(() => {
                 if (instance.pendingRequests.has(id)) {
                     instance.pendingRequests.delete(id);
-                    reject(new Error(`MCP request ${method} timed out after ${timeoutMs / 1000}s`));
+                    reject(new Error(`MCP request ${method} timed out`));
                 }
-            }, timeoutMs);
+            }, 30_000);
         });
     }
     /** Send a JSON-RPC notification (no response expected) */
@@ -380,117 +249,8 @@ class MCPManager extends events_1.EventEmitter {
         const msg = (0, stdio_protocol_1.encodeMcpStdioMessage)({ jsonrpc: '2.0', method, params });
         instance.process.stdin.write(msg);
     }
-    /** Enrich MCP error results with actionable hints */
-    enrichErrorResult(result, toolName, args) {
-        if (!result?.isError)
-            return result;
-        const contentText = result.content
-            ? result.content.map((c) => c.text || JSON.stringify(c)).join('\n')
-            : '';
-        // Detect unhelpful errors and add context
-        const isUnhelpful = !contentText || contentText === 'Unknown error' || contentText.length < 20;
-        // Check for file-type-specific hints
-        const fileId = (args.fileId || args.file_id || '');
-        const mimeType = (args.mimeType || args.mime_type || '');
-        const actionName = toolName.replace(/^mcp_[^_]+_/, '');
-        let hint = '';
-        if (actionName === 'downloadFile' || actionName === 'readSpreadsheet' || actionName === 'readDocument') {
-            const uploadedFormats = ['.xlsx', '.docx', '.pptx', '.csv', '.pdf'];
-            const uploadedMimes = ['application/vnd.openxmlformats', 'application/msword', 'application/pdf'];
-            const isUploaded = uploadedFormats.some(f => mimeType.includes(f)) ||
-                uploadedMimes.some(m => mimeType.includes(m));
-            if (isUploaded && actionName === 'readSpreadsheet') {
-                hint = '\nHINT: This file appears to be an uploaded .xlsx file, NOT a native Google Sheet. ' +
-                    'Use downloadFile to save it locally, then read with run_command (e.g., python with openpyxl).';
-            }
-            else if (isUploaded && actionName === 'downloadFile' && isUnhelpful) {
-                hint = '\nHINT: downloadFile failed. Try using copyFile with convert=true to convert to native Google format first, then use the appropriate read tool.';
-            }
-        }
-        if (hint && result.content) {
-            result.content = [
-                ...result.content,
-                { type: 'text', text: hint },
-            ];
-        }
-        return result;
-    }
-    /** Call a tool on an MCP server (handles both regular and meta-tools) */
+    /** Call a tool on an MCP server */
     async callTool(toolName, args) {
-        // Handle meta-tool calls: resolve to the real tool name and args
-        if ((0, tool_grouping_1.isMetaTool)(toolName)) {
-            const action = args.action;
-            // LLMs sometimes put params at the top level instead of inside "params".
-            // If "params" exists, use it. Otherwise, extract everything except "action"
-            // as the params object — this handles both { action, params: {...} } and
-            // { action, localPath, name, ... } formats.
-            let params;
-            if (args.params && typeof args.params === 'object') {
-                params = args.params;
-            }
-            else {
-                const { action: _a, ...rest } = args;
-                params = Object.keys(rest).length > 0 ? rest : {};
-            }
-            if (!action)
-                throw new Error(`Meta-tool "${toolName}" requires an "action" parameter`);
-            const { originalToolName, originalArgs } = (0, tool_grouping_1.resolveMetaTool)(toolName, action, params);
-            // Find the server for this meta-tool
-            const metaTool = this.allDiscoveredTools.find((t) => t.name === toolName);
-            if (!metaTool)
-                throw new Error(`Meta-tool not found: ${toolName}`);
-            const instance = this.servers.get(metaTool.serverId);
-            if (!instance || !instance.ready)
-                throw new Error(`MCP server ${metaTool.serverId} not running`);
-            // Strip prefix to get the raw MCP tool name
-            const rawName = originalToolName.replace(`mcp_${metaTool.serverId}_`, '');
-            // Auto-create parent directories for downloadFile to avoid "Parent directory does not exist"
-            if (rawName === 'downloadFile' || rawName === 'download_file') {
-                const localPath = originalArgs.localPath || originalArgs.local_path;
-                if (typeof localPath === 'string') {
-                    const parentDir = path.dirname(localPath);
-                    if (!fs.existsSync(parentDir)) {
-                        fs.mkdirSync(parentDir, { recursive: true });
-                    }
-                }
-            }
-            try {
-                const result = await this.sendRequest(instance, 'tools/call', { name: rawName, arguments: originalArgs });
-                // Bug 4: Enrich meta-tool errors with stderr
-                if (result?.isError) {
-                    const recentStderr = instance.stderrBuffer?.slice(-3)
-                        .filter((s) => s.includes('Error') || s.includes('error') || s.includes('fail') || s.includes('not exist') || s.includes('Invalid'))
-                        .join(' | ');
-                    if (recentStderr) {
-                        const existingText = result.content?.map((c) => c.text || '').join(' ') || '';
-                        result.content = [{ type: 'text', text: `${existingText || 'Unknown error'}. Server details: ${recentStderr}` }];
-                    }
-                }
-                // Bug 1: Validate downloadFile results — detect Google sign-in pages
-                if ((rawName === 'downloadFile' || rawName === 'download_file') && !result?.isError) {
-                    const localPath = (originalArgs.localPath || originalArgs.local_path);
-                    if (localPath && fs.existsSync(localPath)) {
-                        const header = Buffer.alloc(500);
-                        const fd = fs.openSync(localPath, 'r');
-                        fs.readSync(fd, header, 0, 500, 0);
-                        fs.closeSync(fd);
-                        const headerStr = header.toString('utf8').toLowerCase();
-                        if (headerStr.includes('accounts.google.com') ||
-                            (headerStr.startsWith('<!doctype html>') && !localPath.endsWith('.html'))) {
-                            fs.unlinkSync(localPath);
-                            return {
-                                content: [{ type: 'text', text: 'ERROR: Download failed — received Google sign-in page instead of actual file content. The OAuth token may have expired. The file was NOT saved. Try using run_command to download via curl with a fresh token, or ask the user to re-authenticate Google Workspace.' }],
-                                isError: true,
-                            };
-                        }
-                    }
-                }
-                return this.enrichErrorResult(result, originalToolName, originalArgs);
-            }
-            catch (err) {
-                throw new Error(`MCP tool ${rawName} failed: ${err.message}${err.stack ? '\n' + err.stack.split('\n').slice(0, 3).join('\n') : ''}`);
-            }
-        }
         const tool = this.allDiscoveredTools.find((t) => t.name === toolName);
         if (!tool)
             throw new Error(`MCP tool not found: ${toolName}`);
@@ -499,45 +259,11 @@ class MCPManager extends events_1.EventEmitter {
             throw new Error(`MCP server ${tool.serverId} not running`);
         // Strip the mcp_{serverId}_ prefix to get the original tool name
         const originalName = toolName.replace(`mcp_${tool.serverId}_`, '');
-        // Auto-create parent directories for downloadFile to avoid "Parent directory does not exist"
-        if (originalName === 'downloadFile' || originalName === 'download_file') {
-            const localPath = args.localPath || args.local_path;
-            if (typeof localPath === 'string') {
-                const parentDir = path.dirname(localPath);
-                if (!fs.existsSync(parentDir)) {
-                    fs.mkdirSync(parentDir, { recursive: true });
-                }
-            }
-        }
-        try {
-            const result = await this.sendRequest(instance, 'tools/call', {
-                name: originalName,
-                arguments: args,
-            });
-            // Bug 1: Validate downloadFile results — detect Google sign-in pages
-            if ((originalName === 'downloadFile' || originalName === 'download_file') && !result?.isError) {
-                const localPath = (args.localPath || args.local_path);
-                if (localPath && fs.existsSync(localPath)) {
-                    const header = Buffer.alloc(500);
-                    const fd = fs.openSync(localPath, 'r');
-                    fs.readSync(fd, header, 0, 500, 0);
-                    fs.closeSync(fd);
-                    const headerStr = header.toString('utf8').toLowerCase();
-                    if (headerStr.includes('accounts.google.com') ||
-                        (headerStr.startsWith('<!doctype html>') && !localPath.endsWith('.html'))) {
-                        fs.unlinkSync(localPath);
-                        return {
-                            content: [{ type: 'text', text: 'ERROR: Download failed — received Google sign-in page instead of actual file content. The OAuth token may have expired. The file was NOT saved. Try using run_command to download via curl with a fresh token, or ask the user to re-authenticate Google Workspace.' }],
-                            isError: true,
-                        };
-                    }
-                }
-            }
-            return this.enrichErrorResult(result, toolName, args);
-        }
-        catch (err) {
-            throw new Error(`MCP tool ${originalName} failed: ${err.message}${err.stack ? '\n' + err.stack.split('\n').slice(0, 3).join('\n') : ''}`);
-        }
+        const result = await this.sendRequest(instance, 'tools/call', {
+            name: originalName,
+            arguments: args,
+        });
+        return result;
     }
     /** Rebuild the merged list of all discovered tools */
     rebuildToolList() {
@@ -560,41 +286,22 @@ class MCPManager extends events_1.EventEmitter {
                     const output = result?.content
                         ? result.content.map((c) => c.text || JSON.stringify(c)).join('\n')
                         : JSON.stringify(result);
-                    let errorOutput = output;
-                    if (result?.isError) {
-                        // Enrich error with recent stderr from the MCP server
-                        const srv = this.servers.get(t.serverId);
-                        const recentStderr = srv?.stderrBuffer?.slice(-3)
-                            .filter((s) => s.includes('Error') || s.includes('error') || s.includes('fail') || s.includes('not exist'))
-                            .join('\n');
-                        const parts = ['ERROR:'];
-                        if (output && output !== 'Unknown error')
-                            parts.push(output);
-                        if (recentStderr)
-                            parts.push(`Server details: ${recentStderr}`);
-                        if (parts.length === 1)
-                            parts.push('Unknown error from MCP server');
-                        errorOutput = parts.join(' ');
-                    }
                     return {
                         tool_call_id: '',
                         name: t.name,
                         success: !result?.isError,
-                        output: result?.isError ? errorOutput : output,
-                        error: result?.isError ? errorOutput : undefined,
+                        output,
                         verified: true,
                         verification_details: 'MCP tool execution',
                     };
                 }
                 catch (err) {
-                    const errorDetail = err.message || 'Unknown error';
-                    const stackHint = err.stack ? '\n' + err.stack.split('\n').slice(1, 3).join('\n') : '';
                     return {
                         tool_call_id: '',
                         name: t.name,
                         success: false,
                         output: '',
-                        error: `${errorDetail}${stackHint}`,
+                        error: err.message,
                         verified: true,
                         verification_details: 'MCP tool execution failed',
                     };
@@ -617,6 +324,47 @@ class MCPManager extends events_1.EventEmitter {
             alwaysOn: instance.config.alwaysOn,
         };
     }
+    async waitForServerExit(id, instance) {
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                instance.process.removeListener('exit', finish);
+                this.removeListener('server-stopped', onStopped);
+                resolve();
+            };
+            const onStopped = (stoppedId) => {
+                if (stoppedId === id)
+                    finish();
+            };
+            const timeout = setTimeout(finish, 5_000);
+            instance.process.once('exit', finish);
+            this.on('server-stopped', onStopped);
+            instance.process.kill();
+        });
+    }
+    async reloadIntegrationServers(integration) {
+        if (integration !== 'google')
+            return [];
+        const restarted = [];
+        const runningGoogleServers = Array.from(this.servers.entries())
+            .filter(([id]) => GOOGLE_INTEGRATION_SERVER_IDS.has(id));
+        for (const [id, instance] of runningGoogleServers) {
+            const config = {
+                ...instance.config,
+                envVars: { ...instance.config.envVars },
+                args: [...instance.config.args],
+            };
+            const entry = instance.entry;
+            await this.waitForServerExit(id, instance);
+            await this.launchServer(config, entry);
+            restarted.push(id);
+        }
+        return restarted;
+    }
     /** Stop a running MCP server */
     async stopServer(id) {
         const instance = this.servers.get(id);
@@ -654,76 +402,6 @@ class MCPManager extends events_1.EventEmitter {
             this.saveConfigs();
         }
     }
-    /**
-     * Pre-warm an npm package by running `npx -y <package> --help` in the background.
-     * This downloads/caches the package so subsequent launches are fast.
-     */
-    static preWarmPackage(npmPackage) {
-        console.log(`[MCP] Pre-warming package cache: ${npmPackage}`);
-        const child = (0, child_process_1.spawn)('npx', ['-y', npmPackage, '--help'], {
-            stdio: 'ignore',
-            detached: true,
-            env: { ...process.env },
-        });
-        child.unref();
-        child.on('exit', (code) => {
-            console.log(`[MCP] Pre-warm of ${npmPackage} finished (exit ${code})`);
-        });
-    }
-    /**
-     * Reload all running Google MCP servers after token refresh.
-     * Stops each server, then re-launches with fresh credentials from the token store.
-     */
-    async reloadIntegrationServers(integration) {
-        if (integration !== 'google')
-            return [];
-        const GOOGLE_IDS = new Set(['google-workspace', 'google-drive', 'google-calendar', 'gmail']);
-        const restarted = [];
-        const runningGoogle = Array.from(this.servers.entries())
-            .filter(([id]) => GOOGLE_IDS.has(id));
-        for (const [id, instance] of runningGoogle) {
-            const config = { ...instance.config };
-            const entry = instance.entry;
-            console.log(`[MCP] Reloading ${id} after Google token refresh...`);
-            try {
-                // Stop current instance
-                instance.process.kill();
-                // Wait briefly for exit
-                await new Promise((resolve) => {
-                    const timeout = setTimeout(resolve, 5000);
-                    instance.process.once('exit', () => { clearTimeout(timeout); resolve(); });
-                });
-                this.servers.delete(id);
-                this.rebuildToolList();
-                // Re-launch with fresh tokens from the updated token store
-                await this.launchServer(config, entry);
-                restarted.push(id);
-                console.log(`[MCP] ✓ Reloaded ${id} successfully`);
-            }
-            catch (err) {
-                console.error(`[MCP] ✗ Failed to reload ${id}: ${err.message}`);
-            }
-        }
-        return restarted;
-    }
-    /**
-     * Fix 3: Check which configured (always-on) servers are NOT currently running.
-     * Returns names of dead servers for injection into system prompt / tool list.
-     */
-    getDeadServers() {
-        const configs = this.loadPersistedConfigs();
-        const running = new Set(this.servers.keys());
-        return configs
-            .filter(c => c.alwaysOn && !running.has(c.id))
-            .map(c => c.id);
-    }
-    /**
-     * Check if a specific server is alive and responsive.
-     */
-    isServerAlive(id) {
-        const instance = this.servers.get(id);
-        return !!(instance && instance.ready && instance.process && !instance.process.killed);
-    }
     /** Shutdown all MCP servers */
     async shutdown() {
         for (const [id, instance] of this.servers) {