dexterm-cli 0.1.1 → 0.1.3

package/dist/packages/cli/src/update.js

@@ -0,0 +1,294 @@
+// task-1397 — `dexterm update` and the quiet startup notice.
+//
+// The check is two anonymous GETs: the npm registry's `latest` for dexterm-cli and GitHub's latest published
+// release of dexterm-xyz/dexterm. Both carry only fixed headers (no version, no OS, no ids, no cookies); nothing
+// about the user or the machine is sent beyond the IP any request has. No telemetry.
+//
+// Startup: a live interactive run reads ~/.dexterm/update-check.json (no network) and shows one toast when a
+// newer version was seen; at most once a day it refreshes that file in the background (never blocks, never in
+// --fixtures/--replay, never with DEXTERM_OFFLINE/CI). Off switches: `dexterm update --off`,
+// DEXTERM_NO_UPDATE_CHECK=1 or NO_UPDATE_NOTIFIER=1. `dexterm update` itself never upgrades anything: it prints
+// the exact command for how this copy was installed (npm, Homebrew, release tarball, git checkout).
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dextermHome } from "./boot-state.js";
+import { VERSION } from "./version.js";
+export const NPM_PACKAGE = 'dexterm-cli';
+export const GITHUB_REPO = 'dexterm-xyz/dexterm';
+export const NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE}/latest`;
+export const GITHUB_LATEST_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+export const RELEASES_URL = `https://github.com/${GITHUB_REPO}/releases`;
+/** Fixed request headers: the same bytes for every user (GitHub's API requires a user-agent). */
+export const REQUEST_HEADERS = Object.freeze({ accept: 'application/json', 'user-agent': 'dexterm' });
+export const CHECK_EVERY_MS = 24 * 60 * 60 * 1000;
+export const REQUEST_TIMEOUT_MS = 4000;
+export const UPDATE_FILE = 'update-check.json';
+export const UPDATE_USAGE = `usage: dexterm update          check npm + GitHub now and print the upgrade command for this install
+       dexterm update --off    turn the once-a-day startup check off (dexterm update still works)
+       dexterm update --on     turn it back on`;
+/** `1.2.3`, `v1.2.3`, `1.2.3-rc.1` → parts; anything else → null (never guessed). */
+export function parseVersion(s) {
+    if (typeof s !== 'string')
+        return null;
+    const m = /^v?(\d{1,6})\.(\d{1,6})\.(\d{1,6})(?:-([0-9A-Za-z.-]{1,64}))?(?:\+[0-9A-Za-z.-]{1,64})?$/.exec(s.trim());
+    if (!m)
+        return null;
+    return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), pre: m[4] ? m[4].split('.') : [] };
+}
+/** Semver precedence: < 0 when a is older than b. Unparseable versions compare equal (no notice on junk). */
+export function compareVersions(a, b) {
+    const x = parseVersion(a), y = parseVersion(b);
+    if (!x || !y)
+        return 0;
+    for (const k of ['major', 'minor', 'patch'])
+        if (x[k] !== y[k])
+            return x[k] - y[k];
+    if (!x.pre.length || !y.pre.length)
+        return y.pre.length - x.pre.length; // a release outranks its prereleases
+    for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+        const p = x.pre[i], q = y.pre[i];
+        if (p === undefined)
+            return -1;
+        if (q === undefined)
+            return 1;
+        const pn = /^\d+$/.test(p), qn = /^\d+$/.test(q);
+        if (pn && qn) {
+            if (Number(p) !== Number(q))
+                return Number(p) - Number(q);
+        }
+        else if (pn !== qn)
+            return pn ? -1 : 1;
+        else if (p !== q)
+            return p < q ? -1 : 1;
+    }
+    return 0;
+}
+const bare = (v) => v.trim().replace(/^v/, '');
+/** This module's real path (symlinks resolved): …/node_modules/dexterm-cli/dist/…, …/Cellar/dexterm/…, or a source tree. */
+export function selfPath() {
+    const p = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/** The source tree's root for a tarball/checkout install (this file is packages/cli/src/update.ts). */
+export function sourceRoot(path = selfPath()) {
+    return resolve(dirname(path), '..', '..', '..');
+}
+export function detectInstall(path = selfPath(), exists = existsSync) {
+    const p = path.replace(/\\/g, '/');
+    if (p.includes(`/node_modules/${NPM_PACKAGE}/`))
+        return 'npm';
+    if (/\/Cellar\/dexterm\/|\/opt\/homebrew\/|\/home\/linuxbrew\/\.linuxbrew\//.test(p))
+        return 'brew';
+    return exists(join(sourceRoot(path), '.git')) ? 'checkout' : 'tarball';
+}
+export const INSTALL_LABEL = {
+    npm: `npm (${NPM_PACKAGE})`, brew: 'Homebrew (dexterm-xyz/dexterm tap)', tarball: 'release tarball (install.sh)', checkout: 'git checkout',
+};
+/** The exact commands that move this install to `latest`. Nothing here is ever run by dexterm. */
+export function upgradeCommands(kind, latest, opts = {}) {
+    const v = bare(latest);
+    if (kind === 'npm')
+        return [`npm i -g ${NPM_PACKAGE}@${v}`];
+    if (kind === 'brew')
+        return ['brew update', 'brew upgrade dexterm'];
+    if (kind === 'checkout')
+        return [`git -C ${shellQuote(opts.root ?? sourceRoot())} pull --ff-only`];
+    const base = `${RELEASES_URL}/download/v${v}`;
+    const file = `dexterm-${v}-src.tar.gz`;
+    const sum = (opts.platform ?? process.platform) === 'darwin' ? 'shasum -a 256 -c' : 'sha256sum -c';
+    return [
+        `curl -fL -O ${base}/${file} -O ${base}/SHA256SUMS`,
+        `grep ' ${file}$' SHA256SUMS | ${sum}`,
+        `tar -xzf ${file} && cd dexterm-${v} && ./install.sh`,
+    ];
+}
+function shellQuote(s) {
+    return /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+}
+async function getJson(fetchFn, url, timeoutMs, cancel) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const res = await fetchFn(url, { headers: { ...REQUEST_HEADERS }, signal: cancel ? AbortSignal.any([cancel, timeout]) : timeout, redirect: 'follow' });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    return res.json();
+}
+function why(e) {
+    const err = e;
+    if (err?.name === 'TimeoutError' || err?.name === 'AbortError')
+        return 'timed out';
+    return String(err?.message ?? e).slice(0, 120);
+}
+/** Ask both sources. Never throws; each side reports its own error. */
+export async function fetchLatest(fetchFn = fetch, timeoutMs = REQUEST_TIMEOUT_MS, cancel) {
+    const npm = getJson(fetchFn, NPM_LATEST_URL, timeoutMs, cancel).then((b) => {
+        const v = b?.version;
+        return parseVersion(v) ? { ok: true, version: bare(v), url: `https://www.npmjs.com/package/${NPM_PACKAGE}` } : { ok: false, error: 'no version in the registry reply' };
+    }, (e) => ({ ok: false, error: why(e) }));
+    const github = getJson(fetchFn, GITHUB_LATEST_URL, timeoutMs, cancel).then((b) => {
+        const r = b;
+        if (r?.draft || r?.prerelease || !parseVersion(r?.tag_name))
+            return { ok: false, error: 'no published release in the reply' };
+        const tag = r.tag_name;
+        return { ok: true, version: bare(tag), url: `${RELEASES_URL}/tag/${tag}` };
+    }, (e) => ({ ok: false, error: why(e) }));
+    return { npm: await npm, github: await github };
+}
+/** The newest stable version either source reported, or null. */
+export function newestOf(r) {
+    let best = null;
+    for (const s of [r.npm, r.github]) {
+        if (!s.ok || parseVersion(s.version)?.pre.length)
+            continue;
+        if (best === null || compareVersions(s.version, best) > 0)
+            best = s.version;
+    }
+    return best;
+}
+/** The version this install's channel can actually move to: npm → the registry; the rest → the GitHub release. */
+export function targetFor(kind, r) {
+    const primary = kind === 'npm' ? r.npm : r.github;
+    return primary.ok ? primary.version : newestOf(r);
+}
+export function updateStatePath(env) {
+    return join(dextermHome(env), UPDATE_FILE);
+}
+export function readUpdateState(env) {
+    try {
+        const j = JSON.parse(readFileSync(updateStatePath(env), 'utf8'));
+        return {
+            enabled: j.enabled !== false,
+            checkedAt: typeof j.checkedAt === 'number' && Number.isFinite(j.checkedAt) ? j.checkedAt : null,
+            latest: typeof j.latest === 'string' && parseVersion(j.latest) ? bare(j.latest) : null,
+        };
+    }
+    catch {
+        return { enabled: true, checkedAt: null, latest: null };
+    }
+}
+export function writeUpdateState(env, s) {
+    const p = updateStatePath(env);
+    mkdirSync(dirname(p), { recursive: true, mode: 0o700 });
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(s, null, 2) + '\n', { mode: 0o600 });
+    renameSync(tmp, p);
+}
+const truthy = (v) => !!v && v !== '0' && v.toLowerCase() !== 'false';
+/** Why the startup check is off, or null when it may run. `dexterm update` itself ignores all but DEXTERM_OFFLINE. */
+export function startupCheckOff(env, s) {
+    if (truthy(env.DEXTERM_NO_UPDATE_CHECK))
+        return 'DEXTERM_NO_UPDATE_CHECK is set';
+    if (truthy(env.NO_UPDATE_NOTIFIER))
+        return 'NO_UPDATE_NOTIFIER is set';
+    if (truthy(env.DEXTERM_OFFLINE))
+        return 'DEXTERM_OFFLINE is set';
+    if (truthy(env.CI))
+        return 'CI is set';
+    if (!s.enabled)
+        return 'turned off with dexterm update --off';
+    return null;
+}
+/** The one-line notice for a cached result, or null. */
+export function noticeFor(current, latest) {
+    if (!latest || parseVersion(latest)?.pre.length || compareVersions(latest, current) <= 0)
+        return null;
+    return `dexterm ${bare(latest)} is available (you have ${bare(current)}) · run dexterm update`;
+}
+/**
+ * Startup: the cached notice now, plus a background refresh when the last check is older than a day.
+ * The caller decides where the notice goes (the interactive loop shows it as a toast after the boot).
+ */
+export function startupCheck(env, opts = {}) {
+    const s = readUpdateState(env);
+    const none = () => { };
+    if (startupCheckOff(env, s))
+        return { notice: null, refresh: null, cancel: none };
+    const current = opts.current ?? VERSION;
+    const now = opts.now ?? Date.now();
+    const notice = noticeFor(current, s.latest);
+    if (s.checkedAt !== null && now - s.checkedAt >= 0 && now - s.checkedAt < CHECK_EVERY_MS)
+        return { notice, refresh: null, cancel: none };
+    const ctl = new AbortController();
+    const refresh = fetchLatest(opts.fetchFn, REQUEST_TIMEOUT_MS, ctl.signal).then((r) => {
+        if (ctl.signal.aborted || (!r.npm.ok && !r.github.ok))
+            return null; // quit / offline / blocked: try again next launch
+        const latest = newestOf(r);
+        try {
+            writeUpdateState(env, { ...s, checkedAt: now, latest });
+        }
+        catch { /* read-only home: no cache */ }
+        // only a notice the cache did not already produce
+        const n = noticeFor(current, latest);
+        return n && n !== notice ? n : null;
+    }).catch(() => null);
+    return { notice, refresh, cancel: () => ctl.abort() };
+}
+export async function updateCommand(argv, io, deps = {}) {
+    const [arg, ...rest] = argv;
+    const env = io.env;
+    if (arg === '-h' || arg === '--help' || arg === 'help') {
+        io.stdout.write(UPDATE_USAGE + '\n');
+        return 0;
+    }
+    if (rest.length || (arg !== undefined && arg !== '--off' && arg !== '--on')) {
+        io.stderr.write(`dexterm update: unknown argument ${JSON.stringify(String(rest[0] ?? arg).slice(0, 20))}\n${UPDATE_USAGE}\n`);
+        return 2;
+    }
+    const state = readUpdateState(env);
+    if (arg === '--off' || arg === '--on') {
+        try {
+            writeUpdateState(env, { ...state, enabled: arg === '--on' });
+        }
+        catch (e) {
+            io.stderr.write(`dexterm update: ${e.message}\n`);
+            return 1;
+        }
+        io.stdout.write(arg === '--off'
+            ? `startup update check: off (saved to ${updateStatePath(env)}). dexterm update still checks when you run it.\n`
+            : `startup update check: on (at most once a day; saved to ${updateStatePath(env)})\n`);
+        return 0;
+    }
+    if (truthy(env.DEXTERM_OFFLINE)) {
+        io.stderr.write('dexterm update: DEXTERM_OFFLINE is set; the check needs the network\n');
+        return 2;
+    }
+    const current = deps.current ?? VERSION;
+    const kind = deps.install ?? detectInstall();
+    const r = await fetchLatest(deps.fetchFn);
+    const line = (label, s) => `  ${label.padEnd(20)} ${s.ok ? `${s.version.padEnd(10)} ${s.url}` : `unavailable (${s.error})`}\n`;
+    io.stdout.write(`dexterm ${current} · installed via ${INSTALL_LABEL[kind]}\n`);
+    io.stdout.write(line(`npm ${NPM_PACKAGE}`, r.npm));
+    io.stdout.write(line('GitHub release', r.github));
+    if (!r.npm.ok && !r.github.ok) {
+        io.stderr.write(`dexterm update: could not reach npm or GitHub; check your connection, or see ${RELEASES_URL}\n`);
+        return 1;
+    }
+    const latest = newestOf(r);
+    try {
+        writeUpdateState(env, { ...state, checkedAt: deps.now ?? Date.now(), latest });
+    }
+    catch { /* read-only home */ }
+    const target = targetFor(kind, r);
+    if (!target || compareVersions(target, current) <= 0) {
+        const ahead = latest && compareVersions(latest, current) > 0;
+        io.stdout.write(ahead
+            ? `You are on the newest version ${kind === 'npm' ? 'npm has' : 'the GitHub release has'} (${current}); ${latest} is out on the other channel and reaches yours shortly.\n`
+            : `You are up to date (${current}).\n`);
+    }
+    else {
+        io.stdout.write(`\ndexterm ${target} is available. Upgrade with:\n\n`);
+        for (const c of upgradeCommands(kind, target, { platform: deps.platform, root: deps.root }))
+            io.stdout.write(`  ${c}\n`);
+        io.stdout.write('\n');
+        if (kind === 'tarball')
+            io.stdout.write(`Verify the download first: ${RELEASES_URL}/tag/v${target} (docs/verify-your-download.md). Release notes: CHANGELOG.md.\n`);
+    }
+    const off = startupCheckOff(env, readUpdateState(env));
+    io.stdout.write(`startup check: ${off ? `off (${off})` : 'on, at most once a day; dexterm update --off or DEXTERM_NO_UPDATE_CHECK=1 turns it off'}. No telemetry: two anonymous GETs (registry.npmjs.org, api.github.com).\n`);
+    return 0;
+}

