termux-dev 1.3.0 → 1.4.0

package/dist/core/pricing.js

@@ -42,7 +42,7 @@ export function getModelPricing(modelName) {
         return cache[clean];
     if (cache[short])
         return cache[short];
-    const baseName = short.replace(/\-\d {4,8}$/, '').replace(/:latest$/, '');
+    const baseName = short.replace(/-\d{4,8}$/, '').replace(/:latest$/, '');
     if (cache[baseName])
         return cache[baseName];
     if (clean.includes('gpt-4o-mini'))

package/dist/core/usage.js

@@ -1,10 +1,13 @@
 import pc from 'picocolors';
 import { getCurrentTheme } from '../cli/theme.js';
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
 export class UsageTracker {
     static instance;
-    requestsCount = 0;
     bytesSent = 0;
     bytesReceived = 0;
+    requestsCount = 0;
     promptTokens = 0;
     completionTokens = 0;
     totalCost = 0;
@@ -20,24 +23,24 @@ export class UsageTracker {
     setLimit(limitMB) {
         this.dataSaverLimitMB = limitMB;
     }
-    recordRequest(bytes) {
-        this.requestsCount++;
-        this.bytesSent += Math.max(0, bytes);
+    recordRequest(payloadBytes) {
+        this.bytesSent += payloadBytes;
+        this.requestsCount += 1;
     }
-    recordResponseChunk(bytes) {
-        this.bytesReceived += Math.max(0, bytes);
+    recordResponseChunk(chunkBytes) {
+        this.bytesReceived += chunkBytes;
     }
-    recordTokens(prompt, completion, cost = 0) {
-        this.promptTokens += Math.max(0, prompt);
-        this.completionTokens += Math.max(0, completion);
-        this.totalCost += Math.max(0, cost);
+    recordTokens(promptTokens, completionTokens, cost) {
+        this.promptTokens += promptTokens;
+        this.completionTokens += completionTokens;
+        this.totalCost += cost;
     }
     getSummary() {
         return {
-            requestsCount: this.requestsCount,
             bytesSent: this.bytesSent,
             bytesReceived: this.bytesReceived,
             totalBytes: this.bytesSent + this.bytesReceived,
+            requestsCount: this.requestsCount,
             promptTokens: this.promptTokens,
             completionTokens: this.completionTokens,
             totalTokens: this.promptTokens + this.completionTokens,
@@ -46,19 +49,15 @@ export class UsageTracker {
         };
     }
     static formatBytes(bytes) {
-        if (bytes <= 0)
-            return '0 B';
         if (bytes < 1024)
             return `${bytes} B`;
         if (bytes < 1024 * 1024)
             return `${(bytes / 1024).toFixed(1)} KB`;
-        if (bytes < 1024 * 1024 * 1024)
-            return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-        return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
     }
     static formatTokens(n) {
-        if (n >= 1_000_000)
-            return `${(n / 1_000_000).toFixed(2)}M`;
+        if (n >= 1000000)
+            return `${(n / 1000000).toFixed(2)}M`;
         if (n >= 1000)
             return `${(n / 1000).toFixed(1)}k`;
         return `${n}`;
@@ -67,10 +66,11 @@ export class UsageTracker {
         const theme = getCurrentTheme();
         const summary = this.getSummary();
         const cols = Math.min(process.stdout.columns || 80, 75);
-        const boxWidth = Math.max(34, cols - 4);
-        const innerWidth = boxWidth - 4;
+        const boxWidth = Math.max(38, cols - 4);
+        const innerWidth = boxWidth - 6;
         const padRow = (label, value) => {
-            const plainLen = label.length + value.length;
+            const visibleValLen = stripAnsi(value).length;
+            const plainLen = label.length + visibleValLen;
             const spaces = Math.max(1, innerWidth - plainLen);
             return `│  ${pc.bold(label)}${' '.repeat(spaces)}${value}  │`;
         };

package/dist/mcp/client.js

@@ -0,0 +1,218 @@
+import { spawn } from 'child_process';
+export class MCPClient {
+    name;
+    config;
+    process = null;
+    nextRequestId = 1;
+    pendingRequests = new Map();
+    buffer = '';
+    tools = [];
+    isConnected = false;
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.config.disabled) {
+            throw new Error(`MCP server "${this.name}" is disabled in configuration.`);
+        }
+        return new Promise(async (resolve, reject) => {
+            let isSettled = false;
+            const initialTimer = setTimeout(() => {
+                if (!isSettled) {
+                    isSettled = true;
+                    this.close();
+                    reject(new Error(`MCP server "${this.name}" initialization timed out after 15s.`));
+                }
+            }, 15000);
+            try {
+                const env = {
+                    ...process.env,
+                    ...(this.config.env || {})
+                };
+                const isWindows = process.platform === 'win32';
+                const useShell = isWindows && (this.config.command.endsWith('.cmd') ||
+                    this.config.command.endsWith('.bat') ||
+                    this.config.command === 'npx' ||
+                    this.config.command === 'npm');
+                this.process = spawn(this.config.command, this.config.args || [], {
+                    env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    shell: useShell
+                });
+                this.process.stdout?.on('data', (data) => {
+                    this.handleStdout(data.toString());
+                });
+                this.process.stderr?.on('data', (_data) => {
+                    // Stderr from MCP servers is used for logging/debugging
+                });
+                this.process.on('error', (err) => {
+                    if (!isSettled) {
+                        isSettled = true;
+                        clearTimeout(initialTimer);
+                        reject(new Error(`Failed to start MCP server "${this.name}": ${err.message}`));
+                    }
+                    this.cleanup();
+                });
+                this.process.on('close', (_code) => {
+                    this.cleanup();
+                });
+                // 1. Initialize Handshake
+                const initResult = await this.sendRequest('initialize', {
+                    protocolVersion: '2024-11-05',
+                    capabilities: {},
+                    clientInfo: {
+                        name: 'devx',
+                        version: '1.4.0'
+                    }
+                });
+                if (!initResult) {
+                    throw new Error(`Invalid initialize response from MCP server "${this.name}".`);
+                }
+                // 2. Send initialized notification
+                this.sendNotification('notifications/initialized', {});
+                // 3. Fetch Tools List
+                const toolsResult = await this.sendRequest('tools/list', {});
+                this.tools = toolsResult?.tools || [];
+                this.isConnected = true;
+                if (!isSettled) {
+                    isSettled = true;
+                    clearTimeout(initialTimer);
+                    resolve(this.tools);
+                }
+            }
+            catch (err) {
+                if (!isSettled) {
+                    isSettled = true;
+                    clearTimeout(initialTimer);
+                    this.close();
+                    reject(err);
+                }
+            }
+        });
+    }
+    getTools() {
+        return this.tools;
+    }
+    hasConnected() {
+        return this.isConnected;
+    }
+    async callTool(toolName, args) {
+        if (!this.process || !this.isConnected) {
+            throw new Error(`MCP server "${this.name}" is not connected.`);
+        }
+        const res = await this.sendRequest('tools/call', {
+            name: toolName,
+            arguments: args || {}
+        }, 60000); // 60s timeout for tool calls
+        if (!res || !res.content) {
+            return JSON.stringify(res || {});
+        }
+        const outputParts = [];
+        for (const c of res.content) {
+            if (c.type === 'text' && c.text) {
+                outputParts.push(c.text);
+            }
+            else if (c.type === 'image' && c.data) {
+                outputParts.push(`[Image content (${c.mimeType || 'image/png'})]`);
+            }
+            else if (c.type === 'resource') {
+                outputParts.push(`[Resource: ${JSON.stringify(c)}]`);
+            }
+        }
+        const finalResult = outputParts.join('\n\n') || JSON.stringify(res);
+        if (res.isError) {
+            throw new Error(finalResult);
+        }
+        return finalResult;
+    }
+    handleStdout(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if ('id' in msg && msg.id !== undefined) {
+                    const pending = this.pendingRequests.get(msg.id);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        this.pendingRequests.delete(msg.id);
+                        if (msg.error) {
+                            pending.reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+                        }
+                        else {
+                            pending.resolve(msg.result);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore non-JSON line outputs (e.g. startup banner)
+            }
+        }
+    }
+    sendRequest(method, params, timeoutMs = 15000) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.process.stdin) {
+                return reject(new Error(`MCP server "${this.name}" process is not running.`));
+            }
+            const id = this.nextRequestId++;
+            const timer = setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`MCP request "${method}" to server "${this.name}" timed out (${timeoutMs / 1000}s).`));
+                }
+            }, timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            const request = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params
+            };
+            try {
+                this.process.stdin.write(JSON.stringify(request) + '\n');
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(new Error(`Failed to write to MCP server "${this.name}": ${err.message}`));
+            }
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process || !this.process.stdin)
+            return;
+        const notif = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        try {
+            this.process.stdin.write(JSON.stringify(notif) + '\n');
+        }
+        catch { }
+    }
+    close() {
+        this.cleanup();
+        if (this.process) {
+            try {
+                this.process.kill();
+            }
+            catch { }
+            this.process = null;
+        }
+    }
+    cleanup() {
+        this.isConnected = false;
+        for (const [id, req] of this.pendingRequests.entries()) {
+            clearTimeout(req.timer);
+            req.reject(new Error(`MCP server "${this.name}" disconnected.`));
+        }
+        this.pendingRequests.clear();
+    }
+}

