termux-dev 1.9.7 → 1.9.9

package/README.md

@@ -22,6 +22,10 @@ Built specifically for **Android Termux**, **Windows**, **macOS**, and **Linux**
 
 <br/><br/>
 
+<a href="assets/demo.mp4"><img src="assets/demo.gif" alt="devx demo: plan, build, test, preview with a QR code" width="880" /></a>
+
+<br/>
+
 <img src="assets/preview.svg" alt="The devx terminal interface" width="880" />
 
 </div>
@@ -235,7 +239,7 @@ Type `/` in the prompt to open the autocomplete command palette:
 - **`@filename`** — Fast fuzzy file autocomplete and full file embedding.
 - **`Backspace`** — Atomically deletes entire badges `[Pasted text #1]` and `[1.png 203kb]` in one press.
 - **`Ctrl+Backspace`** / **`Alt+Backspace`** — Erase the text word by word (also while the agent works).
-- **`Ctrl+Enter`** — While typing: start a new line (a new paragraph) instead of sending. `Alt+Enter` and `Shift+Enter` do the same where the terminal reports them; on a terminal that cannot tell them from `Enter` (a phone keyboard, for one) type `\` before `Enter`.
+- **`Ctrl+Enter`** — While typing: start a new line (a new paragraph) instead of sending. `Alt+Enter` and `Shift+Enter` do the same where the terminal reports them; on a terminal that cannot tell them from `Enter` (a phone keyboard, for one) type `\` before `Enter`. devx asks the terminal to tell them apart only where that is known to work (kitty, Ghostty, WezTerm, iTerm2, foot, Alacritty); Termux and other terminals that read that request as a cursor or style code never get it. `DEVX_EXTENDED_KEYS=1` (or `0`) forces it on (or off).
 - **`Ctrl+P`** / **`Ctrl+O`** — Unfold or fold the reasoning of the model (`Ctrl+P`) and the commands with their output (`Ctrl+O`) in the whole chat, also what is already above. Both are folded by default; works while the agent works and at the prompt.
 - **`Esc`** — Stop the current answer and whatever it started (a running command); what you typed waits in the next prompt. Esc also closes every list and card.
 - **`Ctrl+C`** — Stop current generation immediately or exit.

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.7</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.9</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.7</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.9</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

@@ -69,7 +69,7 @@ import { modelAcceptsImages } from '../core/vision.js';
 import { contextBreakdown } from '../core/context-stats.js';
 import { runUsagePanel } from './usage-panel.js';
 import { TurnComposer } from './typeahead.js';
-import { EXTENDED_KEYS_OFF, normalizeKey, splitKeys } from './keys.js';
+import { extendedKeysOff, normalizeKey, splitKeys } from './keys.js';
 import { LANGUAGES, getLanguage, setLanguage, t } from '../core/i18n.js';
 import { anthropicOnlyModels, formatFromBaseUrl, refreshFormats } from '../core/formats.js';
 import { providerFormat } from '../providers/index.js';
@@ -594,7 +594,7 @@ process.on('exit', () => {
         process.stdin.setRawMode(false);
     }
     if (process.stdout.isTTY)
-        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h');
+        process.stdout.write(extendedKeysOff() + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h');
     resetTerminalTheme();
 });
 process.on('SIGINT', () => {
@@ -606,11 +606,18 @@ process.on('SIGINT', () => {
             process.stdin.setRawMode(false);
             process.stdin.pause();
         }
-        process.stdout.write(EXTENDED_KEYS_OFF + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h'); // restore cursor
+        process.stdout.write(extendedKeysOff() + '\x1B[?1004l' + RESTORE_TERMINAL_TITLE + '\x1B[?25h'); // restore cursor
         resetTerminalTheme();
         process.exit(0);
     }
 });
+/**
+ * The new version has been started (it owns the terminal now) and this process ends when it ends.
+ * Nothing else may run here: a second prompt on the same terminal takes keys from the first.
+ */
+function waitForRestartedDevx() {
+    return new Promise(() => { });
+}
 function clearTerminalScreen() {
     if (process.stdout.isTTY) {
         // \x1b[2J: clear screen, \x1b[3J: clear scrollback buffer (crucial for Termux/xterm), \x1b[H: cursor to home
@@ -933,7 +940,8 @@ export async function main() {
     MemoryManager.enabled = config.enableMemory !== false;
     const sessionManager = new SessionManager(config.model, planMode);
     drawLogo(config.banner || 'full');
-    await runStartupUpdateCheck(config, { save: saveConfig });
+    if ((await runStartupUpdateCheck(config, { save: saveConfig })) === 'updated')
+        await waitForRestartedDevx();
     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
@@ -1281,7 +1289,8 @@ export async function main() {
                 continue;
             }
             if (cmd === '/update') {
-                await runManualUpdate();
+                if ((await runManualUpdate()) === 'updated')
+                    await waitForRestartedDevx();
                 continue;
             }
             if (cmd === '/help') {

package/dist/cli/keys.js

@@ -28,11 +28,50 @@ export function isNewlineKey(key) {
  * Asks the terminal to tell Ctrl+Enter and Shift+Enter apart from Enter (a plain terminal sends
  * the same byte for all of them). Two protocols are requested, a terminal answers the one it knows:
  * the kitty keyboard protocol (kitty, foot, ghostty, wezterm, alacritty, ...) and xterm's
- * modifyOtherKeys. Terminals that know neither ignore both, and Alt+Enter still works.
- * While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.
+ * modifyOtherKeys. While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.
+ *
+ * Only sent to terminals that are known to understand them (`extendedKeysSupported`): a terminal
+ * that does not parses `CSI > 1 u` as "restore the cursor" and `CSI > 4 ; 1 m` as "underline, bold",
+ * which throws the prompt to the top of the screen and draws lines under every row (Termux, UserLAnd).
+ */
+const EXTENDED_KEYS_ON_SEQ = '\x1b[>1u\x1b[>4;1m';
+const EXTENDED_KEYS_OFF_SEQ = '\x1b[<u\x1b[>4;0m';
+const KEYBOARD_PROTOCOL_PROGRAMS = new Set(['ghostty', 'wezterm', 'iterm.app', 'kitty', 'foot', 'alacritty', 'rio', 'contour']);
+/**
+ * Does this terminal understand the extended keyboard modes? Decided from the environment, and
+ * only for terminals known to: a wrong guess in the other direction costs Ctrl+Enter (Alt+Enter
+ * and a backslash before Enter still break the line), a wrong guess in this one wrecks the screen.
+ * `DEVX_EXTENDED_KEYS=1` forces it on, `DEVX_EXTENDED_KEYS=0` off.
  */
-export const EXTENDED_KEYS_ON = '\x1b[>1u\x1b[>4;1m';
-export const EXTENDED_KEYS_OFF = '\x1b[<u\x1b[>4;0m';
+export function extendedKeysSupported(env = process.env, platform = process.platform) {
+    const forced = (env.DEVX_EXTENDED_KEYS ?? '').trim().toLowerCase();
+    if (['1', 'on', 'true', 'yes'].includes(forced))
+        return true;
+    if (['0', 'off', 'false', 'no'].includes(forced))
+        return false;
+    // Android: Termux, UserLAnd and other terminals built on the same emulator.
+    if (platform === 'android' || env.TERMUX_VERSION || env.PREFIX?.includes('com.termux') || env.ANDROID_ROOT || env.ANDROID_DATA)
+        return false;
+    // Multiplexers sit between devx and the real terminal: they decide for themselves.
+    if (env.TMUX || env.STY)
+        return false;
+    const term = (env.TERM ?? '').toLowerCase();
+    if (term.startsWith('screen') || term.startsWith('tmux') || term === 'linux' || term === 'dumb')
+        return false;
+    if (env.KITTY_WINDOW_ID || env.GHOSTTY_RESOURCES_DIR || env.WEZTERM_EXECUTABLE)
+        return true;
+    if (/kitty|ghostty|foot|alacritty|wezterm/.test(term))
+        return true;
+    return KEYBOARD_PROTOCOL_PROGRAMS.has((env.TERM_PROGRAM ?? '').toLowerCase());
+}
+/** What to write to turn the extended keyboard modes on (nothing on a terminal that does not know them). */
+export function extendedKeysOn() {
+    return extendedKeysSupported() ? EXTENDED_KEYS_ON_SEQ : '';
+}
+/** What to write to turn them off again. */
+export function extendedKeysOff() {
+    return extendedKeysSupported() ? EXTENDED_KEYS_OFF_SEQ : '';
+}
 /**
  * Turns the extended encodings back into the keys the rest of the code knows:
  * `CSI 99;5u` and `CSI 27;5;99~` become Ctrl+C (0x03), `CSI 27u` becomes Esc, and every way

package/dist/cli/prompt.js

@@ -8,7 +8,7 @@ import { filterCommandPalette, estimatePromptTokens, formatPromptTokenBadge } fr
 import { PromptHistoryNavigator } from './history_search.js';
 import { buildPromptFrame, moveCursorRow, palette, renderUserEcho, resolveMode } from './ui.js';
 import { displayWidth, padEndWidth, rowsToTop, truncateWidth } from './width.js';
-import { EXTENDED_KEYS_OFF, EXTENDED_KEYS_ON, isNewlineKey, normalizeKey } from './keys.js';
+import { extendedKeysOff, extendedKeysOn, isNewlineKey, normalizeKey } from './keys.js';
 export const SLASH_COMMANDS = [
     { cmd: '/new', desc: 'Start a new clean chat session' },
     { cmd: '/resume', desc: 'Resume a previous chat session' },
@@ -99,7 +99,7 @@ export function askPrompt(opts = {}) {
             process.stdin.setRawMode(true);
             process.stdout.write('\x1b[?2004h'); // Enable bracketed paste mode
             // Lets the terminal tell Ctrl+Enter and Shift+Enter (a new paragraph) from Enter (send).
-            process.stdout.write(EXTENDED_KEYS_ON);
+            process.stdout.write(extendedKeysOn());
         }
         // ── framed prompt (clean layout) ──
         // The frame is a block of rows; the cursor rests on the input row. Redrawing moves up
@@ -552,7 +552,7 @@ export function askPrompt(opts = {}) {
             disposed = true;
             unsubscribeOwner?.();
             if (process.stdout.isTTY) {
-                process.stdout.write('\x1b[?2004l' + EXTENDED_KEYS_OFF);
+                process.stdout.write('\x1b[?2004l' + extendedKeysOff());
             }
             process.stdout.removeListener('resize', onResize);
             process.stdin.removeListener('data', onData);

package/dist/cli/typeahead.js

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { EXTENDED_KEYS_OFF, EXTENDED_KEYS_ON, isNewlineKey, normalizeKey, splitKeys } from './keys.js';
+import { extendedKeysOff, extendedKeysOn, isNewlineKey, normalizeKey, splitKeys } from './keys.js';
 import { buildPromptFrame, palette } from './ui.js';
-import { displayWidth, truncateWidth } from './width.js';
+import { columnAfter, displayWidth, truncateWidth } from './width.js';
 import { t } from '../core/i18n.js';
 /** The down arrow in every form a terminal may send it: `ESC [ B`, `ESC O B` (application mode), `ESC [ 1 ; mods B` (with modifier fields). */
 const DOWN_ARROW = /^\x1b(?:\[|O)(?:1;[\d:]+)?B$/;
@@ -153,6 +153,8 @@ export class TurnComposer {
     state = { text: '', cursor: 0 };
     queue = [];
     lines = [];
+    /** The column the output cursor is in: the frame is drawn under it and the cursor comes back to this column. */
+    col = 0;
     original = null;
     timer = null;
     /** Called on ctrl+p (thinking) and ctrl+o (tool output). */
@@ -207,9 +209,10 @@ export class TurnComposer {
         this.active = true;
         this.suspended = false;
         this.shown = false;
+        this.col = 0;
         this.original = this.out.write.bind(this.out);
         this.out.write = ((chunk, encoding, cb) => this.through(chunk, encoding, cb));
-        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+        this.write(extendedKeysOn() + this.drawSeq());
         // The working line animates: its time and counter are redrawn while the output is quiet.
         if (this.status) {
             this.timer = setInterval(() => this.tick(), 60);
@@ -225,7 +228,7 @@ export class TurnComposer {
             this.timer = null;
         }
         if (this.active) {
-            this.write(this.eraseSeq() + EXTENDED_KEYS_OFF + '\x1b[?25h');
+            this.write(this.eraseSeq() + extendedKeysOff() + '\x1b[?25h');
             if (this.original)
                 this.out.write = this.original;
             this.original = null;
@@ -241,14 +244,14 @@ export class TurnComposer {
         if (!this.active || this.suspended)
             return;
         // The card or question that takes over reads plain keys: the extended encodings go off for it.
-        this.write(this.eraseSeq() + EXTENDED_KEYS_OFF);
+        this.write(this.eraseSeq() + extendedKeysOff());
         this.suspended = true;
     }
     resume() {
         if (!this.active || !this.suspended)
             return;
         this.suspended = false;
-        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+        this.write(extendedKeysOn() + this.drawSeq());
     }
     /** Builds the frame again (the context percentage or the cost changed) and draws it. */
     refresh() {
@@ -298,17 +301,27 @@ export class TurnComposer {
     /** The write that replaces the terminal's own for the length of the turn. */
     through(chunk, encoding, cb) {
         const raw = this.original;
-        if (!this.active || this.suspended)
+        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+        if (!this.active || this.suspended) {
+            this.advanceColumn(text);
             return raw(chunk, encoding, cb);
+        }
+        // The old frame is wiped from the column the cursor is in now; the new one comes back to the column the text ends in.
+        const erase = this.eraseSeq();
+        this.advanceColumn(text);
         if (typeof chunk === 'string') {
             // The callback form `write(chunk, cb)` has the callback in the second place.
-            return raw(this.eraseSeq() + chunk + this.drawSeq(), encoding, cb);
+            return raw(erase + chunk + this.drawSeq(), encoding, cb);
         }
-        raw(this.eraseSeq());
+        raw(erase);
         const result = raw(chunk, encoding, cb);
         raw(this.drawSeq());
         return result;
     }
+    /** Where the cursor is after this text (also while a card has the screen, so that the frame comes back to the right column). */
+    advanceColumn(text) {
+        this.col = columnAfter(this.col, text, this.out.columns ?? 80);
+    }
     write(text) {
         if (text)
             (this.original ?? this.out.write.bind(this.out))(text);
@@ -339,12 +352,25 @@ export class TurnComposer {
     oneRow(line) {
         return line.replace(/[\r\n\x00-\x08\x0b-\x1a\x1c-\x1f]+/g, ' ');
     }
-    /** Wipes the frame: everything under the cursor row. The cursor stays on its text. */
+    /** Puts the cursor back in the column of the output, on the row it is on. */
+    backToColumn() {
+        const cols = Math.max(1, this.out.columns ?? 80);
+        return `\x1b[${Math.min(this.col, cols - 1) + 1}G`;
+    }
+    /**
+     * Wipes the frame: everything under the cursor row. The cursor stays on its text.
+     *
+     * Only relative moves are used, no saved cursor (ESC 7 / ESC 8): the saved position is a screen row,
+     * and when the window changes size in the middle of a write (the keyboard of a phone comes and goes)
+     * some terminals do not move it with the text, and the cursor comes back to the wrong row.
+     */
     eraseSeq() {
         if (!this.shown)
             return '';
         this.shown = false;
-        return '\x1b7\x1b[1B\r\x1b[J\x1b8';
+        // The erase starts from plain attributes: a style left on by the text above (an underline, a
+        // background) would be painted into every row it wipes (stripes across the screen).
+        return '\x1b[0m\x1b[1B\r\x1b[J\x1b[1A' + this.backToColumn();
     }
     /** Draws the frame under the cursor row and puts the cursor back where the text goes on. */
     drawSeq() {
@@ -356,9 +382,9 @@ export class TurnComposer {
         // The real cursor only marks where the output goes on. Whatever showed it in the meantime
         // (an approval card, a spinner that stopped) must not leave it blinking under the output.
         // ESC D moves down (scrolling at the bottom edge) and keeps the column; then back up.
-        let seq = '\x1b[?25l' + '\x1bD'.repeat(n) + `\x1b[${n}A` + '\x1b7';
+        let seq = '\x1b[?25l' + '\x1bD'.repeat(n) + `\x1b[${n}A`;
         for (const line of lines)
-            seq += `\x1b[1B\r\x1b[2K${line}\x1b[0m`;
-        return seq + '\x1b8';
+            seq += `\x1b[0m\x1b[1B\r\x1b[2K${line}\x1b[0m`;
+        return seq + `\x1b[${n}A` + this.backToColumn();
     }
 }

package/dist/cli/update-screen.js

@@ -350,14 +350,13 @@ export async function runStartupUpdateCheck(config, deps = {}) {
     if (result.updateAvailable) {
         if (config.skippedUpdate === result.latestVersion)
             return;
-        await presentUpdate(result, {
+        return presentUpdate(result, {
             offerSkip: true,
             save: async (version) => {
                 config.skippedUpdate = version;
                 await deps.save?.(config);
             },
         }, deps);
-        return;
     }
     if (result.error)
         return; // offline at start-up is not worth a word
@@ -375,7 +374,7 @@ export async function runManualUpdate(deps = {}) {
     const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(10000));
     const cols = columnsOf(out);
     if (result.updateAvailable) {
-        await presentUpdate(result, { offerSkip: false }, deps);
+        return presentUpdate(result, { offerSkip: false }, deps);
     }
     else if (result.error) {
         out.write(renderNotice('warn', t('update.offline', { reason: result.error }), cols) + '\n');

package/dist/cli/updater.js

@@ -280,9 +280,26 @@ export async function runUpdateSteps(steps, events = {}, now = Date.now) {
     }
     return { ok: true };
 }
-/** Starts devx again, with the same arguments, and ends this process when the new one ends. */
+/**
+ * Starts devx again, with the same arguments, and ends this process when the new one ends.
+ *
+ * From here on this process only waits: the terminal belongs to the new one. It stops reading the
+ * keyboard (two programs reading one terminal take the keys from each other, and a typed line
+ * can end up in the shell) and no longer reacts to Ctrl+C itself (the new devx gets it).
+ */
 export function restartDevx() {
+    try {
+        process.stdin.pause();
+    }
+    catch { }
     const child = spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+    process.removeAllListeners('SIGINT');
+    process.on('SIGINT', () => { });
+    process.removeAllListeners('SIGTERM');
+    process.on('SIGTERM', () => { try {
+        child.kill('SIGTERM');
+    }
+    catch { } });
     child.on('exit', (code) => process.exit(code ?? 0));
     child.on('error', () => process.exit(0));
 }

package/dist/cli/width.js

@@ -289,3 +289,35 @@ export function rowsToTop(lineWidths, cursorRow, cursorCol, cols) {
         rows += Math.max(1, Math.ceil(lineWidths[i] / width));
     return rows + Math.floor(Math.max(0, cursorCol) / width);
 }
+/**
+ * The column (0-based, in cells) the cursor is in after `text` is written starting at column `col`
+ * of a terminal `cols` wide. Escape sequences take no room; a line break and a carriage return go
+ * to column 0; a character that does not fit wraps to the next row. A cursor that has just filled
+ * the last column is reported as `cols` (the terminal holds it there until the next character).
+ */
+export function columnAfter(col, text, cols) {
+    const width = Math.max(1, cols);
+    let at = Math.max(0, Math.min(col, width));
+    const plain = text.replace(ANSI, '').replace(/\x1b[0-9A-Za-z=>]/g, '');
+    for (const ch of plain) {
+        if (ch === '\n' || ch === '\r') {
+            at = 0;
+            continue;
+        }
+        if (ch === '\b') {
+            at = Math.max(0, at - 1);
+            continue;
+        }
+        if (ch === '\t') {
+            at = Math.min(width - 1, (Math.floor(at / 8) + 1) * 8);
+            continue;
+        }
+        const w = codePointWidth(ch.codePointAt(0));
+        if (w === 0)
+            continue;
+        if (at + w > width)
+            at = 0;
+        at += w;
+    }
+    return at;
+}

package/dist/core/types.js

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

package/package.json

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