package/dist/packages/cli/src/version.js

@@ -0,0 +1,3 @@
+// The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
+// cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
+export const VERSION = '0.1.3';

package/dist/packages/cli/src/voice-cmd.js

@@ -0,0 +1,194 @@
+// `dexterm voice …` (task-1408, task-1416): inspect the voice engines on this machine, download the two
+// optional voice models — whisper.cpp base.en (speech-in) and the Piper en_GB-alan-medium voice (neural
+// speech-out) — and SET UP the managed neural voice on macOS. Network use is OFF by default: this is the
+// only place dexterm fetches a model or installs a runtime, it asks before it does, and it verifies the
+// voice model against a pinned checksum from the official source. Nothing here runs the signer, touches
+// keys, or changes trading behaviour.
+//
+// No new dependencies: the confirm prompt is node:readline, downloads use global fetch, `voice setup`
+// shells out to the system python/pip, and the checksum/stream/venv logic lives in @dexterm/voice.
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { modelRegistry, downloadModel, modelStatus, resolvePiperBin, pickPlayer, PIPER_MODEL, DEFAULT_PIPER_VOICE, setupPiperRuntime, uninstallPiperRuntime, piperRuntimeStatus, } from '../../voice/src/index.js';
+import { dextermHome } from '../../custom/src/index.js';
+export const VOICE_USAGE = [
+    'usage:',
+    '  dexterm voice [status]                 show the voice engines + which models are installed',
+    '  dexterm voice setup [--yes]            set up the neural voice (Piper) on this machine (asks first)',
+    '  dexterm voice uninstall [--purge-model] remove the managed neural-voice runtime',
+    '  dexterm voice download <model> [--yes] download a voice model (asks first; checksum-verified)',
+    '',
+    '  models: whisper        whisper.cpp base.en  (speech-to-text, off macOS this is the default)',
+    '          piper-voice    Piper en_GB-alan-medium (neural speech-out, the default speaking voice)',
+    '          all            both of the above',
+].join('\n');
+/** Run a command, capture its output, and resolve a RunResult (never rejects). Used by `voice setup`. */
+function runCmd(cmd, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (e) {
+            resolve({ code: 127, stdout: '', stderr: e.message });
+            return;
+        }
+        let stdout = '', stderr = '';
+        child.stdout?.on('data', (d) => { stdout += d; });
+        child.stderr?.on('data', (d) => { stderr += d; });
+        child.on('error', (e) => resolve({ code: 127, stdout, stderr: stderr || e.message }));
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+}
+function onPath(bin, env) {
+    const sep = process.platform === 'win32' ? ';' : ':';
+    for (const p of (env.PATH ?? '').split(sep)) {
+        if (p && existsSync(join(p, bin)))
+            return true;
+    }
+    return false;
+}
+/** y/N prompt on a TTY. Without a TTY (piped/CI) it returns false — the caller tells the user to pass --yes. */
+function askYesNo(io, question) {
+    if (!io.stdin.isTTY)
+        return Promise.resolve(false);
+    const rl = createInterface({ input: io.stdin, output: io.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${question} [y/N] `, (ans) => { rl.close(); resolve(/^y(es)?$/i.test(ans.trim())); });
+    });
+}
+async function printStatus(io) {
+    const home = dextermHome(io.env);
+    const reg = modelRegistry(home);
+    const lines = ['dexterm voice', ''];
+    if (process.platform === 'darwin') {
+        const rt = await piperRuntimeStatus(home);
+        const player = pickPlayer();
+        const piperReady = rt.installed && player !== null;
+        if (piperReady) {
+            lines.push(`  speech-out  Piper ready (${DEFAULT_PIPER_VOICE}, neural, plays via ${player}) · fallback: macOS \`say\``);
+        }
+        else if (rt.pythonPresent || rt.modelInstalled) {
+            lines.push(`  speech-out  Piper partly set up (${rt.pythonPresent ? 'runtime ok' : 'no runtime'}, ${rt.modelInstalled ? 'model ok' : 'no model'}) — finish with \`dexterm voice setup\` · now using macOS \`say\``);
+        }
+        else {
+            lines.push('  speech-out  macOS `say` (built-in) · neural voice: run `dexterm voice setup` · see `dexterm doctor` for the resolved voice');
+        }
+        lines.push('  speech-in   Apple Speech (swiftc) preferred, else whisper.cpp');
+    }
+    else {
+        const piperBin = resolvePiperBin();
+        const player = pickPlayer();
+        const piperReady = piperBin !== null && existsSync(PIPER_MODEL) && player !== null;
+        lines.push(`  speech-out  Piper ${piperReady ? `ready (${DEFAULT_PIPER_VOICE}, plays via ${player})` : 'not ready'}${piperReady ? '' : ` · espeak-ng ${onPath('espeak-ng', io.env) || onPath('espeak', io.env) ? 'ready (baseline)' : 'not installed'}`}`);
+        lines.push(`  speech-in   whisper.cpp (default off macOS) · mic tool ${['arecord', 'sox', 'rec', 'ffmpeg'].find((b) => onPath(b, io.env)) ?? 'none found'}`);
+    }
+    lines.push('', '  models:');
+    for (const spec of Object.values(reg)) {
+        const st = await modelStatus(spec);
+        lines.push(`    ${st.installed ? '✓' : '·'} ${spec.id.padEnd(12)} ${spec.label}${st.installed ? ' (installed)' : ''}`);
+    }
+    lines.push('', `  download a model: dexterm voice download <whisper|piper-voice|all>`);
+    io.stdout.write(lines.join('\n') + '\n');
+    return 0;
+}
+async function runDownload(io, which, yes) {
+    const home = dextermHome(io.env);
+    const reg = modelRegistry(home);
+    const ids = which === 'all' ? Object.keys(reg) : [which];
+    const specs = [];
+    for (const id of ids) {
+        const spec = reg[id];
+        if (!spec) {
+            io.stderr.write(`dexterm voice: unknown model ${JSON.stringify(id)}\n${VOICE_USAGE}\n`);
+            return 2;
+        }
+        specs.push(spec);
+    }
+    if (!yes && !io.stdin.isTTY) {
+        io.stderr.write('dexterm voice download: no interactive terminal to confirm; re-run with --yes to approve the download.\n');
+        return 2;
+    }
+    let anyFailed = false;
+    for (const spec of specs) {
+        try {
+            const res = await downloadModel(spec, {
+                confirm: (prompt) => (yes ? Promise.resolve(true) : askYesNo(io, `\n${prompt}`)),
+                log: (s) => io.stdout.write(s + '\n'),
+            });
+            if (res.status === 'cancelled')
+                return 1; // the user said no — stop here
+        }
+        catch (e) {
+            io.stderr.write(`dexterm voice download ${spec.id}: ${e.message}\n`);
+            anyFailed = true;
+        }
+    }
+    return anyFailed ? 1 : 0;
+}
+/** `dexterm voice setup`: build the managed neural-voice runtime (venv + model) on this machine. */
+async function runSetup(io, yes) {
+    const home = dextermHome(io.env);
+    if (!yes && !io.stdin.isTTY) {
+        io.stderr.write('dexterm voice setup: no interactive terminal to confirm; re-run with --yes to approve the setup.\n');
+        return 2;
+    }
+    // Let the user point setup at a specific interpreter (e.g. a pyenv/homebrew python) via DEXTERM_PYTHON.
+    const candidates = io.env.DEXTERM_PYTHON ? [io.env.DEXTERM_PYTHON] : undefined;
+    const res = await setupPiperRuntime({
+        home,
+        run: runCmd,
+        confirm: (prompt) => (yes ? Promise.resolve(true) : askYesNo(io, `\n${prompt}`)),
+        log: (s) => io.stdout.write(s + '\n'),
+        pythonCandidates: candidates,
+    });
+    if (res.status === 'ok' || res.status === 'already')
+        return 0;
+    if (res.status === 'cancelled')
+        return 1;
+    // no-python / failed: print the exact fix line.
+    io.stderr.write(`dexterm voice setup: ${res.status === 'no-python' ? 'no suitable Python 3 found' : 'setup failed'}.\n`);
+    if (res.fix)
+        io.stderr.write(`  fix: ${res.fix}\n`);
+    return 1;
+}
+/** `dexterm voice uninstall`: remove the managed neural-voice runtime. */
+async function runUninstall(io, purgeModel) {
+    const home = dextermHome(io.env);
+    const res = await uninstallPiperRuntime(home, { purgeModel });
+    if (res.status === 'absent') {
+        io.stdout.write('No managed neural-voice runtime to remove.\n');
+        return 0;
+    }
+    io.stdout.write(`Removed the managed neural-voice runtime${purgeModel ? ' and voice model' : ' (voice model kept — remove with --purge-model)'}.\n`);
+    return 0;
+}
+/** `dexterm voice …`. Returns the process exit code. */
+export async function voiceCommand(argv, io) {
+    const yes = argv.includes('--yes') || argv.includes('-y');
+    const purgeModel = argv.includes('--purge-model');
+    const rest = argv.filter((a) => a !== '--yes' && a !== '-y' && a !== '--purge-model');
+    const sub = rest[0];
+    if (sub === undefined || sub === 'status')
+        return printStatus(io);
+    if (sub === 'setup')
+        return runSetup(io, yes);
+    if (sub === 'uninstall' || sub === 'remove')
+        return runUninstall(io, purgeModel);
+    if (sub === 'download') {
+        const which = rest[1];
+        if (!which) {
+            io.stderr.write(`dexterm voice download: name a model.\n${VOICE_USAGE}\n`);
+            return 2;
+        }
+        return runDownload(io, which, yes);
+    }
+    if (sub === '--help' || sub === '-h' || sub === 'help') {
+        io.stdout.write(VOICE_USAGE + '\n');
+        return 0;
+    }
+    io.stderr.write(`dexterm voice: unknown subcommand ${JSON.stringify(sub)}\n${VOICE_USAGE}\n`);
+    return 2;
+}

package/dist/packages/cli/src/voice-hud.js

@@ -28,7 +28,7 @@ export function renderVoiceHud(c, v, t) {
     else {
         // idle but enabled: a quiet "ready" badge with the key hints.
         x = c.text(x, y, ' ◎ voice ', { fg: t.borderFocus, bg, b: true });
-        x = c.text(x, y, `v talk · m ${v.muted ? 'unmute' : 'mute'} · , voice${voiceName}`, { fg: t.muted, bg });
+        x = c.text(x, y, `v talk · m ${v.muted ? 'unmute' : 'mute'} · , voice · < > rate${voiceName}`, { fg: t.muted, bg });
     }
     if (mute && v.mode !== 'off')
         x = c.text(x, y, mute, { fg: t.warn, bg, b: true });