termux-dev 1.8.0 → 1.8.2

package/dist/core/background.js

@@ -0,0 +1,376 @@
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { StringDecoder } from 'string_decoder';
+export const MAX_BACKGROUND_TASKS = 8;
+/** What is kept of the output of one task; older text is dropped. */
+export const MAX_BUFFER = 200_000;
+/** The most a single read gives back to the model. */
+export const MAX_READ_CHARS = 8000;
+const MAX_NOTES_PER_TASK = 12;
+const NOTE_TAIL_CHARS = 1500;
+const MATCH_DEBOUNCE_MS = 400;
+/** Strips colour codes and carriage-return redraws so the model reads text, not terminal noise. */
+export function cleanOutput(text) {
+    return text
+        .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+        .replace(/[^\n]*\r(?!\n)/g, '')
+        .replace(/\r/g, '');
+}
+function compileRegex(source) {
+    if (!source)
+        return undefined;
+    try {
+        return new RegExp(source, 'i');
+    }
+    catch {
+        throw new Error(`Invalid regular expression: ${source}`);
+    }
+}
+export function formatDuration(ms) {
+    const s = Math.max(0, Math.round(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+    return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+}
+export class BackgroundManager extends EventEmitter {
+    tasks = new Map();
+    counter = 0;
+    notes = [];
+    // ───────────────────────── starting and stopping ─────────────────────────
+    start(command, options = {}) {
+        if (!command || !command.trim())
+            throw new Error('command is required');
+        if (this.running().length >= MAX_BACKGROUND_TASKS) {
+            throw new Error(`Too many background tasks running (${MAX_BACKGROUND_TASKS}). Stop one first (action "stop").`);
+        }
+        const watch = compileRegex(options.notifyOn);
+        this.installExitHook();
+        const isWin = process.platform === 'win32';
+        const cwd = options.cwd || process.cwd();
+        const proc = spawn(command, { shell: true, cwd, detached: !isWin, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const id = `bg${++this.counter}`;
+        const info = {
+            id,
+            label: (options.label || command).replace(/\s+/g, ' ').trim().slice(0, 60),
+            command,
+            cwd,
+            pid: proc.pid,
+            status: 'running',
+            code: null,
+            startedAt: Date.now(),
+            outputChars: 0,
+            watching: options.notifyOn || undefined,
+        };
+        let finish;
+        const done = new Promise((resolve) => { finish = resolve; });
+        const task = {
+            info, proc, buffer: '', trimmed: 0, readCursor: 0, scanFrom: 0, pendingLine: '', watch,
+            notes: 0, matchedLines: [], stopRequested: false, timedOut: false, done,
+        };
+        this.tasks.set(id, task);
+        const decoders = { out: new StringDecoder('utf8'), err: new StringDecoder('utf8') };
+        proc.stdout.on('data', (d) => this.append(task, decoders.out.write(d)));
+        proc.stderr.on('data', (d) => this.append(task, decoders.err.write(d)));
+        let ended = false;
+        const end = (status, code) => {
+            if (ended)
+                return;
+            ended = true;
+            this.append(task, decoders.out.end() + decoders.err.end());
+            this.flushPendingLine(task);
+            clearTimeout(task.killTimer);
+            clearTimeout(task.runtimeTimer);
+            info.status = task.stopRequested ? 'stopped' : status;
+            info.code = code;
+            info.endedAt = Date.now();
+            this.flushMatches(task);
+            // A task the model stopped itself needs no note; anything else does.
+            if (!task.stopRequested || task.timedOut)
+                this.addNote(task, 'exit', this.exitNote(task));
+            this.emit('change', this.snapshot(task));
+            finish();
+        };
+        proc.on('error', () => end('failed', null));
+        proc.on('close', (code) => end(code === 0 ? 'exited' : 'failed', code));
+        // A child that got away can keep the pipes open for good: do not wait for them for long.
+        proc.on('exit', (code) => {
+            setTimeout(() => {
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+                end(code === 0 ? 'exited' : 'failed', code);
+            }, 400).unref();
+        });
+        if (options.maxRuntimeSeconds && options.maxRuntimeSeconds > 0) {
+            task.runtimeTimer = setTimeout(() => { task.timedOut = true; void this.stop(id); }, options.maxRuntimeSeconds * 1000);
+            task.runtimeTimer.unref();
+        }
+        this.emit('change', this.snapshot(task));
+        return this.snapshot(task);
+    }
+    /** Stops a task (SIGTERM, then SIGKILL after a second). Resolves when it is gone. */
+    async stop(id) {
+        const task = this.must(id);
+        if (task.info.status !== 'running')
+            return this.snapshot(task);
+        task.stopRequested = true;
+        this.killTree(task, false);
+        task.killTimer = setTimeout(() => this.killTree(task, true), 1000);
+        task.killTimer.unref();
+        await Promise.race([task.done, new Promise((r) => setTimeout(r, 2500).unref())]);
+        return this.snapshot(task);
+    }
+    async stopAll() {
+        const running = this.running();
+        await Promise.all(running.map((t) => this.stop(t.id).catch(() => null)));
+        return running.length;
+    }
+    /** Forgets finished tasks (their output is gone with them). */
+    clearFinished() {
+        let n = 0;
+        for (const [id, task] of this.tasks) {
+            if (task.info.status !== 'running') {
+                this.tasks.delete(id);
+                n++;
+            }
+        }
+        if (n)
+            this.emit('change');
+        return n;
+    }
+    // ───────────────────────── looking at tasks ─────────────────────────
+    list() {
+        return [...this.tasks.values()].map((t) => this.snapshot(t));
+    }
+    running() {
+        return this.list().filter((t) => t.status === 'running');
+    }
+    get(id) {
+        const task = this.tasks.get(id);
+        return task ? this.snapshot(task) : undefined;
+    }
+    /** The output of a task as text for the model or the screen. */
+    read(id, options = {}) {
+        const task = this.must(id);
+        const grep = compileRegex(options.grep);
+        let from;
+        if (options.mode === 'tail')
+            from = task.trimmed;
+        else
+            from = Math.max(task.readCursor, task.trimmed);
+        let text = task.buffer.slice(from - task.trimmed);
+        if (options.mode !== 'tail')
+            task.readCursor = task.trimmed + task.buffer.length;
+        let lines = cleanOutput(text).split('\n');
+        if (lines.length && lines[lines.length - 1] === '')
+            lines.pop();
+        if (grep)
+            lines = lines.filter((l) => grep.test(l));
+        const want = Math.max(1, Math.min(Math.floor(options.lines ?? (options.mode === 'tail' ? 40 : 200)), 1000));
+        let omitted = 0;
+        if (lines.length > want) {
+            omitted = lines.length - want;
+            lines = lines.slice(-want);
+        }
+        text = lines.join('\n');
+        if (text.length > MAX_READ_CHARS) {
+            omitted += text.slice(0, text.length - MAX_READ_CHARS).split('\n').length - 1;
+            text = text.slice(-MAX_READ_CHARS).replace(/^[^\n]*\n/, '');
+        }
+        return { text, omitted };
+    }
+    /**
+     * Waits until the task ends, a line matches `pattern`, the time is up or the turn is cancelled.
+     * Lines the model has already read do not count; lines it has not read yet do.
+     */
+    wait(id, options = {}) {
+        const task = this.must(id);
+        const pattern = compileRegex(options.pattern);
+        const timeoutMs = Math.min(Math.max(options.timeoutSeconds ?? 60, 1), 600) * 1000;
+        return new Promise((resolve) => {
+            let timer;
+            // Output nobody has read yet counts: a line that came while the model was busy elsewhere is not lost.
+            let scan = Math.max(task.readCursor, task.trimmed);
+            const finish = (result) => {
+                clearTimeout(timer);
+                options.signal?.removeEventListener('abort', onAbort);
+                this.removeListener(`data:${id}`, onData);
+                resolve(result);
+            };
+            const onAbort = () => finish({ reason: 'aborted' });
+            const onClose = () => finish({ reason: 'exit' });
+            void task.done.then(onClose);
+            const onData = () => {
+                if (!pattern)
+                    return;
+                const start = Math.max(scan, task.trimmed);
+                const chunk = cleanOutput(task.buffer.slice(start - task.trimmed));
+                const lastNl = chunk.lastIndexOf('\n');
+                if (lastNl < 0)
+                    return;
+                scan = start + lastNl + 1;
+                const hit = chunk.slice(0, lastNl).split('\n').find((l) => pattern.test(l));
+                if (hit !== undefined)
+                    finish({ reason: 'match', line: hit.trim() });
+            };
+            if (task.info.status !== 'running')
+                return resolve({ reason: 'exit' });
+            if (options.signal?.aborted)
+                return resolve({ reason: 'aborted' });
+            timer = setTimeout(() => finish({ reason: 'timeout' }), timeoutMs);
+            options.signal?.addEventListener('abort', onAbort, { once: true });
+            this.on(`data:${id}`, onData);
+            onData();
+        });
+    }
+    // ───────────────────────── notes for the model ─────────────────────────
+    hasNotes() {
+        return this.notes.length > 0;
+    }
+    /** The notes since the last call, as one message for the model (or '' when there are none). */
+    takeNotes() {
+        if (this.notes.length === 0)
+            return '';
+        const text = this.notes.map((n) => n.text).join('\n\n');
+        this.notes = [];
+        return `[devx · background tasks]\n${text}`;
+    }
+    // ───────────────────────── internals ─────────────────────────
+    must(id) {
+        const task = this.tasks.get(String(id));
+        if (!task) {
+            const known = [...this.tasks.keys()].join(', ');
+            throw new Error(`No background task "${id}"${known ? ` (known: ${known})` : ' (none started)'}`);
+        }
+        return task;
+    }
+    snapshot(task) {
+        return { ...task.info, outputChars: task.trimmed + task.buffer.length };
+    }
+    append(task, text) {
+        if (!text)
+            return;
+        task.buffer += text;
+        if (task.buffer.length > MAX_BUFFER * 1.5) {
+            const cut = task.buffer.length - MAX_BUFFER;
+            task.buffer = task.buffer.slice(cut);
+            task.trimmed += cut;
+        }
+        if (task.watch)
+            this.scanLines(task, text);
+        this.emit(`data:${task.info.id}`);
+        this.emit('output', task.info.id);
+    }
+    scanLines(task, text) {
+        const parts = cleanOutput(task.pendingLine + text).split('\n');
+        task.pendingLine = parts.pop() ?? '';
+        for (const line of parts) {
+            if (task.watch.test(line))
+                this.matched(task, line);
+        }
+    }
+    flushPendingLine(task) {
+        if (task.watch && task.pendingLine && task.watch.test(task.pendingLine))
+            this.matched(task, task.pendingLine);
+        task.pendingLine = '';
+    }
+    matched(task, line) {
+        task.matchedLines.push(line.trim().slice(0, 300));
+        if (task.matchedLines.length > 20)
+            task.matchedLines.shift();
+        clearTimeout(task.matchTimer);
+        task.matchTimer = setTimeout(() => this.flushMatches(task), MATCH_DEBOUNCE_MS);
+        task.matchTimer.unref();
+    }
+    flushMatches(task) {
+        clearTimeout(task.matchTimer);
+        if (task.matchedLines.length === 0)
+            return;
+        const lines = task.matchedLines.splice(0);
+        const shown = lines.slice(-5).map((l) => `  ${l}`).join('\n');
+        this.addNote(task, 'match', {
+            summary: `${task.info.id} · ${lines[lines.length - 1]}`,
+            text: `${task.info.id} "${task.info.label}" printed ${lines.length} line${lines.length === 1 ? '' : 's'} matching /${task.info.watching}/:\n${shown}`,
+        });
+    }
+    exitNote(task) {
+        const { id, label, code, startedAt, endedAt } = task.info;
+        const how = task.timedOut ? 'was stopped: its time limit ran out' : code === 0 ? 'finished (exit code 0)' : code === null ? 'stopped unexpectedly' : `failed (exit code ${code})`;
+        const after = formatDuration((endedAt ?? Date.now()) - startedAt);
+        const tail = this.tailForNote(task);
+        return {
+            summary: `${id} ${code === 0 ? 'finished' : code === null ? 'stopped' : `failed · exit ${code}`} · ${after}`,
+            text: `${id} "${label}" ${how} after ${after}.${tail ? `\nLast output:\n${tail}` : ''}`,
+        };
+    }
+    tailForNote(task) {
+        const text = cleanOutput(task.buffer).trimEnd();
+        return text.length > NOTE_TAIL_CHARS ? '…' + text.slice(-NOTE_TAIL_CHARS).replace(/^[^\n]*\n/, '') : text;
+    }
+    addNote(task, kind, body) {
+        task.notes++;
+        // A chatty watcher must not flood the conversation: after a dozen notes only the end is reported.
+        if (kind === 'match' && task.notes > MAX_NOTES_PER_TASK)
+            return;
+        const note = { taskId: task.info.id, kind, ...body };
+        this.notes.push(note);
+        this.emit('note', note);
+    }
+    killTree(task, force) {
+        const pid = task.proc.pid;
+        if (!pid || task.info.status !== 'running')
+            return;
+        if (process.platform === 'win32') {
+            const killer = spawn('taskkill', ['/pid', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+            killer.on('error', () => task.proc.kill());
+            return;
+        }
+        try {
+            process.kill(-pid, force ? 'SIGKILL' : 'SIGTERM');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                try {
+                    task.proc.kill(force ? 'SIGKILL' : 'SIGTERM');
+                }
+                catch { }
+            }
+        }
+    }
+    /** Nothing started by devx may outlive it. */
+    installExitHook() {
+        liveManagers.add(this);
+        if (exitHookInstalled)
+            return;
+        exitHookInstalled = true;
+        process.on('exit', () => {
+            for (const manager of liveManagers)
+                manager.killAllNow();
+        });
+    }
+    /** Synchronous: used when the process is exiting. */
+    killAllNow() {
+        for (const task of this.tasks.values()) {
+            if (task.info.status === 'running')
+                this.killTree(task, true);
+        }
+    }
+}
+const liveManagers = new Set();
+let exitHookInstalled = false;
+let instance = null;
+export function getBackgroundManager() {
+    if (!instance) {
+        instance = new BackgroundManager();
+        instance.setMaxListeners(50);
+    }
+    return instance;
+}
+/** For tests: a fresh manager. */
+export function resetBackgroundManager() {
+    void instance?.stopAll();
+    instance = null;
+}

package/dist/core/config-merge.js

@@ -0,0 +1,67 @@
+/**
+ * Saving the user's config when several devx processes run at once.
+ *
+ * Every process keeps its own copy of ~/.devxrc.json in memory. Writing that copy back whole would
+ * let the process that saves last overwrite what the others changed meanwhile (theme, API keys,
+ * "Always" permissions, the default model...). So a save writes only what THIS process changed
+ * since it last looked at the file (`base` -> `mine`) on top of what is on disk now (`disk`).
+ */
+const isPlain = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+function isPrimitiveList(v) {
+    return Array.isArray(v) && v.every((x) => x === null || ['string', 'number', 'boolean'].includes(typeof x));
+}
+/** Structural equality for JSON-like values. */
+export function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameValue(x, b[i]));
+    if (isPlain(a) && isPlain(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        for (const k of keys)
+            if (!sameValue(a[k], b[k]))
+                return false;
+        return true;
+    }
+    return false;
+}
+/** A deep copy that is safe to keep as a baseline. */
+export function cloneConfig(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+/**
+ * `disk` with the changes that `base` -> `mine` made applied to it.
+ *  - a value that did not change is left as it is on disk (another process may have changed it);
+ *  - objects (apiKeys, trustedProjects...) are merged key by key;
+ *  - lists of plain values (the bash allowlist) get what this process added and lose what it removed.
+ */
+export function mergeConfigChanges(base, mine, disk) {
+    const result = { ...disk };
+    const keys = new Set([...Object.keys(base), ...Object.keys(mine)]);
+    for (const key of keys) {
+        const b = base[key];
+        const m = mine[key];
+        if (sameValue(b, m))
+            continue;
+        if (m === undefined) {
+            delete result[key];
+        }
+        else if (isPlain(m) && (b === undefined || isPlain(b)) && (disk[key] === undefined || isPlain(disk[key]))) {
+            result[key] = mergeConfigChanges(isPlain(b) ? b : {}, m, isPlain(disk[key]) ? disk[key] : {});
+        }
+        else if (isPrimitiveList(m) && (b === undefined || isPrimitiveList(b)) && (disk[key] === undefined || isPrimitiveList(disk[key]))) {
+            const old = b ?? [];
+            const now = m;
+            const added = now.filter((x) => !old.includes(x));
+            const removed = old.filter((x) => !now.includes(x));
+            // Emptying a list ("/permissions clear") really empties it.
+            result[key] = m.length === 0
+                ? []
+                : [...new Set([...(disk[key] ?? []).filter((x) => !removed.includes(x)), ...added])];
+        }
+        else {
+            result[key] = m;
+        }
+    }
+    return result;
+}

package/dist/core/i18n.js

@@ -15,8 +15,8 @@ export const LANGUAGES = [
     { id: 'es', name: 'Español' },
     { id: 'fr', name: 'Français' },
     { id: 'pt', name: 'Português' },
-    { id: 'zh', name: '中文' },
-    { id: 'ja', name: '日本語' },
+    { id: 'zh', name: 'Chinese' },
+    { id: 'ja', name: 'Japanese' },
 ];
 export const LANGUAGE_IDS = LANGUAGES.map((l) => l.id);
 export const DEFAULT_LANGUAGE = 'en';

package/dist/core/locales/de.js

@@ -207,4 +207,59 @@ export const de = {
     'rewind.filesNo': 'Nein, nur das Gespräch',
     'rewind.done': 'Zurück bei deiner Nachricht. Was danach kam, ist weg, auch für das Modell. Ändere die Nachricht und sende sie.',
     'rewind.doneImages': 'Zurück bei deiner Nachricht (ihre Bilder blieben nicht erhalten, hänge sie erneut an). Was danach kam, ist weg, auch für das Modell.',
+    // ── first run and the prompts around it
+    'welcome.tagline': 'Ein KI-Coding-Agent für das Terminal',
+    'welcome.intro': 'Richten wir alles ein. Das dauert etwa eine Minute.',
+    'welcome.step.language': 'Sprache',
+    'welcome.step.provider': 'Anbieter',
+    'welcome.step.key': 'API-Schlüssel',
+    'welcome.step.model': 'Modell',
+    'welcome.keyNote': 'Dein Schlüssel bleibt auf diesem Computer, in ~/.devxrc.json.',
+    'onboard.language.title': 'sprache',
+    'onboard.language.note': 'Du kannst sie später in /settings ändern.',
+    'onboard.provider.title': 'anbieter',
+    'onboard.provider.placeholder': 'tippen, um einen Anbieter zu finden',
+    'onboard.provider.note': 'Der Dienst, der dir die Modelle liefert. Nicht in der Liste? Wähle eigene Adresse.',
+    'onboard.custom': 'Eigene Adresse',
+    'onboard.customDetail': 'Jede OpenAI-kompatible Adresse',
+    'onboard.baseUrl.title': 'adresse',
+    'onboard.baseUrl.label': 'Basis-URL der API',
+    'onboard.baseUrl.placeholder': 'https://api.example.com/v1',
+    'onboard.key.title': 'api-schlüssel',
+    'onboard.key.label': 'Füge deinen API-Schlüssel für {provider} ein',
+    'onboard.key.note': 'Die Eingabe bleibt verborgen. Esc geht zurück.',
+    'onboard.key.useSaved': 'Gespeicherten Schlüssel verwenden',
+    'onboard.key.enterNew': 'Neuen Schlüssel eingeben',
+    'onboard.key.savedTitle': 'für {provider} ist ein Schlüssel gespeichert',
+    'onboard.model.title': 'modell',
+    'onboard.model.placeholder': 'tippen, um ein Modell zu finden',
+    'onboard.model.custom': 'Modellnamen eingeben',
+    'onboard.model.customDetail': 'Jede Modell-ID',
+    'onboard.model.label': 'Name des Modells (zum Beispiel gpt-4o)',
+    'onboard.model.fetching': 'Modellliste wird geladen...',
+    'onboard.model.manual': 'Die Modellliste konnte nicht geladen werden, gib den Modellnamen ein.',
+    'onboard.model.context': '{n} Kontext',
+    'onboard.model.anthropic': 'Anthropic-Format',
+    'onboard.back': 'Zurück',
+    'onboard.back.detail': 'Aktuelle Einstellung behalten',
+    'onboard.done': 'Fertig. Deine Auswahl ist in ~/.devxrc.json gespeichert.',
+    'finder.placeholder': 'tippen zum Filtern',
+    'finder.empty': 'Keine Treffer',
+    'finder.hint.filter': 'filtern',
+    'picker.hint.move': 'bewegen',
+    'picker.hint.select': 'wählen',
+    'picker.hint.cancel': 'abbrechen',
+    'picker.hint.confirm': 'bestätigen',
+    'welcome.step.theme': 'Design',
+    'onboard.theme.title': 'design',
+    'onboard.theme.note': 'Die Farben der Oberfläche. Mit /theme jederzeit änderbar.',
+    'resume.title': 'fortsetzen',
+    'resume.placeholder': 'tippen, um Sitzungen zu filtern',
+    'resume.msgs': '{n} Nachr.',
+    'sessions.deleteTitle': 'Sitzungen löschen',
+    'sessions.deleteAll': 'Alle {n} Sitzungen löschen',
+    'commands.title': 'Befehle',
+    'commands.placeholder': 'tippen, um einen Befehl zu finden',
+    'compact.done': 'Kontext verdichtet, Zusammenfassung behalten',
+    'compact.summary': 'was das Modell geschrieben hat',
 };

package/dist/core/locales/en.js

@@ -218,4 +218,59 @@ export const en = {
     'rewind.filesNo': 'No, only the conversation',
     'rewind.done': 'Back at your message. What came after it is gone, for the model too. Edit the message and send it.',
     'rewind.doneImages': 'Back at your message (its images were not kept, attach them again). What came after it is gone, for the model too.',
+    // ── first run and the prompts around it
+    'welcome.tagline': 'A terminal AI coding agent',
+    'welcome.intro': 'Let us set things up. It takes about a minute.',
+    'welcome.step.language': 'Language',
+    'welcome.step.provider': 'Provider',
+    'welcome.step.key': 'API key',
+    'welcome.step.model': 'Model',
+    'welcome.keyNote': 'Your key stays on this computer, in ~/.devxrc.json.',
+    'onboard.language.title': 'language',
+    'onboard.language.note': 'You can change it later in /settings.',
+    'onboard.provider.title': 'provider',
+    'onboard.provider.placeholder': 'type to find a provider',
+    'onboard.provider.note': 'The service that gives you the models. Not in the list? Choose Custom endpoint.',
+    'onboard.custom': 'Custom endpoint',
+    'onboard.customDetail': 'Any OpenAI-compatible address',
+    'onboard.baseUrl.title': 'address',
+    'onboard.baseUrl.label': 'Base URL of the API',
+    'onboard.baseUrl.placeholder': 'https://api.example.com/v1',
+    'onboard.key.title': 'api key',
+    'onboard.key.label': 'Paste your API key for {provider}',
+    'onboard.key.note': 'What you type is hidden. Esc goes back.',
+    'onboard.key.useSaved': 'Use the saved key',
+    'onboard.key.enterNew': 'Enter a new key',
+    'onboard.key.savedTitle': 'a key is saved for {provider}',
+    'onboard.model.title': 'model',
+    'onboard.model.placeholder': 'type to find a model',
+    'onboard.model.custom': 'Type a model name',
+    'onboard.model.customDetail': 'Any model id',
+    'onboard.model.label': 'Name of the model (for example gpt-4o)',
+    'onboard.model.fetching': 'Fetching the list of models...',
+    'onboard.model.manual': 'The list of models could not be fetched, so type the name of the model.',
+    'onboard.model.context': '{n} context',
+    'onboard.model.anthropic': 'Anthropic format',
+    'onboard.back': 'Back',
+    'onboard.back.detail': 'Keep what is set now',
+    'onboard.done': 'All set. Your choices are saved in ~/.devxrc.json.',
+    'finder.placeholder': 'type to filter',
+    'finder.empty': 'Nothing matches',
+    'finder.hint.filter': 'filter',
+    'picker.hint.move': 'move',
+    'picker.hint.select': 'select',
+    'picker.hint.cancel': 'cancel',
+    'picker.hint.confirm': 'confirm',
+    'welcome.step.theme': 'Theme',
+    'onboard.theme.title': 'theme',
+    'onboard.theme.note': 'The colours of the interface. Change them any time with /theme.',
+    'resume.title': 'resume',
+    'resume.placeholder': 'type to filter sessions',
+    'resume.msgs': '{n} msgs',
+    'sessions.deleteTitle': 'delete sessions',
+    'sessions.deleteAll': 'Delete all {n} sessions',
+    'commands.title': 'commands',
+    'commands.placeholder': 'type to find a command',
+    'compact.done': 'Context compacted, summary kept',
+    'compact.summary': 'what the model wrote',
 };

package/dist/core/locales/es.js

@@ -207,4 +207,59 @@ export const es = {
     'rewind.filesNo': 'No, solo la conversación',
     'rewind.done': 'De vuelta en tu mensaje. Lo que vino después desapareció, también para el modelo. Edita el mensaje y envíalo.',
     'rewind.doneImages': 'De vuelta en tu mensaje (sus imágenes no se conservaron, adjúntalas de nuevo). Lo que vino después desapareció, también para el modelo.',
+    // ── first run and the prompts around it
+    'welcome.tagline': 'Un agente de programación con IA para la terminal',
+    'welcome.intro': 'Vamos a configurarlo todo. Lleva cerca de un minuto.',
+    'welcome.step.language': 'Idioma',
+    'welcome.step.provider': 'Proveedor',
+    'welcome.step.key': 'Clave de API',
+    'welcome.step.model': 'Modelo',
+    'welcome.keyNote': 'Tu clave se queda en este equipo, en ~/.devxrc.json.',
+    'onboard.language.title': 'idioma',
+    'onboard.language.note': 'Puedes cambiarlo más tarde en /settings.',
+    'onboard.provider.title': 'proveedor',
+    'onboard.provider.placeholder': 'escribe para buscar un proveedor',
+    'onboard.provider.note': 'El servicio que te da los modelos. ¿No está en la lista? Elige Dirección propia.',
+    'onboard.custom': 'Dirección propia',
+    'onboard.customDetail': 'Cualquier dirección compatible con OpenAI',
+    'onboard.baseUrl.title': 'dirección',
+    'onboard.baseUrl.label': 'URL base de la API',
+    'onboard.baseUrl.placeholder': 'https://api.example.com/v1',
+    'onboard.key.title': 'clave de api',
+    'onboard.key.label': 'Pega tu clave de API para {provider}',
+    'onboard.key.note': 'Lo que escribes está oculto. Esc vuelve atrás.',
+    'onboard.key.useSaved': 'Usar la clave guardada',
+    'onboard.key.enterNew': 'Introducir una clave nueva',
+    'onboard.key.savedTitle': 'hay una clave guardada para {provider}',
+    'onboard.model.title': 'modelo',
+    'onboard.model.placeholder': 'escribe para buscar un modelo',
+    'onboard.model.custom': 'Escribir el nombre de un modelo',
+    'onboard.model.customDetail': 'Cualquier id de modelo',
+    'onboard.model.label': 'Nombre del modelo (por ejemplo gpt-4o)',
+    'onboard.model.fetching': 'Obteniendo la lista de modelos...',
+    'onboard.model.manual': 'No se pudo obtener la lista de modelos, escribe el nombre del modelo.',
+    'onboard.model.context': 'contexto de {n}',
+    'onboard.model.anthropic': 'formato Anthropic',
+    'onboard.back': 'Atrás',
+    'onboard.back.detail': 'Mantener lo actual',
+    'onboard.done': 'Listo. Tu elección está guardada en ~/.devxrc.json.',
+    'finder.placeholder': 'escribe para filtrar',
+    'finder.empty': 'Nada coincide',
+    'finder.hint.filter': 'filtrar',
+    'picker.hint.move': 'mover',
+    'picker.hint.select': 'elegir',
+    'picker.hint.cancel': 'cancelar',
+    'picker.hint.confirm': 'confirmar',
+    'welcome.step.theme': 'Tema',
+    'onboard.theme.title': 'tema',
+    'onboard.theme.note': 'Los colores de la interfaz. Puedes cambiarlos cuando quieras con /theme.',
+    'resume.title': 'reanudar',
+    'resume.placeholder': 'escribe para filtrar sesiones',
+    'resume.msgs': '{n} msjs',
+    'sessions.deleteTitle': 'borrar sesiones',
+    'sessions.deleteAll': 'Borrar las {n} sesiones',
+    'commands.title': 'comandos',
+    'commands.placeholder': 'escribe para buscar un comando',
+    'compact.done': 'Contexto compactado, resumen guardado',
+    'compact.summary': 'lo que escribió el modelo',
 };