termux-dev 1.3.0 → 1.4.1

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, '&')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Ultra-fast, terminal-native AI coding assistant and agent built for Android Termux, Windows, macOS, and Linux.",
   "main": "dist/cli/index.js",
   "type": "module",