package/dist/mcp/manager.js

@@ -0,0 +1,196 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import pc from 'picocolors';
+import { MCPClient } from './client.js';
+import { getCurrentTheme } from '../cli/theme.js';
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+export class MCPManager {
+    static instance;
+    clients = new Map();
+    tools = [];
+    serverStatuses = new Map();
+    isInitialized = false;
+    constructor() { }
+    static getInstance() {
+        if (!MCPManager.instance) {
+            MCPManager.instance = new MCPManager();
+        }
+        return MCPManager.instance;
+    }
+    async init(explicitConfigs) {
+        if (this.isInitialized) {
+            return this.tools;
+        }
+        const configs = explicitConfigs || await this.loadConfigs();
+        const serverEntries = Object.entries(configs);
+        if (serverEntries.length === 0) {
+            this.isInitialized = true;
+            return [];
+        }
+        const initPromises = serverEntries.map(async ([name, cfg]) => {
+            if (cfg.disabled) {
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'disabled',
+                    toolsCount: 0,
+                    tools: []
+                });
+                return;
+            }
+            this.serverStatuses.set(name, {
+                name,
+                command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                status: 'connecting',
+                toolsCount: 0,
+                tools: []
+            });
+            const client = new MCPClient(name, cfg);
+            this.clients.set(name, client);
+            try {
+                const mcpTools = await client.start();
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'connected',
+                    toolsCount: mcpTools.length,
+                    tools: mcpTools.map(t => t.name)
+                });
+                // Convert MCP tools into devx Tool format
+                for (const mt of mcpTools) {
+                    const namespacedName = `mcp__${name}__${mt.name}`;
+                    const devxTool = {
+                        name: namespacedName,
+                        definition: {
+                            name: namespacedName,
+                            description: `[MCP: ${name}] ${mt.description || mt.name}`,
+                            parameters: {
+                                type: 'object',
+                                properties: mt.inputSchema?.properties || {},
+                                required: mt.inputSchema?.required
+                            }
+                        },
+                        validateArgs(_args) { },
+                        async execute(args) {
+                            return await client.callTool(mt.name, args);
+                        }
+                    };
+                    this.tools.push(devxTool);
+                }
+            }
+            catch (err) {
+                this.serverStatuses.set(name, {
+                    name,
+                    command: `${cfg.command} ${(cfg.args || []).join(' ')}`.trim(),
+                    status: 'failed',
+                    toolsCount: 0,
+                    tools: [],
+                    error: err.message
+                });
+            }
+        });
+        await Promise.all(initPromises);
+        this.isInitialized = true;
+        return this.tools;
+    }
+    getTools() {
+        return this.tools;
+    }
+    getStatuses() {
+        return Array.from(this.serverStatuses.values());
+    }
+    async reload() {
+        this.stopAll();
+        this.isInitialized = false;
+        this.clients.clear();
+        this.tools = [];
+        this.serverStatuses.clear();
+        return await this.init();
+    }
+    stopAll() {
+        for (const client of this.clients.values()) {
+            try {
+                client.close();
+            }
+            catch { }
+        }
+        this.clients.clear();
+    }
+    renderStatusCard() {
+        const theme = getCurrentTheme();
+        const statuses = this.getStatuses();
+        const cols = Math.min(process.stdout.columns || 80, 80);
+        const boxWidth = Math.max(48, cols - 4);
+        const innerWidth = boxWidth - 6;
+        const padRow = (left, right) => {
+            const plainLen = stripAnsi(left).length + stripAnsi(right).length;
+            const spaces = Math.max(1, innerWidth - plainLen);
+            return `│  ${left}${' '.repeat(spaces)}${right}  │`;
+        };
+        const header = theme.colorFn('┌─ ') + pc.bold('🔌 Model Context Protocol (MCP) Servers') + ' ' + theme.colorFn('─'.repeat(Math.max(2, boxWidth - 43)) + '┐');
+        const divider = theme.colorFn('├' + '─'.repeat(boxWidth - 2) + '┤');
+        const footer = theme.colorFn('└' + '─'.repeat(boxWidth - 2) + '┘');
+        const lines = [header];
+        if (statuses.length === 0) {
+            lines.push(padRow(pc.dim('No MCP servers configured.'), ''));
+            lines.push(padRow(pc.dim('Configure in .devx/mcp.json or ~/.devxrc.json'), ''));
+            lines.push(footer);
+            return lines.join('\n') + '\n';
+        }
+        for (let i = 0; i < statuses.length; i++) {
+            const s = statuses[i];
+            if (i > 0)
+                lines.push(divider);
+            let statusBadge = pc.green('🟢 Connected');
+            if (s.status === 'connecting')
+                statusBadge = pc.yellow('🟡 Connecting');
+            if (s.status === 'failed')
+                statusBadge = pc.red('🔴 Failed');
+            if (s.status === 'disabled')
+                statusBadge = pc.dim('⚪ Disabled');
+            lines.push(padRow(pc.bold(pc.white(`Server: ${s.name}`)), statusBadge));
+            lines.push(padRow(pc.dim(`  Command: ${s.command.slice(0, 36)}${s.command.length > 36 ? '...' : ''}`), pc.cyan(`${s.toolsCount} tools`)));
+            if (s.tools.length > 0) {
+                const toolsListStr = s.tools.slice(0, 3).map(t => pc.dim(`• ${t}`)).join(' ');
+                const extra = s.tools.length > 3 ? pc.dim(` +${s.tools.length - 3} more`) : '';
+                lines.push(padRow(`  ${toolsListStr}${extra}`, ''));
+            }
+            if (s.error) {
+                lines.push(padRow(pc.red(`  Error: ${s.error.slice(0, innerWidth - 10)}`), ''));
+            }
+        }
+        lines.push(footer);
+        return lines.join('\n') + '\n';
+    }
+    async loadConfigs() {
+        const result = {};
+        const configPaths = [
+            path.join(os.homedir(), '.devxrc.json'),
+            path.join(process.cwd(), '.devx', 'mcp.json'),
+            path.join(process.cwd(), '.claude', 'mcp.json'),
+            path.join(process.cwd(), '.devx.json'),
+            path.join(process.cwd(), '.mcp.json')
+        ];
+        for (const pth of configPaths) {
+            try {
+                if (fsSync.existsSync(pth)) {
+                    const raw = await fs.readFile(pth, 'utf8');
+                    const parsed = JSON.parse(raw);
+                    if (parsed && typeof parsed.mcpServers === 'object') {
+                        for (const [name, cfg] of Object.entries(parsed.mcpServers)) {
+                            if (cfg && typeof cfg === 'object' && cfg.command) {
+                                result[name] = cfg;
+                            }
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        return result;
+    }
+}

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/permissions/guard.js

@@ -23,16 +23,25 @@ function isPathOutsideCwd(targetPath) {
 function isDangerousBashCommand(commandStr) {
     if (!commandStr)
         return false;
-    const lower = commandStr.toLowerCase().trim();
-    return (lower.includes('rm -rf /') ||
-        lower.includes('rm -rf ~') ||
-        lower.includes('rm -rf *') ||
-        lower.includes('mkfs') ||
-        lower.includes('dd if=') ||
-        lower.includes(':(){ :|:& };:') ||
-        lower.includes('chmod -r 777 /') ||
-        lower.includes('> /dev/sda') ||
-        lower.includes('format c:'));
+    // Normalize whitespace: collapse multiple spaces/tabs into single space
+    const norm = commandStr.toLowerCase().replace(/\s+/g, ' ').trim();
+    // Pattern matching rm with combined flags (-rf, -fr, -r -f, etc.) targeting root, home, termux prefix, or glob
+    const isDangerousRm = /rm\s+-(?:[a-z]*r[a-z]*f|[a-z]*f[a-z]*r)\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*r[a-z]*\s+-[a-z]*f[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm) ||
+        /rm\s+-[a-z]*f[a-z]*\s+-[a-z]*r[a-z]*\s+(?:\/|\/\*|~|~\/|\*|\$home|\$prefix|\/data\/data\/com\.termux)/i.test(norm);
+    return (isDangerousRm ||
+        norm.includes('rm -rf /') ||
+        norm.includes('rm -rf ~') ||
+        norm.includes('rm -rf *') ||
+        norm.includes('rm -rf $prefix') ||
+        norm.includes('rm -rf $home') ||
+        norm.includes('rm -rf /data/data/com.termux') ||
+        norm.includes('mkfs') ||
+        norm.includes('dd if=') ||
+        norm.includes(':(){ :|:& };:') ||
+        norm.includes('chmod -r 777 /') ||
+        norm.includes('> /dev/sda') ||
+        norm.includes('format c:'));
 }
 /**
  * Checks if a command contains chaining, redirection, or subshell operators.
@@ -98,15 +107,30 @@ export class CLIConsoleGuard {
                 return true;
             }
         }
+        // 5. MCP Tools: ask if autoApprove is false
+        if (t.startsWith('mcp__')) {
+            return true;
+        }
         return false;
     }
     async askUser(toolName, args) {
         const t = (toolName || '').toLowerCase();
         const cmd = args?.command || args?.cmd || '';
         const isDangerous = t === 'bash' && isDangerousBashCommand(cmd);
+        // In headless / non-interactive environment without TTY, deny confirmation-requiring actions immediately
+        if (!process.stdin.isTTY) {
+            console.error(pc.red(`\n🛡️  [PERMISSION DENIED] Action '${toolName}' requires user confirmation in safe mode, but no interactive terminal is available. Pass --yolo (-y) to auto-approve actions in headless mode.`));
+            return false;
+        }
         if (isDangerous) {
             p.log.error(pc.bold(pc.red('⚠️  [SECURITY WARNING] Agent requested a potentially dangerous system command!')));
         }
+        else if (t.startsWith('mcp__')) {
+            const parts = toolName.split('__');
+            const serverName = parts[1] || 'mcp';
+            const mcpToolName = parts.slice(2).join('__');
+            p.log.warn(pc.bold(pc.yellow(`🛡️  [PERMISSION GUARD] Agent wants to call MCP Tool: ${pc.cyan(serverName)} / ${pc.green(mcpToolName)}`)));
+        }
         else {
             p.log.warn(pc.bold(pc.yellow(`🛡️  [PERMISSION GUARD] Agent wants to execute: ${pc.cyan(toolName)}`)));
         }

package/dist/providers/openai.js

@@ -131,11 +131,20 @@ export class OpenAIProvider {
         }
         return {
             content: choice.content || null,
-            toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => ({
-                id: tc.id,
-                name: tc.function.name,
-                arguments: JSON.parse(tc.function.arguments)
-            })) : undefined,
+            toolCalls: choice.tool_calls ? choice.tool_calls.map((tc) => {
+                let parsedArgs = {};
+                try {
+                    parsedArgs = JSON.parse(tc.function.arguments);
+                }
+                catch {
+                    parsedArgs = {};
+                }
+                return {
+                    id: tc.id || `call_${Math.random().toString(36).substring(2, 9)}`,
+                    name: tc.function.name,
+                    arguments: parsedArgs
+                };
+            }) : undefined,
             usage
         };
     }

package/dist/tools/bash.js

@@ -20,20 +20,27 @@ export const bashTool = {
         return new Promise((resolve, reject) => {
             const proc = spawn(args.command, { shell: true });
             let output = '';
+            let isTruncated = false;
             const timeout = setTimeout(() => {
                 proc.kill();
                 resolve(output + '\n[Process killed due to timeout]');
             }, 30000);
             proc.stdout.on('data', (data) => {
+                if (isTruncated)
+                    return;
                 output += data.toString();
                 if (output.length > 20000) {
+                    isTruncated = true;
                     output = output.substring(0, 20000) + '\n[Output truncated]';
                     proc.kill();
                 }
             });
             proc.stderr.on('data', (data) => {
+                if (isTruncated)
+                    return;
                 output += data.toString();
                 if (output.length > 20000) {
+                    isTruncated = true;
                     output = output.substring(0, 20000) + '\n[Output truncated]';
                     proc.kill();
                 }

package/dist/tools/fs.js

@@ -153,7 +153,7 @@ export const editFileTool = {
             let addCounter = startLine;
             addedArr.forEach((l) => diffLines.push(`${addCounter++} +  ${l}`));
             contextAfter.forEach((l) => diffLines.push(`${addCounter++}    ${l}`));
-            const newContent = content.replace(target, args.replacement);
+            const newContent = content.slice(0, targetIndex) + args.replacement + content.slice(targetIndex + target.length);
             await fs.writeFile(args.path, newContent, 'utf8');
             return JSON.stringify({
                 status: 'success',

package/dist/tools/index.js

@@ -9,11 +9,13 @@ import { saveMemoryTool } from '../core/memory.js';
 import { planReadyTool, lastPlanReady, resetPlanReady } from './plan.js';
 import { todoListTool, currentTodoList, resetTodoList } from './todo.js';
 import { servePreviewTool } from './server.js';
+import { MCPManager } from '../mcp/manager.js';
 export function getTools(planMode) {
     const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool, todoListTool];
+    const mcpTools = MCPManager.getInstance().getTools();
     if (planMode) {
-        return baseTools;
+        return [...baseTools, ...mcpTools];
     }
-    return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool, servePreviewTool];
+    return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool, servePreviewTool, ...mcpTools];
 }
 export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady, todoListTool, currentTodoList, resetTodoList, servePreviewTool };

package/dist/tools/web.js

@@ -1,8 +1,8 @@
 function stripHtml(html) {
     return html
-        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
-        .replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, '')
+        .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+        .replace(/<style\b[\s\S]*?<\/style>/gi, '')
+        .replace(/<svg\b[\s\S]*?<\/svg>/gi, '')
         .replace(/<[^>]+>/g, ' ')
         .replace(/&quot;/g, '"')
         .replace(/&amp;/g, '&')