termux-dev 1.1.0 → 1.1.2

package/assets/banner.svg

@@ -25,7 +25,7 @@
 
   <!-- Tagline & Badge -->
   <text x="425" y="142" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" fill="#8b949e" text-anchor="middle" letter-spacing="3">
-    THE TERMINAL-NATIVE AI CODING AGENT <tspan fill="#00f2fe" font-weight="bold">v1.1.0</tspan>
+    THE TERMINAL-NATIVE AI CODING AGENT <tspan fill="#00f2fe" font-weight="bold">v1.1.2</tspan>
   </text>
 
   <!-- Top Accent Line -->

package/dist/cli/index.js

@@ -378,7 +378,7 @@ function drawLogo() {
             pc.cyan('  █▀▀▄ █▀▀▀ █   █ █   █'),
             pc.cyan('  █  █ █▀▀▀  ▀▄▀   ▀▄▀ '),
             pc.cyan('  █▄▄▀ █▄▄▄   ▀    ▀ ▀ '),
-            '  ' + pc.cyan(pc.bold('v1.1.0')),
+            '  ' + pc.cyan(pc.bold('v1.1.2')),
             ''
         ];
         for (const line of logo) {
@@ -393,7 +393,7 @@ function drawLogo() {
             indent + pc.cyan('▀▀▀█▀▀▀ █▀▀▀ █▀▀█ █▄ ▄█ █  █ ▀▄ ▄▀    █▀▀▄ █▀▀▀ █   █'),
             indent + pc.cyan('   █    █▀▀▀ █▄▄▀ █ █ █ █  █   █   ▀▀ █  █ █▀▀▀ █   █'),
             indent + pc.cyan('   █    █▄▄▄ █ ▀▄ █   █ ▀▄▄▀ ▄▀ ▀▄    █▄▄▀ █▄▄▄  ▀▄▀ '),
-            indent + pc.cyan(pc.bold('v1.1.0')),
+            indent + pc.cyan(pc.bold('v1.1.2')),
             ''
         ];
         for (const line of logo) {
@@ -415,6 +415,33 @@ function formatSessionTime(timestamp) {
     const days = Math.floor(hours / 24);
     return `${days}d ago`;
 }
+function formatToolGeneratingLabel(name, targetHint) {
+    const t = name.toLowerCase();
+    const target = targetHint ? ` ${targetHint}` : '';
+    if (t === 'read_file' || t === 'read')
+        return `→ Read${target || '...'}`;
+    if (t === 'write_file' || t === 'write')
+        return `→ Write${target || '...'}`;
+    if (t === 'edit_file' || t === 'patch')
+        return `→ Edit${target || '...'}`;
+    if (t === 'delete_file' || t === 'remove_file' || t === 'rm')
+        return `→ Delete${target || '...'}`;
+    if (t === 'bash' || t === 'run_command' || t === 'exec')
+        return `→ Run:${target || '...'}`;
+    if (t === 'search' || t === 'grep_search')
+        return `→ Search${target || '...'}`;
+    if (t === 'list_dir' || t === 'ls')
+        return `→ List${target || '...'}`;
+    if (t === 'todo_list' || t === 'update_todos')
+        return `→ Update Plan & Tasks...`;
+    if (t === 'plan_ready')
+        return `→ Finalize Plan...`;
+    if (t === 'diagnose_code')
+        return `→ Diagnosing code...`;
+    if (t === 'ask_questions')
+        return `→ Clarifying questions...`;
+    return `→ ${name}${target}...`;
+}
 async function handleSessionDelete() {
     while (true) {
         const sessions = await SessionManager.listSessions();
@@ -588,7 +615,7 @@ export async function main() {
                         const maxIter = config.maxIterations || 100;
                         const maxIterLabel = maxIter >= 9999 ? 'Unlimited' : `${maxIter} steps`;
                         const choice = await select({
-                            message: `${pc.bold('⚙️  Settings')} ${pc.dim('(devx v1.1.0 • by ApvCode)')}`,
+                            message: `${pc.bold('⚙️  Settings')} ${pc.dim('(devx v1.1.2 • by ApvCode)')}`,
                             choices: [
                                 {
                                     name: `${config.pureBlackTheme !== false ? pc.green('🎨 Pure Black Background: ON') : pc.yellow('🎨 Pure Black Background: OFF')}`,
@@ -624,7 +651,7 @@ export async function main() {
                                     description: 'Limit how many tool steps (file edits, terminal commands) agent can do per request'
                                 },
                                 {
-                                    name: `${pc.cyan('✨ About devx')} ${pc.dim('(v1.1.0 by ApvCode)')}`,
+                                    name: `${pc.cyan('✨ About devx')} ${pc.dim('(v1.1.2 by ApvCode)')}`,
                                     value: 'about',
                                     description: 'Terminal-Native AI Coding Agent created by ApvCode (https://github.com/apvcode/Termux-Dev)'
                                 },
@@ -636,7 +663,7 @@ export async function main() {
                             ]
                         });
                         if (choice === 'about') {
-                            p.note(`⚡ devx v1.1.0 — Terminal-Native AI Coding Agent\n` +
+                            p.note(`⚡ devx v1.1.2 — Terminal-Native AI Coding Agent\n` +
                                 `👤 Author: ApvCode (https://github.com/apvcode)\n` +
                                 `🌟 Repository: https://github.com/apvcode/Termux-Dev\n` +
                                 `📜 License: MIT License (2026)\n` +
@@ -1368,15 +1395,15 @@ export async function main() {
                     }
                 }
                 else if (event.type === 'tool_generating') {
+                    const label = formatToolGeneratingLabel(event.name, event.targetHint);
                     if (!spinnerActive) {
                         streamer.finish();
                         finishThinking(false);
-                        s.start(pc.cyan(`⚡ Calling ${event.name}...`));
+                        s.start(pc.bold(pc.cyan(label)));
                         spinnerActive = true;
                     }
                     else {
-                        const chars = event.bytes > 1000 ? `${(event.bytes / 1000).toFixed(1)}k chars` : `${event.bytes} chars`;
-                        s.message(pc.cyan(`⚡ Generating ${event.name} (${chars})...`));
+                        s.message(pc.bold(pc.cyan(label)));
                     }
                 }
                 else if (event.type === 'tool_start') {

package/dist/cli/server.js

@@ -10,6 +10,8 @@ const MIME_TYPES = {
     '.css': 'text/css; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
     '.mjs': 'application/javascript; charset=utf-8',
+    '.ts': 'text/plain; charset=utf-8',
+    '.tsx': 'text/plain; charset=utf-8',
     '.json': 'application/json; charset=utf-8',
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -22,6 +24,8 @@ const MIME_TYPES = {
     '.mp3': 'audio/mpeg',
     '.ogg': 'audio/ogg',
     '.wasm': 'application/wasm',
+    '.pdf': 'application/pdf',
+    '.md': 'text/markdown; charset=utf-8',
     '.txt': 'text/plain; charset=utf-8'
 };
 let activeServer = null;
@@ -45,12 +49,98 @@ export function getServerPort() {
 }
 export function stopServer() {
     if (activeServer) {
-        activeServer.close();
+        try {
+            activeServer.close();
+        }
+        catch { }
         activeServer = null;
         return true;
     }
     return false;
 }
+function renderDirectoryHtml(dirPath, relPath, files, port) {
+    const currentRel = relPath === '/' ? '' : relPath;
+    const items = files
+        .filter(f => !f.name.startsWith('.') && f.name !== 'node_modules')
+        .sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    })
+        .map(f => {
+        const isDir = f.isDirectory();
+        const href = `${currentRel}/${encodeURIComponent(f.name)}${isDir ? '/' : ''}`;
+        const ext = path.extname(f.name).toLowerCase();
+        let icon = isDir ? '📁' : '📄';
+        let badge = '';
+        if (ext === '.html' || ext === '.htm') {
+            icon = '🌐';
+            badge = '<span class="badge">HTML</span>';
+        }
+        else if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'].includes(ext)) {
+            icon = '🖼️';
+        }
+        else if (['.js', '.ts', '.tsx', '.jsx', '.json'].includes(ext)) {
+            icon = '⚡';
+        }
+        else if (ext === '.css') {
+            icon = '🎨';
+        }
+        return `
+        <li>
+          <a class="file-item" href="${href}">
+            <span class="icon">${icon}</span>
+            <span class="name">${f.name}</span>
+            ${badge}
+            <span class="type">${isDir ? 'Directory' : ext || 'File'}</span>
+          </a>
+        </li>
+      `;
+    })
+        .join('');
+    const parentLink = currentRel && currentRel !== '/'
+        ? `<li><a class="file-item" href="${path.dirname(currentRel) === '/' ? '/' : path.dirname(currentRel) + '/'}"><span class="icon">⬆️</span><span class="name">.. (Parent Directory)</span></a></li>`
+        : '';
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>devx Live Preview &bull; ${relPath}</title>
+  <style>
+    * { box-sizing: border-box; }
+    body { background: #0a0a0c; color: #e1e4e8; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, monospace; margin: 0; padding: 24px 16px; }
+    .card { background: #111116; border: 1px solid #22222c; border-radius: 12px; max-width: 800px; margin: 0 auto; padding: 24px; box-shadow: 0 8px 30px rgba(0,0,0,0.6); }
+    h1 { color: #00f2fe; margin: 0 0 8px 0; font-size: 22px; display: flex; align-items: center; gap: 8px; }
+    .info { color: #8b949e; font-size: 14px; margin-bottom: 20px; word-break: break-all; }
+    .info code { background: #1a1a24; padding: 2px 6px; border-radius: 4px; color: #f0f6fc; }
+    ul { list-style: none; padding: 0; margin: 0; }
+    .file-item { display: flex; align-items: center; padding: 10px 14px; border-bottom: 1px solid #1a1a22; text-decoration: none; color: #f0f6fc; border-radius: 6px; transition: all 0.15s; }
+    .file-item:hover { background: #1a1a26; transform: translateX(3px); }
+    .icon { margin-right: 12px; font-size: 18px; }
+    .name { flex: 1; font-weight: 500; font-size: 14px; word-break: break-all; }
+    .type { color: #6e7681; font-size: 12px; margin-left: 12px; }
+    .badge { background: rgba(0, 242, 254, 0.15); color: #00f2fe; border: 1px solid rgba(0, 242, 254, 0.3); padding: 2px 8px; border-radius: 12px; font-size: 11px; margin-left: 8px; font-weight: bold; }
+    .footer { margin-top: 24px; text-align: center; color: #484f58; font-size: 12px; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>⚡ devx Live Preview</h1>
+    <div class="info">
+      Path: <code>${relPath}</code> &bull; Port: <code>${port}</code>
+    </div>
+    <ul>
+      ${parentLink}
+      ${items || '<li style="padding: 20px; text-align: center; color: #6e7681;">No visible files in this directory</li>'}
+    </ul>
+    <div class="footer">devx v1.1.2 &bull; Terminal-Native AI Assistant</div>
+  </div>
+</body>
+</html>`;
+}
 export async function startServer(preferredPort = 3000) {
     if (activeServer) {
         stopServer();
@@ -59,75 +149,108 @@ export async function startServer(preferredPort = 3000) {
     return new Promise((resolve, reject) => {
         const server = http.createServer(async (req, res) => {
             try {
-                let reqPath = decodeURIComponent(req.url?.split('?')[0] || '/');
-                if (reqPath === '/') {
-                    reqPath = '/index.html';
-                }
-                const filePath = path.join(process.cwd(), reqPath);
+                let rawPath = req.url?.split('?')[0] || '/';
+                let reqPath = decodeURIComponent(rawPath);
+                const cwd = process.cwd();
+                let targetPath = path.resolve(cwd, '.' + reqPath);
                 // Security check: ensure path is within cwd
-                if (!filePath.startsWith(process.cwd())) {
+                const rel = path.relative(cwd, targetPath);
+                if (rel.startsWith('..') || path.isAbsolute(rel)) {
                     res.writeHead(403, { 'Content-Type': 'text/plain' });
                     res.end('Forbidden');
                     return;
                 }
-                if (!fsSync.existsSync(filePath)) {
-                    // If html file requested without extension
-                    const withHtml = `${filePath}.html`;
-                    if (fsSync.existsSync(withHtml)) {
-                        const content = await fs.readFile(withHtml);
-                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(content);
+                // 1. Root / Directory Request Handling
+                if (fsSync.existsSync(targetPath)) {
+                    const stat = await fs.stat(targetPath);
+                    if (stat.isDirectory()) {
+                        // Check for index.html in directory
+                        const possibleIndexes = [
+                            path.join(targetPath, 'index.html'),
+                            path.join(targetPath, 'index.htm'),
+                            path.join(targetPath, 'public/index.html'),
+                            path.join(targetPath, 'dist/index.html'),
+                            path.join(targetPath, 'build/index.html')
+                        ];
+                        for (const idxPath of possibleIndexes) {
+                            if (fsSync.existsSync(idxPath)) {
+                                const content = await fs.readFile(idxPath);
+                                res.writeHead(200, {
+                                    'Content-Type': 'text/html; charset=utf-8',
+                                    'Access-Control-Allow-Origin': '*'
+                                });
+                                res.end(content);
+                                return;
+                            }
+                        }
+                        // If no index.html, render sleek directory explorer
+                        const dirents = await fs.readdir(targetPath, { withFileTypes: true });
+                        const dirHtml = renderDirectoryHtml(targetPath, reqPath, dirents, activePort);
+                        res.writeHead(200, {
+                            'Content-Type': 'text/html; charset=utf-8',
+                            'Access-Control-Allow-Origin': '*'
+                        });
+                        res.end(dirHtml);
                         return;
                     }
-                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-                    res.end(`404 Not Found: ${reqPath}`);
-                    return;
                 }
-                const stat = await fs.stat(filePath);
-                if (stat.isDirectory()) {
-                    const indexPath = path.join(filePath, 'index.html');
-                    if (fsSync.existsSync(indexPath)) {
-                        const content = await fs.readFile(indexPath);
-                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(content);
-                        return;
+                // 2. Fallback check for missing .html extension
+                if (!fsSync.existsSync(targetPath)) {
+                    const withHtml = `${targetPath}.html`;
+                    if (fsSync.existsSync(withHtml)) {
+                        targetPath = withHtml;
                     }
-                    res.writeHead(403, { 'Content-Type': 'text/plain' });
-                    res.end('Directory listing disabled');
+                }
+                // 3. Serve File
+                if (fsSync.existsSync(targetPath)) {
+                    const ext = path.extname(targetPath).toLowerCase();
+                    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+                    const content = await fs.readFile(targetPath);
+                    res.writeHead(200, {
+                        'Content-Type': contentType,
+                        'Access-Control-Allow-Origin': '*'
+                    });
+                    res.end(content);
+                    return;
+                }
+                // 4. SPA Fallback: check if root index.html exists
+                const rootIndex = path.join(cwd, 'index.html');
+                if (fsSync.existsSync(rootIndex)) {
+                    const content = await fs.readFile(rootIndex);
+                    res.writeHead(200, {
+                        'Content-Type': 'text/html; charset=utf-8',
+                        'Access-Control-Allow-Origin': '*'
+                    });
+                    res.end(content);
                     return;
                 }
-                const ext = path.extname(filePath).toLowerCase();
-                const contentType = MIME_TYPES[ext] || 'application/octet-stream';
-                const content = await fs.readFile(filePath);
-                res.writeHead(200, {
-                    'Content-Type': contentType,
-                    'Access-Control-Allow-Origin': '*'
-                });
-                res.end(content);
+                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end(`404 Not Found: ${reqPath}`);
             }
             catch (err) {
-                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
                 res.end(`Internal Server Error: ${err.message}`);
             }
         });
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
-                server.listen(activePort + 1);
                 activePort++;
+                server.listen(activePort, '0.0.0.0');
             }
             else {
                 reject(err);
             }
         });
-        server.listen(activePort, () => {
+        server.listen(activePort, '0.0.0.0', () => {
             activeServer = server;
             const localIp = getLocalIp();
             const localUrl = `http://localhost:${activePort}`;
             const networkUrl = `http://${localIp}:${activePort}`;
-            // If in Android Termux, try to open in browser
+            // If on Android Termux, attempt to open browser
             if (process.env.PREFIX?.includes('com.termux')) {
                 try {
-                    spawn('termux-open-url', [localUrl], { stdio: 'ignore' });
+                    const opener = spawn('termux-open-url', [localUrl], { stdio: 'ignore', detached: true });
+                    opener.unref();
                 }
                 catch { }
             }

package/dist/cli/updater.js

@@ -102,75 +102,92 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
 }
+async function isGitRepository(dir) {
+    try {
+        await fs.stat(path.join(dir, '.git'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function performSelfUpdate(latestVersion) {
     const __filename = fileURLToPath(import.meta.url);
     const projectRoot = path.resolve(path.dirname(__filename), '../../');
+    const isGit = await isGitRepository(projectRoot);
     console.log('\n' + pc.bold(pc.cyan('─── 🚀 Starting devx Update ──────────────────────────')));
-    const steps = [
-        {
-            title: '📦 Pulling latest updates from GitHub repository...',
-            action: () => {
-                try {
-                    execSync('git pull origin main --quiet', { cwd: projectRoot, stdio: 'pipe' });
-                }
-                catch {
-                    // If not git clone or detached, try global git install or fetch
-                    try {
-                        execSync('git pull --quiet', { cwd: projectRoot, stdio: 'pipe' });
-                    }
-                    catch {
-                        execSync(`npm install -g git+${GITHUB_REPO_URL}.git --quiet`, { stdio: 'pipe' });
-                    }
-                }
-            }
-        },
-        {
-            title: '🔨 Building and compiling TypeScript sources...',
-            action: () => {
-                execSync('npm install --quiet', { cwd: projectRoot, stdio: 'pipe' });
-                execSync('npm run build --quiet', { cwd: projectRoot, stdio: 'pipe' });
-            }
-        },
-        {
-            title: '🔑 Ensuring binary execution permissions & linking...',
-            action: () => {
-                try {
-                    execSync('chmod +x bin/* 2>/dev/null || true', { cwd: projectRoot, stdio: 'pipe' });
-                }
-                catch { }
-                try {
-                    execSync('npm link --quiet', { cwd: projectRoot, stdio: 'pipe' });
-                }
-                catch { }
-            }
-        }
-    ];
-    for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        process.stdout.write(`  ${pc.cyan('⚡')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
-        // Animation spinner for each step
+    if (!isGit) {
+        // 1. Installed via global npm package: termux-dev
+        process.stdout.write(`  ${pc.cyan('⚡')} [1/1] ${pc.white(`Updating termux-dev via npm (v${latestVersion})...`)}\n`);
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let fIdx = 0;
         const interval = setInterval(() => {
-            process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(step.title)} `);
+            process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(`npm install -g termux-dev@latest`)} `);
         }, 80);
         try {
-            await new Promise(resolve => setTimeout(resolve, 300));
-            step.action();
+            execSync('npm install -g termux-dev@latest', { stdio: 'pipe' });
             clearInterval(interval);
-            process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(step.title))}\n`);
+            process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(`Successfully updated termux-dev to v${latestVersion} via npm!`))}\n`);
         }
         catch (err) {
             clearInterval(interval);
-            process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(step.title)} - ${err.message}\n`);
-            console.log(pc.red(`\nUpdate failed during step ${i + 1}: ${err.message}`));
+            process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(`Update failed: ${err.message}`)}\n`);
+            console.log(pc.yellow(`\n💡 To update manually, run: ${pc.bold('npm install -g termux-dev')}`));
             return false;
         }
     }
+    else {
+        // 2. Installed via git clone (Developer mode)
+        const steps = [
+            {
+                title: '📦 Pulling latest updates from GitHub repository...',
+                action: () => {
+                    execSync('git pull origin main', { cwd: projectRoot, stdio: 'pipe' });
+                }
+            },
+            {
+                title: '🔨 Building and compiling TypeScript sources...',
+                action: () => {
+                    execSync('npm install', { cwd: projectRoot, stdio: 'pipe' });
+                    execSync('npm run build', { cwd: projectRoot, stdio: 'pipe' });
+                }
+            },
+            {
+                title: '🔑 Ensuring binary execution permissions & linking...',
+                action: () => {
+                    try {
+                        execSync('npm link', { cwd: projectRoot, stdio: 'pipe' });
+                    }
+                    catch { }
+                }
+            }
+        ];
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            process.stdout.write(`  ${pc.cyan('⚡')} [${i + 1}/${steps.length}] ${pc.white(step.title)}\n`);
+            const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+            let fIdx = 0;
+            const interval = setInterval(() => {
+                process.stdout.write(`\r  ${pc.cyan(frames[fIdx++ % frames.length])} ${pc.dim(step.title)} `);
+            }, 80);
+            try {
+                await new Promise(resolve => setTimeout(resolve, 200));
+                step.action();
+                clearInterval(interval);
+                process.stdout.write(`\r  ${pc.green('✔')} ${pc.bold(pc.white(step.title))}\n`);
+            }
+            catch (err) {
+                clearInterval(interval);
+                process.stdout.write(`\r  ${pc.red('✖')} ${pc.red(step.title)} - ${err.message}\n`);
+                console.log(pc.red(`\nUpdate failed during step ${i + 1}: ${err.message}`));
+                console.log(pc.yellow(`\n💡 To update manually, run: ${pc.bold('npm install -g termux-dev')}`));
+                return false;
+            }
+        }
+    }
     console.log(pc.bold(pc.green(`\n✅ Successfully updated to v${latestVersion}! Restarting devx...\n`)));
     console.log(pc.bold(pc.cyan('──────────────────────────────────────────────────────\n')));
     await new Promise(r => setTimeout(r, 1000));
-    // Spawn new devx process and exit current
     try {
         const child = spawn(process.argv[0], process.argv.slice(1), {
             stdio: 'inherit',

package/dist/core/loop.js

@@ -88,7 +88,7 @@ export class Agent {
                                 yield { type: 'text_delta', delta: chunk.delta };
                             }
                             else if (chunk.type === 'tool_generating') {
-                                yield { type: 'tool_generating', name: chunk.name, bytes: chunk.bytes };
+                                yield { type: 'tool_generating', name: chunk.name, bytes: chunk.bytes, targetHint: chunk.targetHint };
                             }
                             else if (chunk.type === 'done') {
                                 response = chunk.response;

package/dist/providers/openai.js

@@ -261,10 +261,32 @@ export class OpenAIProvider {
                                     if (tc.function?.arguments)
                                         existing.argsStr += tc.function.arguments;
                                     toolMap.set(idx, existing);
+                                    // Extract live target hint (e.g. path or command being generated)
+                                    let targetHint = undefined;
+                                    const args = existing.argsStr;
+                                    if (args) {
+                                        const pathMatch = args.match(/"(?:path|filePath|targetFile)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+                                        if (pathMatch && pathMatch[1]) {
+                                            targetHint = pathMatch[1];
+                                        }
+                                        else {
+                                            const cmdMatch = args.match(/"(?:command|cmd)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+                                            if (cmdMatch && cmdMatch[1]) {
+                                                targetHint = cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + '...' : cmdMatch[1];
+                                            }
+                                            else {
+                                                const qMatch = args.match(/"(?:query|pattern)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/);
+                                                if (qMatch && qMatch[1]) {
+                                                    targetHint = `"${qMatch[1]}"`;
+                                                }
+                                            }
+                                        }
+                                    }
                                     yield {
                                         type: 'tool_generating',
                                         name: existing.name || 'tool',
-                                        bytes: existing.argsStr.length
+                                        bytes: existing.argsStr.length,
+                                        targetHint
                                     };
                                 }
                             }

package/dist/tools/index.js

@@ -8,11 +8,12 @@ import { installPackageTool } from './packages.js';
 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';
 export function getTools(planMode) {
-    const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool, todoListTool];
+    const baseTools = [readFileTool, listDirTool, searchTool, askQuestionsTool, webSearchTool, fetchUrlTool, saveMemoryTool, planReadyTool, todoListTool, servePreviewTool];
     if (planMode) {
         return baseTools;
     }
     return [...baseTools, writeFileTool, editFileTool, mkdirTool, bashTool, diagnoseCodeTool, installPackageTool];
 }
-export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady, todoListTool, currentTodoList, resetTodoList };
+export { webSearchTool, fetchUrlTool, diagnoseCodeTool, installPackageTool, saveMemoryTool, planReadyTool, lastPlanReady, resetPlanReady, todoListTool, currentTodoList, resetTodoList, servePreviewTool };

package/dist/tools/server.js

@@ -0,0 +1,46 @@
+import { startServer, stopServer, isServerRunning, getServerPort } from '../cli/server.js';
+export const servePreviewTool = {
+    name: 'serve_preview',
+    definition: {
+        name: 'serve_preview',
+        description: 'Start or stop the built-in local live web preview server to view HTML/web apps in the browser.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['start', 'stop', 'status'],
+                    description: 'Action to perform: start the server, stop it, or check status'
+                },
+                port: {
+                    type: 'number',
+                    description: 'Optional preferred port number (defaults to 3000)'
+                }
+            },
+            required: ['action']
+        }
+    },
+    validateArgs: (args) => {
+        if (!args || !args.action) {
+            throw new Error('action is required');
+        }
+    },
+    execute: async (args) => {
+        if (args.action === 'stop') {
+            const stopped = stopServer();
+            return stopped ? 'Web preview server stopped.' : 'No web preview server was running.';
+        }
+        if (args.action === 'status') {
+            const running = isServerRunning();
+            return running ? `Web server is running on port ${getServerPort()}.` : 'Web server is not running.';
+        }
+        const preferredPort = args.port || 3000;
+        try {
+            const { port, localUrl, networkUrl } = await startServer(preferredPort);
+            return `Web Server is now live!\n• Local URL: ${localUrl}\n• Network URL: ${networkUrl}\nOpened in browser automatically.`;
+        }
+        catch (err) {
+            throw new Error(`Failed to start web server: ${err.message}`);
+        }
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-dev",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",