termux-dev 1.9.0 → 1.9.2

package/README.md

@@ -185,7 +185,7 @@ Type `/` in the prompt to open the autocomplete command palette:
 | **`/resume`** | Browse and resume saved chat sessions |
 | **`/session del`** | Selectively or bulk delete saved sessions |
 | **`/settings`** | Configure theme, interface, YOLO auto-approve, project memory, update checks and the interface language |
-| **`/update`** | Check and install latest updates from GitHub |
+| **`/update`** | Check for a new version: a card with what is new, then **Update now**, **Later** or (at start-up) **Skip this version**. The install runs on a live screen step by step, checks that npm really has the version, and restarts devx. If it fails you get the reason and the command to run by hand |
 | **`/model`** | Switch model for the active provider with live search |
 | **`/effort [level]`** | Set the reasoning effort. Only the levels the current model supports are offered (see [Reasoning effort](#reasoning-effort)) |
 | **`/provider`** | Switch provider (OpenRouter, Gemini, Groq, DeepSeek, Local) |

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.0</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.2</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.0</text>
+  <text x="112.0" y="62.0" class="t" fill="#5f6b7a">v1.9.2</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/finder.js

@@ -38,10 +38,14 @@ function hintLine(width, typing) {
     return '';
 }
 /** The card around some content rows; `rows` are already padded to the inner width by the caller's `box`. */
-function frame(title, subtitle, cols, body, footer) {
+/** The card every list and field is drawn in: a title and a subtitle in the border, a body, a line of hints under it. */
+export function frame(title, subtitle, cols, body, footer) {
     if (cols < 60) {
         const width = Math.max(20, cols - 1);
-        const head = ' ' + palette.bold(palette.accent(title)) + (subtitle ? palette.faint(' · ' + truncateWidth(subtitle, Math.max(6, width - displayWidth(title) - 6))) : '');
+        // Never wider than the screen, however long the title is in the language of the interface.
+        const shownTitle = truncateWidth(title, Math.max(4, width - 1));
+        const subRoom = width - 1 - displayWidth(shownTitle) - 3;
+        const head = ' ' + palette.bold(palette.accent(shownTitle)) + (subtitle && subRoom >= 6 ? palette.faint(' · ' + truncateWidth(subtitle, subRoom)) : '');
         const plain = (c, shaded = false) => (shaded ? palette.shade(padEndWidth(' ' + c, width)) : ' ' + c);
         return [head, ...body(width - 1, plain), ' ' + footer];
     }

package/dist/cli/index.js

@@ -34,7 +34,7 @@ import { MarkdownStreamer, renderMarkdown } from './markdown.js';
 import { SmoothStreamer } from './smooth.js';
 import { askPrompt } from './prompt.js';
 import { resolveAtMentions } from './files.js';
-import { runStartupUpdateCheck, checkForUpdates, performSelfUpdate } from './updater.js';
+import { runManualUpdate, runStartupUpdateCheck } from './update-screen.js';
 import { setActiveTheme, getCurrentTheme, listThemes, findTheme } from './theme.js';
 import { runHeadlessMode } from './headless.js';
 import { CustomCommandManager } from '../core/commands.js';
@@ -934,7 +934,7 @@ export async function main() {
     history.addMessage({ role: 'system', content: sysPrompt });
     const sessionManager = new SessionManager(config.model, planMode);
     drawLogo(config.banner || 'full');
-    await runStartupUpdateCheck(config);
+    await runStartupUpdateCheck(config, { save: saveConfig });
     await MCPManager.getInstance().init(undefined, config.projectMcpTrusted === true);
     // Ask a custom endpoint what the current model can do (cached for a day; never blocks the prompt).
     void refreshEndpoint(config).catch(() => null);
@@ -1275,20 +1275,7 @@ export async function main() {
                 continue;
             }
             if (cmd === '/update') {
-                const s = new UiSpinner();
-                s.start('Checking for updates from https://github.com/apvcode/Termux-Dev...');
-                const res = await checkForUpdates(10000);
-                s.stop();
-                if (res.updateAvailable) {
-                    log.info(pc.bold(pc.yellow(`Update available: v${res.currentVersion} → v${res.latestVersion}`)));
-                    const doUpdate = await askConfirm({ title: 'update', question: t('confirm.update', { version: res.latestVersion }), initial: true });
-                    if (doUpdate) {
-                        await performSelfUpdate(res.latestVersion);
-                    }
-                }
-                else {
-                    log.success(pc.green(`devx is up to date! (v${res.currentVersion})`));
-                }
+                await runManualUpdate();
                 continue;
             }
             if (cmd === '/help') {

package/dist/cli/liveblock.js

@@ -61,6 +61,15 @@ export class LiveBlock {
         this.out.write(`\r${rows > 1 ? `\x1b[${rows - 1}A` : ''}\x1b[J\x1b[?25h`);
         this.widths = [];
     }
+    /** Leaves what is drawn on the screen as it is: the cursor comes back under it and the next draw starts a new block. */
+    release() {
+        if (this.widths.length === 0) {
+            this.out.write('\x1b[?25h');
+            return;
+        }
+        this.out.write('\n\x1b[?25h');
+        this.widths = [];
+    }
     /**
      * Calls `redraw` when the window is resized, so the block is drawn again at the new width.
      * Returns the function that stops watching (call it when the panel closes).

package/dist/cli/update-screen.js

@@ -0,0 +1,383 @@
+import { frame } from './finder.js';
+import { LiveBlock } from './liveblock.js';
+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';
+/**
+ * The update screens, in the style of the rest of devx:
+ *
+ *   checking   one line, the text with a bright band sweeping across it
+ *   card       what is new (from the notes of the release), how it will be installed
+ *   choice     Update now / Later / Skip this version
+ *   progress   the steps with a spinner and the time of each, and a bar that fills as they go
+ *   result     installed (the bar drains while devx restarts) or what failed and how to do it by hand
+ *
+ * Every screen is a pure function of its state and the animation tick, so it can be tested without
+ * a terminal; `presentUpdate` only adds the timer, the keyboard and the install.
+ */
+export const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const TICK_MS = 80;
+// ───────────────────────── animation pieces ─────────────────────────
+/** The text with a bright band moving across it; `tick` is the frame of the animation. */
+export function shimmer(text, tick) {
+    const chars = Array.from(text);
+    const position = ((tick * 1.2) % (chars.length + 10)) - 5;
+    return chars
+        .map((ch, i) => {
+        if (ch === ' ')
+            return ch;
+        const d = Math.abs(i - position);
+        if (d < 1.2)
+            return palette.bold(palette.text(ch));
+        if (d < 3.5)
+            return palette.accent(ch);
+        return palette.muted(ch);
+    })
+        .join('');
+}
+/** A bar of exactly `width` cells. While busy a bright spot runs along the filled part. */
+export function renderBar(width, progress, tick, tone = 'busy') {
+    const w = Math.max(4, width);
+    const filled = Math.max(0, Math.min(w, Math.round(progress * w)));
+    const color = tone === 'done' ? palette.ok : tone === 'failed' ? palette.err : palette.accent;
+    const spot = tone === 'busy' && filled > 0 ? ((tick * 1.5) % (filled + 6)) - 3 : -99;
+    let out = '';
+    for (let i = 0; i < w; i++) {
+        if (i < filled)
+            out += Math.abs(i - spot) < 1.5 ? palette.bold(palette.text('━')) : color('━');
+        else if (i === filled && tone === 'busy')
+            out += color('╸');
+        else
+            out += palette.rule('─');
+    }
+    return out;
+}
+/** How long each step weighs in the bar: the install is nearly all of the wait. */
+const WEIGHT = { registry: 0.1, install: 0.75, verify: 0.15, pull: 0.15, build: 0.75, link: 0.1 };
+/**
+ * How full the bar is. The real progress of an install is not known, so the step that is running
+ * fills asymptotically: it keeps moving, and it never reaches the end before the step is done.
+ */
+export function estimateProgress(ids, doneCount, runningMs, expectedMs = 15000) {
+    const total = ids.reduce((sum, id) => sum + WEIGHT[id], 0);
+    if (doneCount >= ids.length)
+        return 1;
+    const done = ids.slice(0, doneCount).reduce((sum, id) => sum + WEIGHT[id], 0);
+    const running = WEIGHT[ids[doneCount]] * (1 - Math.exp(-runningMs / expectedMs)) * 0.92;
+    return Math.min(0.99, (done + running) / total);
+}
+const seconds = (ms) => `${(ms / 1000).toFixed(1)}s`;
+// ───────────────────────── what is new ─────────────────────────
+const SECTION_NAMES = {
+    en: /english/i, ru: /русск/i, uk: /україн/i, de: /deutsch/i, es: /español/i, fr: /français/i, pt: /português/i, zh: /中文/, ja: /日本語/,
+};
+function cleanMarkdown(text) {
+    return text
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/[`*_]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * The highlights of a release: the top-level bullets under its first `###` heading, in the language
+ * of the interface when the notes have a section for it (`## Русский`), else the first section.
+ */
+export function extractHighlights(body, language, max = 4) {
+    if (!body)
+        return [];
+    const lines = body.replace(/\r/g, '').split('\n');
+    const sections = [];
+    for (const line of lines) {
+        const heading = /^##\s+(.+?)\s*$/.exec(line);
+        if (heading)
+            sections.push({ name: heading[1], lines: [] });
+        else
+            sections[sections.length - 1]?.lines.push(line);
+    }
+    const pool = sections.length > 0 ? sections : [{ name: '', lines }];
+    const own = SECTION_NAMES[language];
+    const chosen = (own && pool.find((s) => own.test(s.name))) || pool.find((s) => SECTION_NAMES.en.test(s.name)) || pool[0];
+    const out = [];
+    let seenHeading = false;
+    for (const line of chosen.lines) {
+        if (/^###\s/.test(line)) {
+            // The bullets of the first block only ("Highlights"): the next heading ends them.
+            if (seenHeading && out.length > 0)
+                break;
+            seenHeading = true;
+            continue;
+        }
+        const bullet = /^-\s+(.+)$/.exec(line);
+        if (bullet) {
+            const text = cleanMarkdown(bullet[1]);
+            if (text)
+                out.push(text);
+            if (out.length >= max)
+                break;
+        }
+    }
+    return out;
+}
+/** `Your own providers. A name, an address…` -> the short head and the rest. */
+function splitHighlight(text) {
+    const at = text.search(/[.:] /);
+    if (at > 0 && at <= 50)
+        return { head: text.slice(0, at + 1), rest: text.slice(at + 2) };
+    return { head: text, rest: '' };
+}
+const versions = (current, latest) => `v${current} → v${latest}`;
+/** The line while the check runs. */
+export function renderChecking(cols, tick, current) {
+    const limit = Math.max(10, cols - 1);
+    const spin = palette.accent(SPINNER_FRAMES[tick % SPINNER_FRAMES.length]);
+    // Two cells of indent, the spinner and a space come first; the text is cut to what is left.
+    const text = truncateWidth(t('update.checking'), Math.max(4, limit - 4));
+    const label = shimmer(text, tick);
+    const withTag = `  ${spin} ${label}  ${palette.faint(`v${current}`)}`;
+    return displayWidth(withTag) <= limit ? withTag : `  ${spin} ${label}`;
+}
+/** The card that says a new version is out and what is in it. */
+export function renderUpdateCard(info, cols) {
+    const how = info.method === 'npm' ? t('update.viaNpm') : t('update.viaGit');
+    return frame(t('update.title'), versions(info.current, info.latest), cols, (iw, box) => {
+        const lines = [];
+        lines.push(box(' ' + palette.bold(palette.accent(truncateWidth(t('update.available', { version: info.latest }), iw - 2)))));
+        const date = info.publishedAt ? info.publishedAt.slice(0, 10) : '';
+        const meta = [t('update.have', { version: info.current }), date ? t('update.released', { date }) : ''].filter(Boolean).join(' · ');
+        lines.push(box(' ' + palette.muted(truncateWidth(meta, iw - 2))));
+        if (info.highlights.length > 0) {
+            lines.push(box(''));
+            lines.push(box(' ' + palette.faint(truncateWidth(t('update.whatsNew').toUpperCase(), iw - 2))));
+            for (const text of info.highlights) {
+                const { head, rest } = splitHighlight(text);
+                const room = iw - 4;
+                const headText = truncateWidth(head, room);
+                const restRoom = room - displayWidth(headText) - 1;
+                const tailText = rest && restRoom >= 8 ? ' ' + palette.muted(truncateWidth(rest, restRoom)) : '';
+                lines.push(box(' ' + palette.accent('●') + ' ' + palette.bold(palette.text(headText)) + tailText));
+            }
+        }
+        lines.push(box(''));
+        return lines;
+    }, palette.faint(truncateWidth(how, Math.max(10, cols - 3))));
+}
+/** The steps with a spinner on the one that runs, and the bar. */
+export function renderProgressCard(state, cols, tick) {
+    const done = state.tone === 'done';
+    return frame(done ? t('update.titleDone') : t('update.titleBusy'), versions(state.current, state.latest), cols, (iw, box) => {
+        const lines = [];
+        for (const step of state.steps) {
+            const icon = step.status === 'ok' ? palette.ok('✓')
+                : step.status === 'run' ? palette.accent(SPINNER_FRAMES[tick % SPINNER_FRAMES.length])
+                    : step.status === 'fail' ? palette.err('✗')
+                        : palette.faint('○');
+            const time = step.ms !== undefined ? palette.faint(seconds(step.ms)) : '';
+            const room = Math.max(6, iw - 4 - displayWidth(time) - 1);
+            const text = truncateWidth(step.label, room);
+            const label = step.status === 'run' ? palette.bold(palette.text(text))
+                : step.status === 'wait' ? palette.faint(text)
+                    : step.status === 'fail' ? palette.err(text)
+                        : palette.muted(text);
+            const left = ' ' + icon + ' ' + label;
+            lines.push(box(left + ' '.repeat(Math.max(1, iw - displayWidth(left) - displayWidth(time) - 1)) + time));
+        }
+        lines.push(box(''));
+        lines.push(box(' ' + renderBar(iw - 2, state.progress, tick, state.tone)));
+        if (state.restarting)
+            lines.push(box(' ' + palette.muted(truncateWidth(t('update.restarting'), iw - 2))));
+        lines.push(box(''));
+        return lines;
+    }, palette.faint(truncateWidth(done ? t('update.installed', { version: state.latest }) : t('update.keepOpen'), Math.max(10, cols - 3))));
+}
+/** The command that does the update by hand. */
+export const manualCommand = (method) => (method === 'npm' ? 'npm install -g termux-dev@latest' : 'git pull && npm install && npm run build');
+/** What failed, and how to do it by hand. devx goes on with the version it has. */
+export function renderFailureCard(info, cols) {
+    return frame(t('update.titleFailed'), versions(info.current, info.latest), cols, (iw, box) => {
+        const lines = [];
+        lines.push(box(' ' + palette.err('✗') + ' ' + palette.err(truncateWidth(t('update.failedStep', { step: info.step }), iw - 4))));
+        const detail = info.notPublished
+            ? [t('update.notPublished', { version: info.latest })]
+            : info.message.split('\n').map((l) => l.trim()).filter(Boolean).slice(-4);
+        for (const line of detail)
+            lines.push(box('   ' + palette.muted(truncateWidth(line, iw - 4))));
+        lines.push(box(''));
+        lines.push(box(' ' + palette.text(truncateWidth(t('update.keepsRunning', { version: info.current }), iw - 2))));
+        lines.push(box(''));
+        lines.push(box(' ' + palette.faint(truncateWidth(t('update.byHand'), iw - 2))));
+        lines.push(box('   ' + palette.bold(palette.text(truncateWidth(manualCommand(info.method), iw - 4)))));
+        lines.push(box(''));
+        return lines;
+    }, '');
+}
+const columnsOf = (out) => out.columns || process.stdout.columns || 80;
+const write = (out, lines) => out.write(lines.join('\n') + '\n');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Shows the card for a new version, asks what to do and, when told to, installs it on a live
+ * screen and restarts devx. `offerSkip` adds "Skip this version" (the start-up check, not /update);
+ * `save` is told which version was skipped.
+ */
+export async function presentUpdate(info, opts, deps = {}) {
+    const out = deps.output ?? process.stdout;
+    const now = deps.now ?? Date.now;
+    const install = deps.install ?? (await detectInstallMethod());
+    const cols = columnsOf(out);
+    write(out, [
+        '',
+        ...renderUpdateCard({ current: info.currentVersion, latest: info.latestVersion, publishedAt: info.publishedAt, highlights: extractHighlights(info.releaseNotes, getLanguage()), method: install.method }, cols),
+        '',
+    ]);
+    // Nobody to ask (a pipe): the card is all there is.
+    if (!out.isTTY)
+        return 'later';
+    const picker = deps.picker ?? runPicker;
+    const labels = [t('update.now'), t('update.later'), t('update.skip')];
+    const choice = await picker({
+        title: t('update.title'),
+        subtitle: versions(info.currentVersion, info.latestVersion),
+        items: [
+            { value: 'now', label: t('update.now'), detail: t('update.nowDetail', { version: info.latestVersion }) },
+            { value: 'later', label: t('update.later'), detail: t('update.laterDetail') },
+            ...(opts.offerSkip ? [{ value: 'skip', label: t('update.skip'), detail: t('update.skipDetail', { version: info.latestVersion }) }] : []),
+        ],
+        current: 'now',
+        labelWidth: Math.max(...labels.slice(0, opts.offerSkip ? 3 : 2).map((l) => displayWidth(l))) + 2,
+    });
+    if (choice === 'skip') {
+        await opts.save?.(info.latestVersion);
+        out.write(renderNotice('info', t('update.skipped', { version: info.latestVersion }), cols) + '\n\n');
+        return 'skipped';
+    }
+    if (choice !== 'now')
+        return 'later';
+    // ── the install, on a screen that is redrawn in place
+    const steps = buildUpdateSteps(install.method, install.root, info.latestVersion, deps.run);
+    const ids = steps.map((step) => step.id);
+    const state = {
+        current: info.currentVersion,
+        latest: info.latestVersion,
+        steps: ids.map((id, i) => ({ label: t(`update.step.${id}`, { version: info.latestVersion }), status: i === 0 ? 'run' : 'wait' })),
+        progress: 0,
+        tone: 'busy',
+    };
+    const block = new LiveBlock(out);
+    let tick = 0;
+    let runningSince = now();
+    let restartStart = 0;
+    const restartMs = deps.restartMs ?? 1500;
+    const draw = () => {
+        if (state.restarting)
+            state.progress = Math.max(0, 1 - (now() - restartStart) / restartMs);
+        else {
+            const doneCount = state.steps.filter((s) => s.status === 'ok').length;
+            state.progress = state.tone === 'failed' ? state.progress : estimateProgress(ids, doneCount, now() - runningSince);
+        }
+        block.draw(renderProgressCard(state, columnsOf(out), tick++));
+    };
+    draw();
+    const timer = setInterval(draw, deps.tickMs ?? TICK_MS);
+    timer.unref?.();
+    const stopWatching = block.watchResize(draw);
+    const outcome = await runUpdateSteps(steps, {
+        onStart: (i) => {
+            state.steps[i].status = 'run';
+            runningSince = now();
+        },
+        onDone: (i, ms) => {
+            state.steps[i].status = 'ok';
+            state.steps[i].ms = ms;
+            if (state.steps[i + 1])
+                state.steps[i + 1].status = 'run';
+        },
+    }, now);
+    if (!outcome.ok) {
+        clearInterval(timer);
+        stopWatching();
+        state.steps[outcome.index].status = 'fail';
+        state.tone = 'failed';
+        block.erase();
+        write(out, renderFailureCard({ current: info.currentVersion, latest: info.latestVersion, step: state.steps[outcome.index].label, message: outcome.error.message, notPublished: outcome.error.kind === 'not-published', method: install.method }, columnsOf(out)));
+        out.write('\x1b[?25h\n');
+        return 'failed';
+    }
+    // Installed: the bar turns green and drains while devx restarts.
+    state.tone = 'done';
+    state.restarting = true;
+    restartStart = now();
+    await sleep(restartMs);
+    clearInterval(timer);
+    stopWatching();
+    state.progress = 0;
+    block.draw(renderProgressCard(state, columnsOf(out), tick));
+    block.release();
+    (deps.restart ?? restartDevx)();
+    return 'updated';
+}
+// ───────────────────────── the check ─────────────────────────
+/** Runs `work` while the "checking" line plays, and takes the line away when it is done. */
+async function withCheckingLine(out, current, work, tickMs = TICK_MS) {
+    if (!out.isTTY)
+        return work();
+    const block = new LiveBlock(out);
+    let tick = 0;
+    const draw = () => block.draw([renderChecking(columnsOf(out), tick++, current)]);
+    draw();
+    const timer = setInterval(draw, tickMs);
+    timer.unref?.();
+    try {
+        return await work();
+    }
+    finally {
+        clearInterval(timer);
+        block.erase();
+    }
+}
+/** At start-up: look for a new version; say so only when there is one (and it was not skipped). */
+export async function runStartupUpdateCheck(config, deps = {}) {
+    if (config.checkUpdates === false)
+        return;
+    const out = deps.output ?? process.stdout;
+    if (!out.isTTY)
+        return;
+    const current = await getCurrentVersion();
+    const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(6000));
+    if (result.updateAvailable) {
+        if (config.skippedUpdate === result.latestVersion)
+            return;
+        await 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
+    // 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);
+    out.write('\x1b[1A\x1b[2K');
+}
+/** `/update`: the same, but it always answers (also "up to date" and "could not check"). */
+export async function runManualUpdate(deps = {}) {
+    const out = deps.output ?? process.stdout;
+    const current = await getCurrentVersion();
+    const result = await withCheckingLine(out, current, () => (deps.check ?? checkForUpdates)(10000));
+    const cols = columnsOf(out);
+    if (result.updateAvailable) {
+        await presentUpdate(result, { offerSkip: false }, deps);
+    }
+    else if (result.error) {
+        out.write(renderNotice('warn', t('update.offline', { reason: result.error }), cols) + '\n');
+    }
+    else {
+        out.write(renderNotice('ok', t('update.upToDate', { version: result.currentVersion }), cols) + '\n');
+    }
+}
+export { UpdateError };

package/dist/cli/updater.js

@@ -1,13 +1,11 @@
-import { execSync, spawn } from 'child_process';
+import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs/promises';
-import pc from 'picocolors';
-import { select } from '@inquirer/prompts';
-import { palette } from './ui.js';
 import { fileURLToPath } from 'url';
 const GITHUB_REPO_URL = 'https://github.com/apvcode/Termux-Dev';
-const REMOTE_PKG_URL = 'https://raw.githubusercontent.com/apvcode/Termux-Dev/main/package.json';
-const REMOTE_RELEASE_URL = 'https://api.github.com/repos/apvcode/Termux-Dev/releases/latest';
+// Where to look for the newest version. Overridable (a mirror, a test server).
+const REMOTE_PKG_URL = process.env.DEVX_UPDATE_PKG_URL || 'https://raw.githubusercontent.com/apvcode/Termux-Dev/main/package.json';
+const REMOTE_RELEASE_URL = process.env.DEVX_UPDATE_RELEASE_URL || 'https://api.github.com/repos/apvcode/Termux-Dev/releases/latest';
 // Compare semantic versions (e.g. 1.1.0 > 1.0.0)
 export function isNewerVersion(remote, current) {
     const clean = (v) => v.replace(/^v/, '').trim();
@@ -54,6 +52,7 @@ export async function checkForUpdates(timeoutMs = 10000) {
         });
         let latestVersion = '';
         let releaseNotes = '';
+        let publishedAt = '';
         if (res.ok) {
             const pkg = await res.json();
             latestVersion = (pkg.version || '').replace(/^v/, '').trim();
@@ -71,6 +70,7 @@ export async function checkForUpdates(timeoutMs = 10000) {
                     latestVersion = relTag;
                 }
                 releaseNotes = relData.body || '';
+                publishedAt = relData.published_at || '';
             }
         }
         catch { }
@@ -79,7 +79,8 @@ export async function checkForUpdates(timeoutMs = 10000) {
                 updateAvailable: true,
                 currentVersion,
                 latestVersion,
-                releaseNotes
+                releaseNotes,
+                publishedAt: publishedAt || undefined
             };
         }
         return {
@@ -98,163 +99,136 @@ export async function checkForUpdates(timeoutMs = 10000) {
         };
     }
 }
-async function isGitRepository(dir) {
+/** 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);
+    const root = path.resolve(path.dirname(here), '../../');
+    // DEVX_UPDATE_METHOD forces one of them (a copy in a git folder that is installed with npm, a test).
+    const forced = (process.env.DEVX_UPDATE_METHOD || '').toLowerCase();
+    if (forced === 'npm' || forced === 'git')
+        return { method: forced, root };
     try {
-        await fs.stat(path.join(dir, '.git'));
-        return true;
+        await fs.stat(path.join(root, '.git'));
+        return { method: 'git', root };
     }
     catch {
-        return false;
+        return { method: 'npm', root };
     }
 }
-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 ──────────────────────────')));
-    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(`npm install -g termux-dev@latest`)} `);
-        }, 80);
-        try {
-            execSync('npm install -g termux-dev@latest --prefer-online', { stdio: 'pipe' });
-            clearInterval(interval);
-            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(`Update failed: ${err.message}`)}\n`);
-            console.log(pc.yellow(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev@latest')}`));
-            return false;
-        }
+/** What a step of the update says when it fails. `not-published`: the version is on GitHub but not in npm yet. */
+export class UpdateError extends Error {
+    kind;
+    constructor(message, kind = 'failed') {
+        super(message);
+        this.kind = kind;
+        this.name = 'UpdateError';
     }
-    else {
-        // 2. Installed via git clone (Developer mode)
-        const steps = [
+}
+const OUTPUT_KEEP = 4000;
+export const runCommand = (command, args, options = {}) => new Promise((resolve) => {
+    let output = '';
+    const keep = (chunk) => {
+        output = (output + chunk.toString('utf8')).slice(-OUTPUT_KEEP);
+    };
+    // On Windows npm is a .cmd file, which only a shell can start.
+    const child = spawn(command, args, { cwd: options.cwd, shell: process.platform === 'win32', stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    child.stdout?.on('data', keep);
+    child.stderr?.on('data', keep);
+    child.on('error', (err) => resolve({ code: -1, output: output + String(err.message) }));
+    child.on('close', (code) => resolve({ code: code ?? -1, output }));
+});
+/** The last lines of a command's output, for the message of a failure. */
+export function tail(output, lines = 4) {
+    return output
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .slice(-lines)
+        .join('\n');
+}
+function must(result, what) {
+    if (result.code !== 0)
+        throw new UpdateError(tail(result.output) || `${what} failed (exit code ${result.code})`);
+    return result;
+}
+/**
+ * The steps of an update, in order. Nothing is run until `run()` of a step is called.
+ *
+ *  npm: ask the registry whether the version is there (GitHub knows a release before npm has the
+ *       package: installing `latest` then would "update" to the old version), install exactly that
+ *       version, and read back which version is installed.
+ *  git: pull, install and build, link the command.
+ */
+export function buildUpdateSteps(method, root, version, run = runCommand) {
+    if (method === 'npm') {
+        return [
             {
-                title: 'Pulling latest updates from GitHub repository...',
-                action: () => {
-                    execSync('git pull origin main', { cwd: projectRoot, stdio: 'pipe' });
-                }
+                id: 'registry',
+                run: async () => {
+                    const res = await run('npm', ['view', `termux-dev@${version}`, 'version', '--prefer-online']);
+                    if (res.code !== 0) {
+                        // A version that is not in the registry is an E404, not an older answer.
+                        if (/E404|No match found/i.test(res.output))
+                            throw new UpdateError(`termux-dev@${version} is not in the npm registry yet`, 'not-published');
+                        throw new UpdateError(tail(res.output) || `npm view failed (exit code ${res.code})`);
+                    }
+                    if (res.output.trim().split('\n').pop()?.trim() !== version) {
+                        throw new UpdateError(`termux-dev@${version} is not in the npm registry yet`, 'not-published');
+                    }
+                },
             },
             {
-                title: 'Building and compiling TypeScript sources...',
-                action: () => {
-                    execSync('npm install', { cwd: projectRoot, stdio: 'pipe' });
-                    execSync('npm run build', { cwd: projectRoot, stdio: 'pipe' });
-                }
+                id: 'install',
+                run: async () => {
+                    must(await run('npm', ['install', '-g', `termux-dev@${version}`, '--prefer-online']), 'npm install');
+                },
             },
             {
-                title: 'Ensuring binary execution permissions & linking...',
-                action: () => {
+                id: 'verify',
+                run: async () => {
+                    const res = await run('npm', ['ls', '-g', 'termux-dev', '--depth=0', '--json']);
+                    let installed = '';
                     try {
-                        execSync('npm link', { cwd: projectRoot, stdio: 'pipe' });
+                        installed = JSON.parse(res.output.slice(res.output.indexOf('{')))?.dependencies?.['termux-dev']?.version ?? '';
                     }
                     catch { }
-                }
-            }
+                    if (installed !== version)
+                        throw new UpdateError(`npm reports ${installed || 'no version'} instead of ${version}`);
+                },
+            },
         ];
-        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(`\nTo update manually, run: ${pc.bold('npm install -g termux-dev')}`));
-                return false;
-            }
-        }
-    }
-    console.log(pc.bold(pc.green(`\nSuccessfully updated to v${latestVersion}! Restarting devx...\n`)));
-    console.log(pc.bold(pc.cyan('──────────────────────────────────────────────────────\n')));
-    await new Promise(r => setTimeout(r, 1000));
-    try {
-        const child = spawn(process.argv[0], process.argv.slice(1), {
-            stdio: 'inherit',
-            detached: true
-        });
-        child.unref();
-        process.exit(0);
-    }
-    catch {
-        process.exit(0);
     }
-    return true;
+    return [
+        { id: 'pull', run: async () => void must(await run('git', ['pull', '--ff-only', 'origin', 'main'], { cwd: root }), 'git pull') },
+        {
+            id: 'build',
+            run: async () => {
+                must(await run('npm', ['install'], { cwd: root }), 'npm install');
+                must(await run('npm', ['run', 'build'], { cwd: root }), 'npm run build');
+            },
+        },
+        // Linking is a convenience: a failure here does not undo the update.
+        { id: 'link', run: async () => void (await run('npm', ['link'], { cwd: root })) },
+    ];
 }
-export async function runStartupUpdateCheck(config) {
-    // If updates checking is disabled in settings, return immediately
-    if (config.checkUpdates === false) {
-        return;
-    }
-    const currentVersion = await getCurrentVersion();
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let fIdx = 0;
-    let isDone = false;
-    const spinner = setInterval(() => {
-        if (isDone)
-            return;
-        // The colours of the theme, like the rest of the interface.
-        const frame = palette.accent(frames[fIdx++ % frames.length]);
-        process.stdout.write(`\r  ${frame} ${palette.muted('Checking for updates from')} ${palette.accent('apvcode/Termux-Dev')} ${palette.faint(`(v${currentVersion})...`)} `);
-    }, 75);
-    const result = await checkForUpdates(10000);
-    isDone = true;
-    clearInterval(spinner);
-    // Clear spinner line
-    process.stdout.write('\r\x1b[K');
-    if (result.updateAvailable) {
-        console.log();
-        console.log(palette.rule('  ┌───────────────────────────────────────────────────────────┐'));
-        console.log(palette.rule('  │') + palette.bold(palette.accent(`  A new update is available: `)) + palette.muted(`v${result.currentVersion}`) + palette.bold(palette.ok(` → v${result.latestVersion}`)) + ' '.repeat(Math.max(1, 23 - result.currentVersion.length - result.latestVersion.length)) + palette.rule('│'));
-        console.log(palette.rule('  │') + palette.faint(`  Repository: https://github.com/apvcode/Termux-Dev          `) + palette.rule('│'));
-        console.log(palette.rule('  └───────────────────────────────────────────────────────────┘'));
-        console.log();
+/** Runs the steps one after the other and stops at the first that fails. */
+export async function runUpdateSteps(steps, events = {}, now = Date.now) {
+    for (let index = 0; index < steps.length; index++) {
+        events.onStart?.(index);
+        const started = now();
         try {
-            const choice = await select({
-                message: palette.bold('Do you want to update devx now?'),
-                loop: false,
-                choices: [
-                    {
-                        name: `Update now (Pull v${result.latestVersion}, rebuild & restart)`,
-                        value: 'update',
-                        description: 'Download latest code, compile TypeScript, and restart devx'
-                    },
-                    {
-                        name: 'Skip for now (Continue to chat)',
-                        value: 'skip',
-                        description: 'Keep current version and start session'
-                    }
-                ]
-            });
-            if (choice === 'update') {
-                await performSelfUpdate(result.latestVersion);
-            }
+            await steps[index].run();
         }
-        catch {
-            // If user presses Ctrl+C / cancels prompt, continue
+        catch (err) {
+            return { ok: false, index, error: err instanceof UpdateError ? err : new UpdateError(String(err?.message || err)) };
         }
+        events.onDone?.(index, now() - started);
     }
-    else {
-        // Briefly show up to date message
-        process.stdout.write(`  ${palette.ok('✓')} ${palette.muted(`devx is up to date (v${result.currentVersion})`)}\n`);
-        await new Promise(r => setTimeout(r, 450));
-        // Clean up line
-        process.stdout.write('\x1b[1A\x1b[2K');
-    }
+    return { ok: true };
+}
+/** Starts devx again, with the same arguments, and ends this process when the new one ends. */
+export function restartDevx() {
+    const child = spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+    child.on('exit', (code) => process.exit(code ?? 0));
+    child.on('error', () => process.exit(0));
 }

package/dist/core/locales/de.js

@@ -225,6 +225,39 @@ export const de = {
     'onboard.provider.note': 'Der Dienst, der dir die Modelle gibt. Nicht in der Liste? Füge deinen eigenen mit „Anbieter hinzufügen“ hinzu.',
     'onboard.custom': 'Eigene Adresse',
     'onboard.customDetail': 'Jede OpenAI-kompatible Adresse',
+    'update.title': 'Update',
+    'update.titleBusy': 'aktualisiere',
+    'update.titleDone': 'aktualisiert',
+    'update.titleFailed': 'Update fehlgeschlagen',
+    'update.checking': 'Suche nach Updates',
+    'update.upToDate': 'devx ist aktuell ({version})',
+    'update.offline': 'Update-Prüfung nicht möglich ({reason})',
+    'update.available': 'devx {version} ist da',
+    'update.have': 'Du hast {version}',
+    'update.released': 'veröffentlicht am {date}',
+    'update.whatsNew': 'Neu in dieser Version',
+    'update.viaNpm': 'Mit npm installiert: Das Update führt npm install -g termux-dev aus.',
+    'update.viaGit': 'Aus einem Git-Klon installiert: Das Update holt, baut und verlinkt ihn.',
+    'update.now': 'Jetzt aktualisieren',
+    'update.nowDetail': '{version} installieren und devx neu starten',
+    'update.later': 'Später',
+    'update.laterDetail': 'Diese Version vorerst behalten',
+    'update.skip': 'Diese Version überspringen',
+    'update.skipDetail': 'Zu {version} nicht mehr fragen',
+    'update.step.registry': 'Prüfe die Registry',
+    'update.step.install': 'Installiere devx {version}',
+    'update.step.verify': 'Prüfe die neue Version',
+    'update.step.pull': 'Hole von GitHub',
+    'update.step.build': 'Installiere und baue',
+    'update.step.link': 'Verlinke den Befehl',
+    'update.keepOpen': 'Lass devx geöffnet, das dauert einen Moment.',
+    'update.installed': 'devx {version} ist installiert',
+    'update.restarting': 'Starte devx neu…',
+    'update.failedStep': 'Gestoppt bei: {step}',
+    'update.keepsRunning': 'devx läuft weiter auf {version}.',
+    'update.byHand': 'So aktualisierst du von Hand:',
+    'update.notPublished': 'npm hat {version} noch nicht. Versuche es in ein paar Minuten erneut.',
+    'update.skipped': 'Verstanden: keine Fragen mehr zu {version}.',
     'provider.add': 'Anbieter hinzufügen',
     'provider.addDetail': 'Jede OpenAI- oder Anthropic-kompatible Adresse',
     'provider.customTag': 'eigen',

package/dist/core/locales/en.js

@@ -236,6 +236,39 @@ export const en = {
     'onboard.provider.note': 'The service that gives you the models. Not in the list? Add your own with “Add a provider”.',
     'onboard.custom': 'Custom endpoint',
     'onboard.customDetail': 'Any OpenAI-compatible address',
+    'update.title': 'update',
+    'update.titleBusy': 'updating',
+    'update.titleDone': 'updated',
+    'update.titleFailed': 'update failed',
+    'update.checking': 'Checking for updates',
+    'update.upToDate': 'devx is up to date ({version})',
+    'update.offline': 'Could not check for updates ({reason})',
+    'update.available': 'devx {version} is out',
+    'update.have': 'You have {version}',
+    'update.released': 'released {date}',
+    'update.whatsNew': 'What\'s new',
+    'update.viaNpm': 'Installed with npm: the update runs npm install -g termux-dev.',
+    'update.viaGit': 'Installed from a git clone: the update pulls, builds and links it.',
+    'update.now': 'Update now',
+    'update.nowDetail': 'Install {version} and restart devx',
+    'update.later': 'Later',
+    'update.laterDetail': 'Keep this version for now',
+    'update.skip': 'Skip this version',
+    'update.skipDetail': 'Do not ask again about {version}',
+    'update.step.registry': 'Checking the registry',
+    'update.step.install': 'Installing devx {version}',
+    'update.step.verify': 'Checking the new version',
+    'update.step.pull': 'Pulling from GitHub',
+    'update.step.build': 'Installing and building',
+    'update.step.link': 'Linking the command',
+    'update.keepOpen': 'Keep devx open, this takes a moment.',
+    'update.installed': 'devx {version} is installed',
+    'update.restarting': 'Restarting devx…',
+    'update.failedStep': 'Stopped at: {step}',
+    'update.keepsRunning': 'devx keeps running on {version}.',
+    'update.byHand': 'To update by hand:',
+    'update.notPublished': 'npm does not have {version} yet. Try again in a few minutes.',
+    'update.skipped': 'Understood: no more questions about {version}.',
     'provider.add': 'Add a provider',
     'provider.addDetail': 'Any OpenAI or Anthropic compatible address',
     'provider.customTag': 'custom',

package/dist/core/locales/es.js

@@ -225,6 +225,39 @@ export const es = {
     'onboard.provider.note': 'El servicio que te da los modelos. ¿No está en la lista? Añade el tuyo con «Añadir proveedor».',
     'onboard.custom': 'Dirección propia',
     'onboard.customDetail': 'Cualquier dirección compatible con OpenAI',
+    'update.title': 'actualización',
+    'update.titleBusy': 'actualizando',
+    'update.titleDone': 'actualizado',
+    'update.titleFailed': 'la actualización falló',
+    'update.checking': 'Buscando actualizaciones',
+    'update.upToDate': 'devx está al día ({version})',
+    'update.offline': 'No se pudo buscar actualizaciones ({reason})',
+    'update.available': 'Ya está devx {version}',
+    'update.have': 'Tienes {version}',
+    'update.released': 'publicada el {date}',
+    'update.whatsNew': 'Novedades',
+    'update.viaNpm': 'Instalado con npm: la actualización ejecuta npm install -g termux-dev.',
+    'update.viaGit': 'Instalado desde un clon de git: la actualización lo descarga, compila y enlaza.',
+    'update.now': 'Actualizar ahora',
+    'update.nowDetail': 'Instalar {version} y reiniciar devx',
+    'update.later': 'Más tarde',
+    'update.laterDetail': 'Mantener esta versión por ahora',
+    'update.skip': 'Omitir esta versión',
+    'update.skipDetail': 'No volver a preguntar por {version}',
+    'update.step.registry': 'Comprobando el registro',
+    'update.step.install': 'Instalando devx {version}',
+    'update.step.verify': 'Comprobando la nueva versión',
+    'update.step.pull': 'Descargando de GitHub',
+    'update.step.build': 'Instalando y compilando',
+    'update.step.link': 'Enlazando el comando',
+    'update.keepOpen': 'Mantén devx abierto, tarda un momento.',
+    'update.installed': 'devx {version} está instalado',
+    'update.restarting': 'Reiniciando devx…',
+    'update.failedStep': 'Se detuvo en: {step}',
+    'update.keepsRunning': 'devx sigue funcionando en {version}.',
+    'update.byHand': 'Para actualizar a mano:',
+    'update.notPublished': 'npm aún no tiene {version}. Inténtalo de nuevo en unos minutos.',
+    'update.skipped': 'Entendido: no se preguntará más por {version}.',
     'provider.add': 'Añadir proveedor',
     'provider.addDetail': 'Cualquier dirección compatible con OpenAI o Anthropic',
     'provider.customTag': 'propio',

package/dist/core/locales/fr.js

@@ -225,6 +225,39 @@ export const fr = {
     'onboard.provider.note': 'Le service qui vous donne les modèles. Pas dans la liste ? Ajoutez le vôtre avec « Ajouter un fournisseur ».',
     'onboard.custom': 'Adresse personnalisée',
     'onboard.customDetail': 'Toute adresse compatible OpenAI',
+    'update.title': 'mise à jour',
+    'update.titleBusy': 'mise à jour en cours',
+    'update.titleDone': 'mis à jour',
+    'update.titleFailed': 'échec de la mise à jour',
+    'update.checking': 'Recherche de mises à jour',
+    'update.upToDate': 'devx est à jour ({version})',
+    'update.offline': 'Impossible de vérifier les mises à jour ({reason})',
+    'update.available': 'devx {version} est sorti',
+    'update.have': 'Vous avez {version}',
+    'update.released': 'publiée le {date}',
+    'update.whatsNew': 'Nouveautés',
+    'update.viaNpm': 'Installé avec npm : la mise à jour lance npm install -g termux-dev.',
+    'update.viaGit': 'Installé depuis un clone git : la mise à jour le récupère, le compile et le lie.',
+    'update.now': 'Mettre à jour maintenant',
+    'update.nowDetail': 'Installer {version} et redémarrer devx',
+    'update.later': 'Plus tard',
+    'update.laterDetail': 'Garder cette version pour l’instant',
+    'update.skip': 'Ignorer cette version',
+    'update.skipDetail': 'Ne plus demander pour {version}',
+    'update.step.registry': 'Vérification du registre',
+    'update.step.install': 'Installation de devx {version}',
+    'update.step.verify': 'Vérification de la nouvelle version',
+    'update.step.pull': 'Récupération depuis GitHub',
+    'update.step.build': 'Installation et compilation',
+    'update.step.link': 'Liaison de la commande',
+    'update.keepOpen': 'Gardez devx ouvert, cela prend un instant.',
+    'update.installed': 'devx {version} est installé',
+    'update.restarting': 'Redémarrage de devx…',
+    'update.failedStep': 'Arrêté à l’étape : {step}',
+    'update.keepsRunning': 'devx continue de tourner en {version}.',
+    'update.byHand': 'Pour mettre à jour à la main :',
+    'update.notPublished': 'npm n’a pas encore {version}. Réessayez dans quelques minutes.',
+    'update.skipped': 'Compris : plus de questions sur {version}.',
     'provider.add': 'Ajouter un fournisseur',
     'provider.addDetail': 'Toute adresse compatible OpenAI ou Anthropic',
     'provider.customTag': 'perso',

package/dist/core/locales/ja.js

@@ -225,6 +225,39 @@ export const ja = {
     'onboard.provider.note': 'モデルを提供するサービスです。一覧にない場合は「プロバイダを追加」で自分のものを追加できます。',
     'onboard.custom': '独自のアドレス',
     'onboard.customDetail': 'OpenAI 互換の任意のアドレス',
+    'update.title': 'アップデート',
+    'update.titleBusy': '更新中',
+    'update.titleDone': '更新しました',
+    'update.titleFailed': '更新に失敗しました',
+    'update.checking': 'アップデートを確認しています',
+    'update.upToDate': 'devx は最新です（{version}）',
+    'update.offline': 'アップデートを確認できませんでした（{reason}）',
+    'update.available': 'devx {version} が公開されました',
+    'update.have': '現在のバージョンは {version} です',
+    'update.released': '{date} 公開',
+    'update.whatsNew': '新機能',
+    'update.viaNpm': 'npm でインストール済み：更新は npm install -g termux-dev を実行します。',
+    'update.viaGit': 'git クローンからインストール済み：更新は取得・ビルド・リンクを行います。',
+    'update.now': '今すぐ更新',
+    'update.nowDetail': '{version} をインストールして devx を再起動',
+    'update.later': 'あとで',
+    'update.laterDetail': '今回はこのバージョンのままにする',
+    'update.skip': 'このバージョンをスキップ',
+    'update.skipDetail': '{version} について今後は確認しない',
+    'update.step.registry': 'レジストリを確認中',
+    'update.step.install': 'devx {version} をインストール中',
+    'update.step.verify': '新しいバージョンを確認中',
+    'update.step.pull': 'GitHub から取得中',
+    'update.step.build': 'インストールとビルド中',
+    'update.step.link': 'コマンドをリンク中',
+    'update.keepOpen': 'devx を開いたままにしてください。少し時間がかかります。',
+    'update.installed': 'devx {version} をインストールしました',
+    'update.restarting': 'devx を再起動しています…',
+    'update.failedStep': '停止した手順：{step}',
+    'update.keepsRunning': 'devx は {version} のまま動作します。',
+    'update.byHand': '手動で更新するには：',
+    'update.notPublished': 'npm にはまだ {version} がありません。数分後にもう一度お試しください。',
+    'update.skipped': '了解しました：{version} についてはもう確認しません。',
     'provider.add': 'プロバイダを追加',
     'provider.addDetail': 'OpenAI または Anthropic 互換の任意のアドレス',
     'provider.customTag': 'カスタム',

package/dist/core/locales/pt.js

@@ -225,6 +225,39 @@ export const pt = {
     'onboard.provider.note': 'O serviço que fornece os modelos. Não está na lista? Adicione o seu em «Adicionar provedor».',
     'onboard.custom': 'Endereço próprio',
     'onboard.customDetail': 'Qualquer endereço compatível com OpenAI',
+    'update.title': 'atualização',
+    'update.titleBusy': 'atualizando',
+    'update.titleDone': 'atualizado',
+    'update.titleFailed': 'a atualização falhou',
+    'update.checking': 'Procurando atualizações',
+    'update.upToDate': 'o devx está atualizado ({version})',
+    'update.offline': 'Não foi possível procurar atualizações ({reason})',
+    'update.available': 'O devx {version} saiu',
+    'update.have': 'Você tem {version}',
+    'update.released': 'lançada em {date}',
+    'update.whatsNew': 'Novidades',
+    'update.viaNpm': 'Instalado com npm: a atualização executa npm install -g termux-dev.',
+    'update.viaGit': 'Instalado de um clone git: a atualização baixa, compila e vincula.',
+    'update.now': 'Atualizar agora',
+    'update.nowDetail': 'Instalar {version} e reiniciar o devx',
+    'update.later': 'Mais tarde',
+    'update.laterDetail': 'Manter esta versão por enquanto',
+    'update.skip': 'Ignorar esta versão',
+    'update.skipDetail': 'Não perguntar mais sobre {version}',
+    'update.step.registry': 'Verificando o registro',
+    'update.step.install': 'Instalando o devx {version}',
+    'update.step.verify': 'Verificando a nova versão',
+    'update.step.pull': 'Baixando do GitHub',
+    'update.step.build': 'Instalando e compilando',
+    'update.step.link': 'Vinculando o comando',
+    'update.keepOpen': 'Mantenha o devx aberto, leva um instante.',
+    'update.installed': 'o devx {version} está instalado',
+    'update.restarting': 'Reiniciando o devx…',
+    'update.failedStep': 'Parou em: {step}',
+    'update.keepsRunning': 'o devx continua na versão {version}.',
+    'update.byHand': 'Para atualizar manualmente:',
+    'update.notPublished': 'O npm ainda não tem {version}. Tente de novo em alguns minutos.',
+    'update.skipped': 'Entendido: sem mais perguntas sobre {version}.',
     'provider.add': 'Adicionar provedor',
     'provider.addDetail': 'Qualquer endereço compatível com OpenAI ou Anthropic',
     'provider.customTag': 'próprio',

package/dist/core/locales/ru.js

@@ -225,6 +225,39 @@ export const ru = {
     'onboard.provider.note': 'Сервис, который даёт модели. Нет в списке? Добавьте свой через «Добавить провайдера».',
     'onboard.custom': 'Свой адрес',
     'onboard.customDetail': 'Любой адрес, совместимый с OpenAI',
+    'update.title': 'обновление',
+    'update.titleBusy': 'обновляю',
+    'update.titleDone': 'обновлено',
+    'update.titleFailed': 'обновление не удалось',
+    'update.checking': 'Проверяю обновления',
+    'update.upToDate': 'devx последней версии ({version})',
+    'update.offline': 'Не удалось проверить обновления ({reason})',
+    'update.available': 'Вышел devx {version}',
+    'update.have': 'У вас {version}',
+    'update.released': 'выпущена {date}',
+    'update.whatsNew': 'Что нового',
+    'update.viaNpm': 'Установлен через npm: обновление выполнит npm install -g termux-dev.',
+    'update.viaGit': 'Установлен из git-клона: обновление подтянет, соберёт и подключит его.',
+    'update.now': 'Обновить сейчас',
+    'update.nowDetail': 'Установить {version} и перезапустить devx',
+    'update.later': 'Позже',
+    'update.laterDetail': 'Пока оставить эту версию',
+    'update.skip': 'Пропустить эту версию',
+    'update.skipDetail': 'Больше не спрашивать про {version}',
+    'update.step.registry': 'Проверяю реестр',
+    'update.step.install': 'Устанавливаю devx {version}',
+    'update.step.verify': 'Проверяю новую версию',
+    'update.step.pull': 'Забираю с GitHub',
+    'update.step.build': 'Устанавливаю и собираю',
+    'update.step.link': 'Подключаю команду',
+    'update.keepOpen': 'Не закрывайте devx, это займёт немного времени.',
+    'update.installed': 'devx {version} установлен',
+    'update.restarting': 'Перезапускаю devx…',
+    'update.failedStep': 'Остановилось на шаге: {step}',
+    'update.keepsRunning': 'devx продолжает работать на {version}.',
+    'update.byHand': 'Чтобы обновить вручную:',
+    'update.notPublished': 'В npm ещё нет {version}. Попробуйте через пару минут.',
+    'update.skipped': 'Понятно: про {version} больше не спрашиваю.',
     'provider.add': 'Добавить провайдера',
     'provider.addDetail': 'Любой адрес, совместимый с OpenAI или Anthropic',
     'provider.customTag': 'свой',

package/dist/core/locales/uk.js

@@ -225,6 +225,39 @@ export const uk = {
     'onboard.provider.note': 'Сервіс, що дає моделі. Немає в списку? Додайте свій через «Додати провайдера».',
     'onboard.custom': 'Власна адреса',
     'onboard.customDetail': 'Будь-яка адреса, сумісна з OpenAI',
+    'update.title': 'оновлення',
+    'update.titleBusy': 'оновлюю',
+    'update.titleDone': 'оновлено',
+    'update.titleFailed': 'оновлення не вдалося',
+    'update.checking': 'Перевіряю оновлення',
+    'update.upToDate': 'devx останньої версії ({version})',
+    'update.offline': 'Не вдалося перевірити оновлення ({reason})',
+    'update.available': 'Вийшов devx {version}',
+    'update.have': 'У вас {version}',
+    'update.released': 'випущено {date}',
+    'update.whatsNew': 'Що нового',
+    'update.viaNpm': 'Встановлено через npm: оновлення виконає npm install -g termux-dev.',
+    'update.viaGit': 'Встановлено з git-клону: оновлення підтягне, збере й підключить його.',
+    'update.now': 'Оновити зараз',
+    'update.nowDetail': 'Встановити {version} і перезапустити devx',
+    'update.later': 'Пізніше',
+    'update.laterDetail': 'Поки залишити цю версію',
+    'update.skip': 'Пропустити цю версію',
+    'update.skipDetail': 'Більше не питати про {version}',
+    'update.step.registry': 'Перевіряю реєстр',
+    'update.step.install': 'Встановлюю devx {version}',
+    'update.step.verify': 'Перевіряю нову версію',
+    'update.step.pull': 'Забираю з GitHub',
+    'update.step.build': 'Встановлюю і збираю',
+    'update.step.link': 'Підключаю команду',
+    'update.keepOpen': 'Не закривайте devx, це займе трохи часу.',
+    'update.installed': 'devx {version} встановлено',
+    'update.restarting': 'Перезапускаю devx…',
+    'update.failedStep': 'Зупинилося на кроці: {step}',
+    'update.keepsRunning': 'devx продовжує працювати на {version}.',
+    'update.byHand': 'Щоб оновити вручну:',
+    'update.notPublished': 'У npm ще немає {version}. Спробуйте за кілька хвилин.',
+    'update.skipped': 'Зрозуміло: про {version} більше не питаю.',
     'provider.add': 'Додати провайдера',
     'provider.addDetail': 'Будь-яка адреса, сумісна з OpenAI або Anthropic',
     'provider.customTag': 'власний',

package/dist/core/locales/zh.js

@@ -225,6 +225,39 @@ export const zh = {
     'onboard.provider.note': '为你提供模型的服务。不在列表里？用“添加提供商”添加你自己的。',
     'onboard.custom': '自定义地址',
     'onboard.customDetail': '任何兼容 OpenAI 的地址',
+    'update.title': '更新',
+    'update.titleBusy': '正在更新',
+    'update.titleDone': '已更新',
+    'update.titleFailed': '更新失败',
+    'update.checking': '正在检查更新',
+    'update.upToDate': 'devx 已是最新版本（{version}）',
+    'update.offline': '无法检查更新（{reason}）',
+    'update.available': 'devx {version} 已发布',
+    'update.have': '你当前是 {version}',
+    'update.released': '发布于 {date}',
+    'update.whatsNew': '新内容',
+    'update.viaNpm': '通过 npm 安装：更新会执行 npm install -g termux-dev。',
+    'update.viaGit': '从 git 克隆安装：更新会拉取、构建并链接。',
+    'update.now': '立即更新',
+    'update.nowDetail': '安装 {version} 并重启 devx',
+    'update.later': '稍后',
+    'update.laterDetail': '暂时保留此版本',
+    'update.skip': '跳过此版本',
+    'update.skipDetail': '不再询问 {version}',
+    'update.step.registry': '正在检查注册表',
+    'update.step.install': '正在安装 devx {version}',
+    'update.step.verify': '正在检查新版本',
+    'update.step.pull': '正在从 GitHub 拉取',
+    'update.step.build': '正在安装并构建',
+    'update.step.link': '正在链接命令',
+    'update.keepOpen': '请保持 devx 打开，这需要一点时间。',
+    'update.installed': 'devx {version} 已安装',
+    'update.restarting': '正在重启 devx…',
+    'update.failedStep': '停在：{step}',
+    'update.keepsRunning': 'devx 继续运行在 {version}。',
+    'update.byHand': '手动更新：',
+    'update.notPublished': 'npm 上还没有 {version}，请几分钟后再试。',
+    'update.skipped': '明白：不再询问 {version}。',
     'provider.add': '添加提供商',
     'provider.addDetail': '任何兼容 OpenAI 或 Anthropic 的地址',
     'provider.customTag': '自定义',

package/dist/core/types.js

@@ -1 +1 @@
-export const DEVX_VERSION = '1.9.0';
+export const DEVX_VERSION = '1.9.2';

package/package.json

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