termux-dev 1.9.5 → 1.9.7

package/README.md

@@ -67,6 +67,8 @@ The terminal interface is built around a framed prompt that carries the status i
   Built-in support for TypeScript (`tsc`), JavaScript (`node --check`), Python (`py_compile`), and Rust (`cargo check`). The AI automatically finds and fixes errors before finishing turns.
 - **Project Memory Bank (`.devx/memory.md`):**  
   Persistent project context across sessions with `/memory add <rule>`.
+- **Notifications when devx waits for you:**  
+  When the agent needs an approval or asks you a question (`◆ Clarify`) and the terminal is not in front, you get a notification (kitty's own protocol, `notify-send` on Linux, `osascript` on macOS; on Termux an Android notification with a short vibration). A finished task is announced too, with the start of the answer. The terminal has to report focus changes (most modern ones do); when devx cannot tell whether you are looking, it stays quiet instead of popping up in front of you.
 - **Past chats (`search_chats`):**  
   When you say "as we decided last time" or "in that chat about the parser", the agent can look through your saved chats by keywords (any language, other word forms match: page / pages) and read the one it needs, a few messages at a time. It is read-only and local, so it asks nothing; the chat that is open is not searched; tool output is not indexed; and what it reads is handed to the model as data, not as instructions. The agent does not use it on a normal task.
 - **18 Colour Themes on a Pure Black Background (`#0a0a0c`):**  
@@ -92,6 +94,33 @@ The terminal interface is built around a framed prompt that carries the status i
 - **Node.js**: `v20.0.0` or higher
 - **npm**, **pnpm**, or **yarn**
 
+### Installing Node.js and npm
+
+devx needs Node.js 20 or newer (npm comes with it). Pick your system:
+
+```bash
+# Windows (PowerShell)
+winget install OpenJS.NodeJS.LTS
+
+# macOS (Homebrew)
+brew install node
+
+# Ubuntu / Debian (NodeSource: the version in the distribution's own repository is often older than 20)
+curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Fedora
+sudo dnf install -y nodejs
+
+# Arch Linux
+sudo pacman -S nodejs npm
+
+# Android (Termux)
+pkg update && pkg install -y nodejs-lts
+```
+
+Reopen the terminal and check: `node -v` (should be `v20` or higher) and `npm -v`. Any system: the installer at [nodejs.org](https://nodejs.org/en/download) or [nvm](https://github.com/nvm-sh/nvm).
+
 ### Fast Global Install (Recommended)
 
 ```bash

package/assets/banner.svg

@@ -16,7 +16,7 @@
     <rect width="1000" height="280" fill="url(#bg)"/>
   </g>
   <rect x="1.5" y="1.5" width="997" height="277" rx="18" fill="none" stroke="#23252c" stroke-width="1.5"/>
-  <text x="500.0" y="70" text-anchor="middle" font-family="'Inter',system-ui,-apple-system,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif" font-size="13" font-weight="600" letter-spacing="5" fill="#7d8896">THE TERMINAL-NATIVE AI CODING AGENT<tspan dx="16" fill="#2fe3ee" font-weight="700">v1.9.5</tspan></text>
+  <text x="500.0" y="70" text-anchor="middle" font-family="'Inter',system-ui,-apple-system,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif" font-size="13" font-weight="600" letter-spacing="5" fill="#7d8896">THE TERMINAL-NATIVE AI CODING AGENT<tspan dx="16" fill="#2fe3ee" font-weight="700">v1.9.7</tspan></text>
   <g>
     <text x="500.0" y="178" text-anchor="middle" font-family="'JetBrains Mono','Fira Code','SF Mono',ui-monospace,Menlo,Consolas,'DejaVu Sans Mono',monospace" font-size="112" font-weight="800" letter-spacing="14" fill="#2fe3ee">DEVX</text>
   </g>

package/assets/preview.svg

@@ -32,7 +32,7 @@
   <rect x="595.2" y="574.0" width="243.2" height="19" fill="#000000"/>
   <text x="44.8" y="62.0" class="t" fill="#b794f6">▌</text>
   <text x="61.6" y="62.0" class="t b" fill="#f4f7fb">devx</text>
-  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.5</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.7</text>
   <text x="61.6" y="106.0" class="t" fill="#5f6b7a">model</text>
   <text x="128.8" y="106.0" class="t" fill="#e5eaf1">deepseek-v4.1-flash · think high</text>
   <text x="406.0" y="106.0" class="t" fill="#5f6b7a">/model</text>

package/dist/cli/index.js

@@ -17,6 +17,7 @@ import { globalSnapshotManager } from '../core/snapshot.js';
 import { MemoryManager, memoryForPrompt } from '../core/memory.js';
 import { startServer, stopServer, displayServerBanner } from './server.js';
 import { notifyDevice, acquireWakeLock, isTermux, notificationBody, sendDesktopNotification } from '../core/notify.js';
+import { isTerminalFocused, setFocusTracking, setTerminalFocused } from '../core/attention.js';
 import { copyToClipboard } from './clipboard-write.js';
 import { REWIND_CURRENT, messageDraft, rewindItems, userEntries } from './rewind.js';
 import { runPicker } from './picker.js';
@@ -933,9 +934,14 @@ export async function main() {
     const sessionManager = new SessionManager(config.model, planMode);
     drawLogo(config.banner || 'full');
     await runStartupUpdateCheck(config, { save: saveConfig });
-    await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
-    // After the servers are up: the prompt says how the agent reaches the tools it has to load.
     history.addMessage({ role: 'system', content: await buildSystemPrompt(planMode) });
+    // The servers start while the prompt is already there (starting them takes seconds: `npx` and the
+    // network). What needs them waits for `mcpReady`: the first request, and /mcp. When they are up the
+    // prompt is written again, so that it says how the agent reaches the tools that wait to be loaded.
+    const mcpReady = MCPManager.getInstance()
+        .init(undefined, config.projectMcpTrusted === true)
+        .then(async () => { history.updateSystemPrompt(await buildSystemPrompt(planMode)); })
+        .catch(() => undefined);
     // Ask a custom endpoint what the current model can do (cached for a day; never blocks the prompt).
     void refreshEndpoint(config).catch(() => null);
     const sessionCost = new CostLedger();
@@ -988,7 +994,6 @@ export async function main() {
     // The name of the chat: in the title of the terminal window (`◈ Short title`) and in the list of sessions.
     let windowTitle = '';
     let titleAttempts = 0;
-    let terminalFocused = true; // updated by the terminal's focus reports while a task runs
     const setWindowTitle = (title) => {
         windowTitle = title;
         if (process.stdout.isTTY)
@@ -1858,6 +1863,7 @@ export async function main() {
                 continue;
             }
             if (cmd === '/mcp') {
+                await mcpReady;
                 const sub = (parts[1] || '').toLowerCase();
                 if (sub === 'reload' || sub === 'restart' || sub === 'r') {
                     const s = new UiSpinner();
@@ -2109,6 +2115,8 @@ export async function main() {
         });
         // The format of the gateway is learned once (cached); the first request waits for it.
         await refreshFormats(config).catch(() => null);
+        // The MCP servers may still be starting (see mcpReady): the request goes out with their tools.
+        await mcpReady;
         const provider = createProvider(config);
         const tools = getToolSource(planMode);
         const guard = new CLIConsoleGuard(config.autoApprove, [...(config.bashAllowlist || [])], {
@@ -2424,7 +2432,7 @@ export async function main() {
             let text = (Buffer.isBuffer(data) ? data : Buffer.from(String(data))).toString('utf8');
             // Focus reports: ESC [ I (got the focus) and ESC [ O (lost it). They are not keys.
             if (text.includes('\x1b[I') || text.includes('\x1b[O')) {
-                terminalFocused = text.lastIndexOf('\x1b[I') > text.lastIndexOf('\x1b[O');
+                setTerminalFocused(text.lastIndexOf('\x1b[I') > text.lastIndexOf('\x1b[O'));
                 text = text.replace(/\x1b\[[IO]/g, '');
                 if (!text)
                     return;
@@ -2468,6 +2476,7 @@ export async function main() {
                     process.stdout.on('resize', onResize);
                     uiSpinner?.mute(true);
                     process.stdout.write('\x1b[?1004h'); // the terminal tells when it loses or gets the focus
+                    setFocusTracking(true); // approval cards and questions notify when it is not in front
                 }
             }
             catch { }
@@ -2843,7 +2852,7 @@ export async function main() {
                     if (shouldNotify)
                         notifyDevice(heading, preview || `Task completed in ${secs}s!`);
                 }
-                else if (!terminalFocused) {
+                else if (!isTerminalFocused()) {
                     // The terminal is not in front: a notification with the start of the answer.
                     if (sendDesktopNotification(heading, preview || `Task completed in ${secs}s`) === 'none' && shouldNotify)
                         notifyDevice(heading, preview || `Task completed in ${secs}s!`);
@@ -2932,6 +2941,7 @@ export async function main() {
             const unsent = composer.stop();
             if (process.stdout.isTTY)
                 process.stdout.write('\x1b[?1004l');
+            setFocusTracking(false);
             releasePauseHook();
             process.stdout.removeListener('resize', onResize);
             if (!currentDraft && (unsent.draft || unsent.queued.length > 0)) {

package/dist/cli/update-screen.js

@@ -4,7 +4,7 @@ import { runPicker } from './picker.js';
 import { palette, renderNotice } from './ui.js';
 import { displayWidth, truncateWidth } from './width.js';
 import { getLanguage, t } from '../core/i18n.js';
-import { UpdateError, buildUpdateSteps, checkForUpdates, detectInstallMethod, getCurrentVersion, restartDevx, runUpdateSteps, } from './updater.js';
+import { UpdateError, buildUpdateSteps, checkForUpdates, checkForUpdatesRemembered, detectInstallMethod, readCachedCheck, getCurrentVersion, restartDevx, runUpdateSteps, } from './updater.js';
 /**
  * The update screens, in the style of the rest of devx:
  *
@@ -344,7 +344,9 @@ export async function runStartupUpdateCheck(config, deps = {}) {
     if (!out.isTTY)
         return;
     const current = await getCurrentVersion();
-    const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(6000));
+    // A recent answer is used as it is: no network, no "checking" line, no wait before the prompt.
+    const cached = deps.check ? undefined : await readCachedCheck();
+    const result = cached ?? await withCheckingLine(out, current, () => (deps.check ?? checkForUpdatesRemembered)(6000));
     if (result.updateAvailable) {
         if (config.skippedUpdate === result.latestVersion)
             return;
@@ -359,6 +361,8 @@ export async function runStartupUpdateCheck(config, deps = {}) {
     }
     if (result.error)
         return; // offline at start-up is not worth a word
+    if (cached)
+        return; // up to date, as the last check said: nothing to show
     // Up to date: a short line that goes away by itself.
     out.write(`  ${palette.ok('✓')} ${palette.muted(t('update.upToDate', { version: result.currentVersion }))}\n`);
     await sleep(deps.tickMs !== undefined ? 0 : 450);

package/dist/cli/updater.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import os from 'os';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 const GITHUB_REPO_URL = 'https://github.com/apvcode/Termux-Dev';
@@ -40,6 +41,12 @@ export async function checkForUpdates(timeoutMs = 10000) {
     // mobile connection a stalled second request used to block devx at startup forever.
     const signal = AbortSignal.timeout(timeoutMs);
     try {
+        // The release is asked at the same time as the package.json, not after it: the check takes as long
+        // as the slower of the two, not both. A failure of the release request is not an error of the check.
+        const releaseRequest = fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
+            signal,
+            headers: { 'User-Agent': 'devx-updater' }
+        }).catch(() => null);
         // 1. Try fetching latest package.json with cache-busting timestamp
         const cacheBusterUrl = `${REMOTE_PKG_URL}?t=${Date.now()}`;
         const res = await fetch(cacheBusterUrl, {
@@ -59,11 +66,8 @@ export async function checkForUpdates(timeoutMs = 10000) {
         }
         // 2. Also check latest GitHub release tag
         try {
-            const relRes = await fetch(`${REMOTE_RELEASE_URL}?t=${Date.now()}`, {
-                signal,
-                headers: { 'User-Agent': 'devx-updater' }
-            });
-            if (relRes.ok) {
+            const relRes = await releaseRequest;
+            if (relRes?.ok) {
                 const relData = await relRes.json();
                 const relTag = (relData.tag_name || relData.name || '').replace(/^v/, '').trim();
                 if (relTag && (!latestVersion || isNewerVersion(relTag, latestVersion))) {
@@ -99,6 +103,56 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
 }
+// ───────────────────────── remembering the check ─────────────────────────
+/** An answer is good for this long; after it devx asks again. */
+const CHECK_FRESH_MS = 6 * 60 * 60 * 1000;
+/** A failed check (offline, a stalled connection) is not repeated at every start: that would stall every start. */
+const CHECK_FAILED_MS = 30 * 60 * 1000;
+const checkFile = () => path.join(os.homedir(), '.devx', 'update-check.json');
+/** The last check, when it is recent enough to be trusted at start-up; undefined when devx has to ask again. */
+export async function readCachedCheck(now = Date.now()) {
+    try {
+        const saved = JSON.parse(await fs.readFile(checkFile(), 'utf8'));
+        const age = now - Number(saved.checkedAt);
+        // A clock that went backwards makes the age negative: such an answer is not trusted.
+        if (!Number.isFinite(age) || age < 0)
+            return undefined;
+        const currentVersion = await getCurrentVersion();
+        if (saved.error) {
+            return age < CHECK_FAILED_MS ? { updateAvailable: false, currentVersion, latestVersion: currentVersion, error: saved.error } : undefined;
+        }
+        if (age >= CHECK_FRESH_MS || !saved.latestVersion)
+            return undefined;
+        // Judged against the version that runs now: after an update the old answer no longer says "update".
+        return {
+            updateAvailable: isNewerVersion(saved.latestVersion, currentVersion),
+            currentVersion,
+            latestVersion: saved.latestVersion,
+            releaseNotes: saved.releaseNotes || undefined,
+            publishedAt: saved.publishedAt || undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Keeps the answer of a check for the next start-ups. Never throws: this is only a shortcut. */
+export async function rememberCheck(result, now = Date.now()) {
+    try {
+        const saved = result.error
+            ? { checkedAt: now, error: result.error }
+            : { checkedAt: now, latestVersion: result.latestVersion, releaseNotes: result.releaseNotes, publishedAt: result.publishedAt };
+        await fs.mkdir(path.dirname(checkFile()), { recursive: true, mode: 0o700 });
+        await fs.writeFile(checkFile(), JSON.stringify(saved));
+    }
+    catch { }
+}
+/** `checkForUpdates`, and the answer is kept for the next start-ups (the start-up check reads it, see readCachedCheck). */
+export async function checkForUpdatesRemembered(timeoutMs = 10000) {
+    const result = await checkForUpdates(timeoutMs);
+    await rememberCheck(result);
+    return result;
+}
 /** How this devx was installed: from the npm package, or from a git clone (a developer's copy). */
 export async function detectInstallMethod() {
     const here = fileURLToPath(import.meta.url);

package/dist/core/attention.js

@@ -0,0 +1,63 @@
+import { isTermux, notificationBody, notifyDevice, sendDesktopNotification } from './notify.js';
+/**
+ * "devx is waiting for you": a notification when the agent needs an answer (an approval card, a
+ * question) and the person is not looking at the terminal. A finished task is announced elsewhere
+ * (the end of a turn); this is for the moments when the work is stopped until someone answers.
+ */
+let tracking = false;
+let focused = true;
+/**
+ * The terminal reports when it loses and gets the focus (while a task runs). Without those reports
+ * devx cannot tell whether anybody is looking, and a notification that pops up in front of someone who is
+ * typing in the terminal is worse than none, so nothing is sent then.
+ */
+export function setFocusTracking(on) {
+    tracking = on;
+    // A task starts because the person just pressed Enter here.
+    if (on)
+        focused = true;
+}
+export function setTerminalFocused(value) {
+    focused = value;
+}
+export function isTerminalFocused() {
+    return focused;
+}
+/**
+ * Tells the person that devx waits for them. Returns whether something was sent. Never throws.
+ * On Termux (Android) a notification always goes out: the person is most likely in another app, and
+ * the phone cannot tell devx. On a desktop it goes out only when the terminal is not in front.
+ */
+export function notifyAttention(title, body, deps = {}) {
+    try {
+        const text = notificationBody(body, 140) || title;
+        if (deps.termux ?? isTermux()) {
+            (deps.device ?? notifyDevice)(title, text);
+            return true;
+        }
+        if (!tracking || focused)
+            return false;
+        const via = (deps.desktop ?? sendDesktopNotification)(title, text);
+        // No desktop notification service: the terminal bell at least marks the window as asking for attention.
+        if (via === 'none')
+            (deps.device ?? notifyDevice)(title, text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** What an approval card asks, in a line for a notification: `bash: npm test`. */
+export function approvalNotice(title, lines, danger) {
+    const first = (lines.find((l) => l.trim()) ?? '').trim();
+    return {
+        title: danger ? 'devx · dangerous action, approval needed' : 'devx · approval needed',
+        body: first ? `${title}: ${first}` : title,
+    };
+}
+/** The question the agent asks, for a notification (and how many more follow). */
+export function questionNotice(questions) {
+    const first = String(questions[0]?.question ?? '').trim();
+    const more = questions.length > 1 ? ` (+${questions.length - 1} more)` : '';
+    return { title: 'devx · question for you', body: `${first || 'The agent has a question'}${more}` };
+}

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.9.5';
+export const DEVX_VERSION = '1.9.7';

package/dist/permissions/guard.js

@@ -1,3 +1,4 @@
+import { approvalNotice, notifyAttention } from '../core/attention.js';
 import pc from 'picocolors';
 import path from 'path';
 import os from 'os';
@@ -377,6 +378,9 @@ export class CLIConsoleGuard {
             return false;
         }
         const request = buildPermissionRequest(toolName, args);
+        // The work stops here until somebody answers: if the terminal is not in front, a notification says so.
+        const notice = approvalNotice(request.title, request.lines, request.danger);
+        notifyAttention(notice.title, notice.body);
         // Only requests that are safe to remember offer "Session" and "Always".
         const remember = request.danger ? null : rememberKeyFor(toolName, args);
         const offer = remember ? { session: true, always: true } : {};

package/dist/tools/questions.js

@@ -3,6 +3,7 @@ import { runPicker } from '../cli/picker.js';
 import { palette } from '../cli/ui.js';
 import { wrapWords } from '../cli/width.js';
 import { t } from '../core/i18n.js';
+import { notifyAttention, questionNotice } from '../core/attention.js';
 export const askQuestionsTool = {
     name: 'ask_questions',
     definition: {
@@ -45,6 +46,9 @@ export const askQuestionsTool = {
         if (!args.questions || !Array.isArray(args.questions) || args.questions.length === 0) {
             return 'No questions provided.';
         }
+        // The agent waits for the answer: if the terminal is not in front, a notification says so.
+        const notice = questionNotice(args.questions);
+        notifyAttention(notice.title, notice.body);
         const results = [];
         const total = args.questions.length;
         const cols = process.stdout.columns || 80;

package/package.json

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