termux-dev 1.1.1 → 1.2.0

package/dist/cli/prompt.js

@@ -1,11 +1,14 @@
 import pc from 'picocolors';
 import { scanProjectFiles } from './files.js';
 import { saveClipboardImage, processPastedFilePath } from './clipboard.js';
+import { getCurrentTheme, listThemes } from './theme.js';
 export const SLASH_COMMANDS = [
     { cmd: '/new', desc: 'Start a new clean chat session' },
     { cmd: '/resume', desc: 'Resume a previous chat session' },
     { cmd: '/session', desc: 'Show active session ID, stats, and info' },
     { cmd: '/session del', desc: 'Select and delete saved sessions' },
+    { 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' },
     { cmd: '/update', desc: 'Check and install updates from GitHub' },
     { cmd: '/model', desc: 'Switch model for current provider' },
@@ -47,8 +50,9 @@ export function askPrompt(opts = {}) {
         const pastes = [];
         const imageAttachments = [];
         const usedImageNames = new Set();
+        const theme = getCurrentTheme();
         // Header printed once
-        console.log(pc.cyan('◆') + '  ' + pc.bold(msg));
+        console.log(theme.colorFn('◆') + '  ' + pc.bold(msg));
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(true);
         }
@@ -56,6 +60,33 @@ export function askPrompt(opts = {}) {
             process.stdout.write('\x1b[?2004h');
         }
         function getDropdownItems() {
+            if (input.startsWith('/theme ') || input.startsWith('/themes ') || input === '/theme') {
+                const afterCmd = input.replace(/^\/(?:theme|themes)\s*/i, '').trim().toLowerCase();
+                const themes = listThemes();
+                const matched = themes.filter(t => !afterCmd ||
+                    t.id.toLowerCase().startsWith(afterCmd) ||
+                    t.name.toLowerCase().includes(afterCmd));
+                const list = [];
+                if (!afterCmd || '/theme'.startsWith(input.trim().toLowerCase())) {
+                    list.push({
+                        label: '/theme',
+                        desc: 'Interactive UI theme picker menu',
+                        replacement: '/theme',
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    });
+                }
+                for (const t of matched) {
+                    list.push({
+                        label: `/theme ${t.id}`,
+                        desc: `${t.emoji} ${t.name} (${t.desc})`,
+                        replacement: `/theme ${t.id}`,
+                        replaceStart: 0,
+                        replaceLen: input.length
+                    });
+                }
+                return list;
+            }
             if (input.startsWith('/')) {
                 const q = input.trim().toLowerCase();
                 const filtered = SLASH_COMMANDS.filter(c => c.cmd.toLowerCase().startsWith(q) || q === '/');
@@ -146,9 +177,9 @@ export function askPrompt(opts = {}) {
                     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 ? pc.cyan('›') : ' '} ${isSelected ? pc.bold(pc.cyan(labelStr)) : pc.white(labelStr)} ${pc.gray(descStr)} `;
+                    let row = ` ${isSelected ? theme.colorFn('›') : ' '} ${isSelected ? theme.boldFn(labelStr) : pc.white(labelStr)} ${pc.gray(descStr)} `;
                     if (isSelected) {
-                        row = pc.bgCyan(pc.black(` › ${labelStr} ${descStr} `));
+                        row = theme.badgeFn(`› ${labelStr} ${descStr}`);
                     }
                     dropdownLines.push(pc.dim('│') + '  ' + pc.dim('│') + row + pc.dim('│'));
                 }

package/dist/cli/server.js

@@ -4,12 +4,17 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import { spawn } from 'child_process';
+import pc from 'picocolors';
+import qrcode from 'qrcode-terminal';
+import { getTheme } from './theme.js';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.htm': 'text/html; charset=utf-8',
     '.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 +27,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 +52,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.2.0 &bull; Terminal-Native AI Assistant</div>
+  </div>
+</body>
+</html>`;
+}
 export async function startServer(preferredPort = 3000) {
     if (activeServer) {
         stopServer();
@@ -59,75 +152,122 @@ 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);
-                        return;
-                    }
-                    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-                    res.end(`404 Not Found: ${reqPath}`);
+                // Security check: block dotfiles, hidden directories (.env, .git, etc.) and node_modules
+                const segments = reqPath.split(/[\/\\]/).filter(Boolean);
+                if (segments.some(seg => (seg.startsWith('.') && seg !== '.') || seg === 'node_modules')) {
+                    res.writeHead(403, { 'Content-Type': 'text/plain' });
+                    res.end('Forbidden');
                     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);
+                // 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(403, { 'Content-Type': 'text/plain' });
-                    res.end('Directory listing disabled');
+                }
+                // 2. Fallback check for missing .html extension
+                if (!fsSync.existsSync(targetPath)) {
+                    const withHtml = `${targetPath}.html`;
+                    if (fsSync.existsSync(withHtml)) {
+                        targetPath = withHtml;
+                    }
+                }
+                // 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;
                 }
-                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);
+                // 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;
+                }
+                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}`);
             }
         });
+        let retryCount = 0;
         server.on('error', (err) => {
             if (err.code === 'EADDRINUSE') {
-                server.listen(activePort + 1);
+                retryCount++;
+                if (retryCount > 20) {
+                    reject(new Error(`Could not find an open port after 20 attempts (started at ${preferredPort})`));
+                    return;
+                }
                 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.on('error', () => { });
+                    opener.unref();
                 }
                 catch { }
             }
@@ -135,3 +275,41 @@ export async function startServer(preferredPort = 3000) {
         });
     });
 }
+export function getQrCodeString(text) {
+    return new Promise((resolve) => {
+        try {
+            qrcode.generate(text, { small: true }, (qr) => {
+                resolve(qr);
+            });
+        }
+        catch {
+            resolve('');
+        }
+    });
+}
+export async function displayServerBanner(localUrl, networkUrl) {
+    const th = getTheme();
+    const qr = await getQrCodeString(networkUrl);
+    const cols = Math.min(process.stdout.columns || 80, 80);
+    const cardWidth = Math.max(36, Math.min(cols - 4, 66));
+    const innerWidth = cardWidth - 2;
+    const title = ' 🌐 Live Web Preview ';
+    const topFill = Math.max(2, cardWidth - 3 - title.length);
+    console.log('\n' + th.colorFn('┌─') + pc.bold(title) + th.colorFn('─'.repeat(topFill) + '┐'));
+    const printRow = (content) => {
+        const visibleLength = content.replace(/\u001b\[[0-9;]*m/g, '').length;
+        const padding = Math.max(0, innerWidth - visibleLength);
+        console.log(th.colorFn('│') + content + ' '.repeat(padding) + th.colorFn('│'));
+    };
+    printRow(`  ${pc.bold('Local:')}   ${pc.cyan(localUrl)}`);
+    printRow(`  ${pc.bold('Network:')} ${pc.green(networkUrl)}`);
+    printRow(' ');
+    printRow(`  ${pc.bold('📱 Mobile QR:')}`);
+    if (qr) {
+        const qrLines = qr.trim().split('\n');
+        for (const ql of qrLines) {
+            printRow(`  ${ql}`);
+        }
+    }
+    console.log(th.colorFn('└' + '─'.repeat(innerWidth) + '┘\n'));
+}

package/dist/cli/theme.js

@@ -0,0 +1,140 @@
+import pc from 'picocolors';
+export const THEMES = {
+    cyan: {
+        id: 'cyan',
+        name: 'Cyan Cyber',
+        desc: 'Electric neon cyan & obsidian (Default)',
+        emoji: '⚡',
+        colorFn: (s) => pc.cyan(s),
+        boldFn: (s) => pc.bold(pc.cyan(s)),
+        accentFn: (s) => pc.blue(s),
+        badgeFn: (s) => pc.bgCyan(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgCyan(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlue(pc.white(s)),
+        hex: '#00f2fe'
+    },
+    purple: {
+        id: 'purple',
+        name: 'Synthwave Purple',
+        desc: 'Vibrant neon magenta & violet retro',
+        emoji: '🟣',
+        colorFn: (s) => pc.magenta(s),
+        boldFn: (s) => pc.bold(pc.magenta(s)),
+        accentFn: (s) => pc.blue(s),
+        badgeFn: (s) => pc.bgMagenta(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgMagenta(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlue(pc.white(s)),
+        hex: '#d946ef'
+    },
+    matrix: {
+        id: 'matrix',
+        name: 'Matrix Hacker',
+        desc: 'Classic bright phosphor green terminal',
+        emoji: '🟢',
+        colorFn: (s) => pc.green(s),
+        boldFn: (s) => pc.bold(pc.green(s)),
+        accentFn: (s) => pc.cyan(s),
+        badgeFn: (s) => pc.bgGreen(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgGreen(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgRed(pc.white(s)),
+        hex: '#22c55e'
+    },
+    amber: {
+        id: 'amber',
+        name: 'Solar Amber',
+        desc: 'Warm vintage CRT amber gold',
+        emoji: '🟡',
+        colorFn: (s) => pc.yellow(s),
+        boldFn: (s) => pc.bold(pc.yellow(s)),
+        accentFn: (s) => pc.red(s),
+        badgeFn: (s) => pc.bgYellow(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgYellow(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgRed(pc.white(s)),
+        hex: '#f59e0b'
+    },
+    crimson: {
+        id: 'crimson',
+        name: 'Ruby Crimson',
+        desc: 'Aggressive cyberpunk scarlet red',
+        emoji: '🔴',
+        colorFn: (s) => pc.red(s),
+        boldFn: (s) => pc.bold(pc.red(s)),
+        accentFn: (s) => pc.magenta(s),
+        badgeFn: (s) => pc.bgRed(pc.white(` ${s} `)),
+        diffAddBg: (s) => pc.bgRed(pc.white(s)),
+        diffRemoveBg: (s) => pc.bgMagenta(pc.white(s)),
+        hex: '#ef4444'
+    },
+    monochrome: {
+        id: 'monochrome',
+        name: 'Pure Monochrome',
+        desc: 'Crisp minimal pure white & gray',
+        emoji: '⚪',
+        colorFn: (s) => pc.white(s),
+        boldFn: (s) => pc.bold(pc.white(s)),
+        accentFn: (s) => pc.dim(s),
+        badgeFn: (s) => pc.bgWhite(pc.black(` ${s} `)),
+        diffAddBg: (s) => pc.bgWhite(pc.black(s)),
+        diffRemoveBg: (s) => pc.bgBlack(pc.white(s)),
+        hex: '#ffffff'
+    }
+};
+const THEME_ALIASES = {
+    '1': 'cyan',
+    '2': 'purple',
+    '3': 'matrix',
+    '4': 'amber',
+    '5': 'crimson',
+    '6': 'monochrome',
+    'blue': 'cyan',
+    'neon': 'cyan',
+    'cyber': 'cyan',
+    'magenta': 'purple',
+    'violet': 'purple',
+    'pink': 'purple',
+    'synthwave': 'purple',
+    'green': 'matrix',
+    'hacker': 'matrix',
+    'terminal': 'matrix',
+    'yellow': 'amber',
+    'gold': 'amber',
+    'solar': 'amber',
+    'orange': 'amber',
+    'red': 'crimson',
+    'ruby': 'crimson',
+    'cyberpunk': 'crimson',
+    'white': 'monochrome',
+    'mono': 'monochrome',
+    'gray': 'monochrome',
+    'grey': 'monochrome'
+};
+let activeThemeId = 'cyan';
+export function getTheme(themeId) {
+    const id = (themeId || activeThemeId).toLowerCase().trim();
+    return THEMES[id] || (THEME_ALIASES[id] && THEMES[THEME_ALIASES[id]]) || THEMES.cyan;
+}
+export function findTheme(query) {
+    const q = (query || '').toLowerCase().trim();
+    if (!q)
+        return null;
+    if (THEMES[q])
+        return THEMES[q];
+    if (THEME_ALIASES[q] && THEMES[THEME_ALIASES[q]])
+        return THEMES[THEME_ALIASES[q]];
+    const all = listThemes();
+    const found = all.find(t => t.id.toLowerCase() === q ||
+        t.id.toLowerCase().startsWith(q) ||
+        t.name.toLowerCase().includes(q));
+    return found || null;
+}
+export function setActiveTheme(themeId) {
+    const theme = getTheme(themeId);
+    activeThemeId = theme.id;
+    return theme;
+}
+export function getCurrentTheme() {
+    return THEMES[activeThemeId] || THEMES.cyan;
+}
+export function listThemes() {
+    return Object.values(THEMES);
+}

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/core/notify.js

@@ -0,0 +1,40 @@
+import { spawn } from 'child_process';
+export function isTermux() {
+    return !!process.env.PREFIX?.includes('com.termux');
+}
+/**
+ * Sends a notification and haptic vibration to the device.
+ * On Termux: uses termux-notification and termux-vibrate via termux-api.
+ * On Desktop: emits terminal bell \u0007.
+ */
+export function notifyDevice(title, message, options = { vibrate: true, sound: true }) {
+    if (isTermux()) {
+        try {
+            // 1. Android notification via Termux API
+            const notif = spawn('termux-notification', [
+                '--title', title,
+                '--content', message,
+                '--id', 'devx_task_notif',
+                '--priority', 'high'
+            ], { stdio: 'ignore', detached: true });
+            notif.on('error', () => { });
+            notif.unref();
+            // 2. Haptic vibration (150ms)
+            if (options.vibrate !== false) {
+                const vib = spawn('termux-vibrate', ['-d', '150'], { stdio: 'ignore', detached: true });
+                vib.on('error', () => { });
+                vib.unref();
+            }
+        }
+        catch { }
+    }
+    else {
+        // Desktop terminal bell
+        if (options.sound !== false) {
+            try {
+                process.stdout.write('\u0007');
+            }
+            catch { }
+        }
+    }
+}

package/dist/core/snapshot.js

@@ -36,12 +36,8 @@ export class SnapshotManager {
                 });
             }
         }
-        catch {
-            this.currentTurn.files.set(resolved, {
-                filePath: resolved,
-                existed: false,
-                content: null
-            });
+        catch (err) {
+            throw new Error(`Cannot safely snapshot file ${resolved} before edit: ${err.message}`);
         }
     }
     finishTurn() {

package/dist/prompts/builder.js

@@ -41,8 +41,9 @@ export async function buildSystemPrompt(planMode) {
         prompt += `- Whenever you modify or create files, use the 'diagnose_code' tool to check for any syntax or type errors.\n`;
         prompt += `- If any error is found, automatically fix it with 'edit_file' until all diagnostics pass cleanly.\n`;
         prompt += `- If you need dependencies, use 'install_package' to install them cleanly.\n`;
+        prompt += `- Whenever you create or modify web applications, sites, HTML/CSS/JS, canvas games, or React/Vite frontend apps, automatically call the 'serve_preview' tool with action='start' to start the local preview server and display the mobile QR-code for the user!\n`;
         prompt += `- Use 'save_memory' to remember important architectural decisions, user preferences, or project rules.\n`;
-        prompt += `Always explain your actions briefly before using tools.\n`;
+        prompt += `- Always explain your actions briefly before using tools.\n`;
     }
     // Load Project Memory Bank
     try {

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
                                     };
                                 }
                             }