termux-dev 1.8.2 → 1.9.1

package/dist/cli/ui.js

@@ -36,9 +36,12 @@ export const palette = {
     accent: (s) => tokens().accent(s),
     bold: (s) => (colorOn() ? `\x1b[1m${s}\x1b[22m` : s),
 };
-export function resolveMode(planMode, yolo) {
+/** `extra` is YOLO without the safety net (nothing is asked); it only counts while YOLO is on. */
+export function resolveMode(planMode, yolo, extra = false) {
     if (planMode)
         return 'plan';
+    if (yolo && extra)
+        return 'extra';
     return yolo ? 'yolo' : 'agent';
 }
 export function modeStyle(mode) {
@@ -47,6 +50,8 @@ export function modeStyle(mode) {
             return { label: 'plan', glyph: '◆', color: palette.plan };
         case 'yolo':
             return { label: 'yolo', glyph: '▲', color: palette.yolo };
+        case 'extra':
+            return { label: 'extra', glyph: '▲', color: palette.err };
         default:
             return { label: 'agent', glyph: '●', color: palette.accent };
     }
@@ -136,7 +141,7 @@ function brand(version) {
 }
 export function renderHeader(info, cols) {
     const W = contentWidth(cols);
-    const modePill = info.yolo ? palette.yolo(palette.bold('▲ auto-approve')) : '';
+    const modePill = info.extra ? palette.err(palette.bold('▲ extra: nothing asked')) : info.yolo ? palette.yolo(palette.bold('▲ auto-approve')) : '';
     const branch = info.branch
         ? `${palette.faint('git:')}${palette.muted(info.branch)}${info.dirty ? palette.warn('*') : ''}`
         : '';
@@ -146,7 +151,7 @@ export function renderHeader(info, cols) {
         const limit = Math.max(8, cols - 1);
         const room = Math.max(6, cols - 3);
         const titleOptions = info.yolo
-            ? [`${brand(info.version)}  ${modePill}`, `${brand(info.version)}  ${palette.yolo('▲ yolo')}`, `${brand(info.version)} ${palette.yolo('▲')}`, brand(info.version)]
+            ? [`${brand(info.version)}  ${modePill}`, `${brand(info.version)}  ${info.extra ? palette.err('▲ extra') : palette.yolo('▲ yolo')}`, `${brand(info.version)} ${info.extra ? palette.err('▲') : palette.yolo('▲')}`, brand(info.version)]
             : [brand(info.version)];
         lines.push(titleOptions.find((t) => displayWidth(t) <= limit) ?? truncateWidth(stripAnsi(brand(info.version)), limit));
         lines.push(`  ${palette.text(truncateWidth(info.model, room))}`);
@@ -258,6 +263,8 @@ export function inputCells(cols) {
     const W = frameWidth(cols);
     return Math.max(4, isCompact(cols) ? W - 4 : W - 6);
 }
+/** Control characters but the line break (`\n` is a real break in the input, it is laid out, not shown). */
+const CONTROL_EXCEPT_NEWLINE = /[\x00-\x09\x0b-\x1f\x7f]/g;
 /** Rows the input may take before it scrolls: a quarter of the terminal, at most 8. */
 export function maxInputRows(termRows = process.stdout.rows || 24) {
     return Math.max(1, Math.min(8, Math.floor(termRows / 4)));
@@ -291,7 +298,14 @@ export function wrapInput(input, cells) {
         const start = i;
         let used = 0;
         let afterSpace = -1;
+        let hardBreak = false;
         while (i < cps.length) {
+            // A line break ends the row; it stays at the end of that row, so the cursor behind it is on the next one.
+            if (cps[i] === '\n') {
+                i++;
+                hardBreak = true;
+                break;
+            }
             let next = atoms.get(i) ?? i + 1;
             let w = widths.slice(i, next).reduce((a, b) => a + b, 0);
             if (next > i + 1 && w > cells) {
@@ -305,12 +319,17 @@ export function wrapInput(input, cells) {
             if (cps[i - 1] === ' ')
                 afterSpace = i;
         }
-        if (i < cps.length && cps[i] !== ' ' && afterSpace > start)
-            i = afterSpace; // break between words
-        if (i === start)
-            i = start + 1; // a cell wider than the row
+        if (!hardBreak) {
+            if (i < cps.length && cps[i] !== ' ' && afterSpace > start)
+                i = afterSpace; // break between words
+            if (i === start)
+                i = start + 1; // a cell wider than the row
+        }
         rows.push({ start, end: i });
     }
+    // Text that ends with a line break: the cursor waits on a new, empty row.
+    if (cps[cps.length - 1] === '\n')
+        rows.push({ start: cps.length, end: cps.length });
     return rows;
 }
 function layoutInput(input, cursorPos, cells) {
@@ -335,7 +354,7 @@ function layoutInput(input, cursorPos, cells) {
  * (the arrow keys then walk the prompt history as before). Returns a UTF-16 index.
  */
 export function moveCursorRow(input, cursorPos, cols, dir) {
-    const clean = input.replace(/[\x00-\x1f\x7f]/g, ' ');
+    const clean = input.replace(CONTROL_EXCEPT_NEWLINE, ' ');
     const { cps, rows, widths, cursorRow, cursorCell } = layoutInput(clean, cursorPos, inputCells(cols));
     const target = rows[cursorRow + dir];
     if (!target)
@@ -358,7 +377,7 @@ function inputRows(f, cells) {
     const { cps, rows, cursorRow, cursorCell } = layoutInput(f.input, f.cursorPos, cells);
     const limit = f.maxInputRows ?? maxInputRows();
     const firstRow = rows.length <= limit ? 0 : Math.max(0, Math.min(cursorRow - limit + 1, rows.length - limit));
-    const shown = rows.slice(firstRow, firstRow + limit).map((r) => formatBadges(cps.slice(r.start, r.end).join('')));
+    const shown = rows.slice(firstRow, firstRow + limit).map((r) => formatBadges(cps.slice(r.start, r.end).join('').replace(/\n$/, '')));
     return { rows: shown, firstRow, cursorRow: cursorRow - firstRow, cursorCol: cursorCell };
 }
 function keyHints(cols, mode) {
@@ -398,8 +417,9 @@ export function fitModelLabel(label, max) {
 }
 export function buildPromptFrame(input) {
     // Control characters would move the cursor and tear the frame apart. They are shown as
-    // spaces; one character stays one character, so cursor positions keep matching.
-    const f = { ...input, input: input.input.replace(/[\x00-\x1f\x7f]/g, ' ') };
+    // spaces; one character stays one character, so cursor positions keep matching. A line break
+    // is kept: it starts a new row of the input.
+    const f = { ...input, input: input.input.replace(CONTROL_EXCEPT_NEWLINE, ' ') };
     if (isCompact(f.cols))
         return buildCompactFrame(f);
     const W = frameWidth(f.cols);
@@ -997,7 +1017,7 @@ export function easeToward(current, target, dtMs, tauMs = 400) {
     return current + distance * (1 - Math.exp(-dtMs / tauMs));
 }
 /**
- * The working line:  `  ⠹ Read src/x.ts  (12s · ↓ 364 tokens · ctrl+c to stop)`.
+ * The working line:  `  ⠹ Read src/x.ts  (12s · ↓ 364 tokens · esc to stop)`.
  * On a narrow screen the details are dropped step by step, the label is cut last.
  */
 export function renderStatusLine({ label: rawLabel, elapsedMs, meta = '', frame, columns }) {
@@ -1026,7 +1046,7 @@ export function renderStatusLine({ label: rawLabel, elapsedMs, meta = '', frame,
     return `  ${glyph} ${palette.text(text)}${' '.repeat(GAP)}${suffix}`;
 }
 /**
- * Animated "working" line:  `  ⠹ Read src/x.ts  (12s · 1.2k tok · ctrl+c to stop)`.
+ * Animated "working" line:  `  ⠹ Read src/x.ts  (12s · 1.2k tok · esc to stop)`.
  * Same start / message / stop API as the clack spinner it replaces.
  */
 let activeSpinner = null;

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