termux-dev 1.3.0 → 1.4.1

package/dist/cli/prompt.js

@@ -10,6 +10,7 @@ export const SLASH_COMMANDS = [
     { cmd: '/session del', desc: 'Select and delete saved sessions' },
     { cmd: '/usage', desc: 'Show network bandwidth, data saver & token cost' },
     { cmd: '/export', desc: 'Export session conversation to Markdown' },
+    { cmd: '/mcp', desc: 'Manage Model Context Protocol (MCP) servers & tools' },
     { cmd: '/theme', desc: 'Switch UI theme (Cyan, Purple, Matrix, Amber, etc.)' },
     { cmd: '/doctor', desc: 'Run system & environment health diagnostics' },
     { cmd: '/settings', desc: 'Configure permissions & auto-approval' },
@@ -151,18 +152,27 @@ export function askPrompt(opts = {}) {
             }
             return result;
         }
+        function stripAnsi(str) {
+            return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+        }
         function render() {
             if (disposed)
                 return;
             const items = getDropdownItems();
             const dropdownLines = [];
+            const cols = Math.max(28, process.stdout.columns || 80);
+            const rows = Math.max(8, process.stdout.rows || 24);
             if (items.length > 0) {
                 if (selectedIndex >= items.length)
                     selectedIndex = 0;
                 if (selectedIndex < 0)
                     selectedIndex = items.length - 1;
-                const boxWidth = Math.min((process.stdout.columns || 80) - 6, 60);
-                const pageSize = Math.min(5, Math.max(3, Math.floor(((process.stdout.rows || 24) - 4) / 2)));
+                // Ensure inner box width strictly fits: innerBoxWidth + 5 <= cols - 2
+                const innerBoxWidth = Math.max(16, Math.min(cols - 8, 54));
+                const isNarrowOrShort = rows <= 16 || cols < 50;
+                const pageSize = isNarrowOrShort
+                    ? Math.max(2, Math.min(3, rows - 5))
+                    : Math.min(5, Math.max(3, Math.floor((rows - 4) / 2)));
                 const total = items.length;
                 let startIndex = 0;
                 if (total > pageSize) {
@@ -173,26 +183,47 @@ export function askPrompt(opts = {}) {
                 const endIndex = Math.min(startIndex + pageSize, total);
                 const hasMoreUp = startIndex > 0;
                 const hasMoreDown = endIndex < total;
-                let topBorderStr = '─'.repeat(boxWidth);
+                let topBorderStr = '─'.repeat(innerBoxWidth);
                 if (hasMoreUp) {
-                    const mid = Math.max(0, Math.floor(boxWidth / 2) - 2);
-                    topBorderStr = '─'.repeat(mid) + ' ▲ ' + '─'.repeat(Math.max(0, boxWidth - mid - 3));
+                    const mid = Math.max(0, Math.floor(innerBoxWidth / 2) - 2);
+                    topBorderStr = '─'.repeat(mid) + ' ▲ ' + '─'.repeat(Math.max(0, innerBoxWidth - mid - 3));
                 }
-                let botBorderStr = '─'.repeat(boxWidth);
+                let botBorderStr = '─'.repeat(innerBoxWidth);
                 if (hasMoreDown) {
-                    const mid = Math.max(0, Math.floor(boxWidth / 2) - 2);
-                    botBorderStr = '─'.repeat(mid) + ' ▼ ' + '─'.repeat(Math.max(0, boxWidth - mid - 3));
+                    const mid = Math.max(0, Math.floor(innerBoxWidth / 2) - 2);
+                    botBorderStr = '─'.repeat(mid) + ' ▼ ' + '─'.repeat(Math.max(0, innerBoxWidth - mid - 3));
                 }
                 dropdownLines.push(pc.dim('│') + '  ' + pc.dim('╭' + topBorderStr + '╮'));
                 for (let i = startIndex; i < endIndex; i++) {
                     const item = items[i];
                     const isSelected = i === selectedIndex;
-                    const labelStr = item.label.length > 20 ? item.label.slice(0, 19) + '…' : item.label.padEnd(20);
-                    const maxDescLen = Math.max(6, boxWidth - 25);
-                    const descStr = item.desc.length > maxDescLen ? item.desc.slice(0, maxDescLen - 3) + '...' : item.desc.padEnd(maxDescLen);
-                    let row = ` ${isSelected ? theme.colorFn('›') : ' '} ${isSelected ? theme.boldFn(labelStr) : pc.white(labelStr)} ${pc.gray(descStr)} `;
-                    if (isSelected) {
-                        row = theme.badgeFn(`› ${labelStr} ${descStr}`);
+                    const pointer = isSelected ? '› ' : '  ';
+                    const availWidth = innerBoxWidth - 2;
+                    let row = '';
+                    if (availWidth < 20) {
+                        // Very narrow mobile screen: show command name only
+                        const labelStr = item.label.length > availWidth ? item.label.slice(0, availWidth - 1) + '…' : item.label.padEnd(availWidth);
+                        const plain = pointer + labelStr;
+                        row = isSelected ? theme.badgeFn(plain) : (pointer + theme.boldFn(labelStr));
+                    }
+                    else {
+                        // Show command name and truncated description
+                        const labelMax = Math.min(15, Math.floor(availWidth * 0.45));
+                        const labelStr = item.label.length > labelMax ? item.label.slice(0, labelMax - 1) + '…' : item.label.padEnd(labelMax);
+                        const descMax = availWidth - labelMax - 1;
+                        const descStr = item.desc.length > descMax ? item.desc.slice(0, descMax - 1) + '…' : item.desc.padEnd(descMax);
+                        const plain = `${pointer}${labelStr} ${descStr}`;
+                        if (isSelected) {
+                            row = theme.badgeFn(plain);
+                        }
+                        else {
+                            row = `${pointer}${theme.boldFn(labelStr)} ${pc.gray(descStr)}`;
+                        }
+                    }
+                    // Safety guarantee: exact visible width must match innerBoxWidth
+                    const currentLen = stripAnsi(row).length;
+                    if (currentLen < innerBoxWidth) {
+                        row += ' '.repeat(innerBoxWidth - currentLen);
                     }
                     dropdownLines.push(pc.dim('│') + '  ' + pc.dim('│') + row + pc.dim('│'));
                 }
@@ -201,7 +232,9 @@ export function askPrompt(opts = {}) {
             // 1. Draw/update input line (line 0)
             let inputDisplay = pc.dim('│') + '  ';
             if (input.length === 0) {
-                inputDisplay += pc.dim(placeholder);
+                const maxPlace = Math.max(12, cols - 8);
+                const displayPlace = placeholder.length > maxPlace ? placeholder.slice(0, maxPlace - 1) + '…' : placeholder;
+                inputDisplay += pc.dim(displayPlace);
             }
             else {
                 inputDisplay += formatInputWithBadges(input);

package/dist/cli/server.js

@@ -139,7 +139,7 @@ function renderDirectoryHtml(dirPath, relPath, files, port) {
       ${parentLink}
       ${items || '<li style="padding: 20px; text-align: center; color: #6e7681;">No visible files in this directory</li>'}
     </ul>
-    <div class="footer">devx v1.3.0 &bull; Terminal-Native AI Assistant</div>
+    <div class="footer">devx v1.4.1 &bull; Terminal-Native AI Assistant</div>
   </div>
 </body>
 </html>`;

package/dist/cli/updater.js

@@ -85,12 +85,6 @@ export async function checkForUpdates(timeoutMs = 10000) {
             currentVersion,
             latestVersion: latestVersion || currentVersion
         };
-        return {
-            updateAvailable: false,
-            currentVersion,
-            latestVersion: currentVersion,
-            error: `HTTP ${res.status}`
-        };
     }
     catch (err) {
         clearTimeout(timer);

package/dist/core/commands.js

@@ -64,12 +64,12 @@ export class CustomCommandManager {
             return trimmedArgs ? `${template}\n\nUser Arguments: ${trimmedArgs}` : template;
         }
         let expanded = template;
-        expanded = expanded.replace(/\$ARG/g, trimmedArgs);
-        expanded = expanded.replace(/\$\*/g, trimmedArgs);
+        expanded = expanded.replace(/\$ARG/g, () => trimmedArgs);
+        expanded = expanded.replace(/\$\*/g, () => trimmedArgs);
         // Support positional parameters: $1, $2, etc.
         const parts = trimmedArgs.split(/\s+/);
         for (let i = 0; i < parts.length; i++) {
-            expanded = expanded.replace(new RegExp(`\\$${i + 1}`, 'g'), parts[i]);
+            expanded = expanded.replace(new RegExp(`\\$${i + 1}`, 'g'), () => parts[i]);
         }
         return expanded;
     }

package/dist/core/history.js

@@ -16,6 +16,16 @@ export class History {
     getMessages() {
         return [...this.messages];
     }
+    popLastTurn() {
+        // Pop assistant and tool messages from the end of history
+        while (this.messages.length > 1 && this.messages[this.messages.length - 1].role !== 'user') {
+            this.messages.pop();
+        }
+        // Pop the triggering user message
+        if (this.messages.length > 1 && this.messages[this.messages.length - 1].role === 'user') {
+            this.messages.pop();
+        }
+    }
     clear() {
         this.messages = [];
     }

package/dist/core/loop.js

@@ -94,9 +94,13 @@ export class Agent {
                                 response = chunk.response;
                             }
                         }
-                        if (response || receivedAnyChunk) {
+                        if (response) {
                             break;
                         }
+                        if (!receivedAnyChunk) {
+                            throw new Error('Provider stream ended unexpectedly without receiving any data.');
+                        }
+                        break;
                     }
                     else {
                         response = await this.provider.chat(request);

package/dist/core/models.js

@@ -33,7 +33,7 @@ export function getModelContextLimit(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('kimi-k2') || clean.includes('kimi'))

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.1'
+                    }
+                });
+                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();
+    }
+}