@vascend/talos 0.1.0

package/dist/tui/image-attachments.js

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, resolve } from "node:path";
+import { isImageDataUri, isImagePath, parseImageDataUri, unquotePath } from "./images.js";
+import { IMAGE_REF } from "./attachment-refs.js";
+// MIME del media dedotto dall'estensione (fallback png). Allineato ai formati
+// immagine supportati dai provider.
+const MIME_BY_EXT = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+// Riconosce se una stringa incollata e' un riferimento a un'immagine allegabile:
+// data URI immagine, oppure path a un file immagine ESISTENTE sul disco.
+export function detectImageSource(raw, cwd) {
+    const s = raw.trim();
+    if (!s)
+        return null;
+    if (isImageDataUri(s)) {
+        const parsed = parseImageDataUri(s);
+        return parsed ? { kind: "data", bytes: parsed.bytes, mime: parsed.mime } : null;
+    }
+    const candidate = unquotePath(s);
+    // Una sola "parola" plausibile come path (niente spazi a meno che fosse quotato).
+    if (!isImagePath(candidate))
+        return null;
+    const abs = isAbsolute(candidate) ? candidate : resolve(cwd, candidate);
+    try {
+        if (existsSync(abs) && statSync(abs).isFile())
+            return { kind: "file", path: abs };
+    }
+    catch {
+        // permessi/path non valido: non e' un allegato
+    }
+    return null;
+}
+export class ImageRegistry {
+    items = [];
+    seq = 0;
+    // Aggiunge un file immagine. Ritorna l'allegato (con ref "img #N").
+    addFile(path, label) {
+        const index = ++this.seq;
+        const att = {
+            index,
+            ref: `[Image #${index}]`,
+            kind: "file",
+            path,
+            label: label || basename(path),
+        };
+        this.items.push(att);
+        return att;
+    }
+    // Aggiunge byte da data URI. Ritorna l'allegato (con ref "img #N").
+    addData(bytes, mime, label) {
+        const index = ++this.seq;
+        const att = {
+            index,
+            ref: `[Image #${index}]`,
+            kind: "data",
+            bytes,
+            mime,
+            label: label || "incollata",
+        };
+        this.items.push(att);
+        return att;
+    }
+    // Registra una sorgente gia' rilevata (detectImageSource).
+    add(src) {
+        return src.kind === "file" ? this.addFile(src.path) : this.addData(src.bytes, src.mime);
+    }
+    get(index) {
+        return this.items.find((a) => a.index === index);
+    }
+    // Risolve un riferimento testuale "img #N" (case-insensitive, spazi opzionali).
+    resolveRef(ref) {
+        const m = new RegExp(IMAGE_REF, "i").exec(ref);
+        return m ? this.get(Number(m[1])) : undefined;
+    }
+    all() {
+        return this.items;
+    }
+    // Costruisce le parti immagine (ImagePart, base64 inline) per tutti i ref
+    // "img #N" PRESENTI nel testo e RISOLVIBILI in questo registro. I byte dei
+    // file vengono riletti dal disco; le immagini incollate hanno gia' i byte.
+    // Non inviare il solo segnaposto quando un allegato non e' piu' disponibile.
+    imagePartsFor(text, opts = {}) {
+        const maxTotal = opts.maxTotalBytes ?? 16 * 1024 * 1024;
+        const parts = [];
+        const seen = new Set();
+        let used = 0;
+        for (const idx of findImageRefs(text)) {
+            if (seen.has(idx))
+                continue;
+            seen.add(idx);
+            const att = this.get(idx);
+            if (!att)
+                throw new Error(`Allegato img #${idx} non disponibile in questa chat. Incolla nuovamente l'immagine.`);
+            let bytes;
+            let mime = att.mime;
+            if (att.kind === "data") {
+                bytes = att.bytes;
+            }
+            else if (att.path) {
+                try {
+                    bytes = readFileSync(att.path);
+                }
+                catch {
+                    throw new Error(`Allegato ${att.ref} non leggibile. Il file potrebbe essere stato spostato: incolla nuovamente l'immagine.`);
+                }
+                mime = mime || MIME_BY_EXT[extname(att.path).toLowerCase()] || "image/png";
+            }
+            if (!bytes || !bytes.length)
+                throw new Error(`Allegato ${att.ref} vuoto. Incolla nuovamente l'immagine.`);
+            if (used + bytes.length > maxTotal)
+                throw new Error(`Allegati oltre il limite di ${Math.round(maxTotal / 1024 / 1024)} MB. Riduci le dimensioni o invia meno immagini insieme.`);
+            used += bytes.length;
+            parts.push({
+                type: "image",
+                data: bytes.toString("base64"),
+                mime: mime || "image/png",
+                source: att.ref,
+            });
+        }
+        return parts;
+    }
+    get count() {
+        return this.items.length;
+    }
+    // Nuova/ripresa sessione: i riferimenti img #N non devono attraversare il
+    // confine e allegare accidentalmente byte della conversazione precedente.
+    clear() {
+        this.items.length = 0;
+        this.seq = 0;
+    }
+}
+function basename(p) {
+    const parts = p.split(/[\\/]/);
+    return parts[parts.length - 1] || p;
+}
+// Trova tutti i riferimenti "img #N" presenti in un testo (per l'anteprima).
+export function findImageRefs(text) {
+    const out = [];
+    const re = new RegExp(IMAGE_REF, "gi");
+    let m;
+    while ((m = re.exec(text)) !== null)
+        out.push(Number(m[1]));
+    return out;
+}
+// Span di un token "img #N" che TOCCA la posizione del cursore (1 char a
+// sinistra, come per il backspace). Ritorna {start, end, index} se il cursore
+// e' all'interno o subito dopo un token, altrimenti null. Serve per la
+// cancellazione ATOMICA: cancellando un carattere del token, sparisce tutto il
+// riferimento (l'allegato si scollega), stile Claude Code.
+export function imageTokenSpanAt(text, cursor) {
+    const re = new RegExp(IMAGE_REF, "gi");
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const start = m.index;
+        const end = m.index + m[0].length;
+        // Il backspace agisce sul carattere a sinistra del cursore: il token e'
+        // "toccato" se il cursore cade dentro (start, end] -> cancelliamo tutto.
+        if (cursor > start && cursor <= end)
+            return { start, end, index: Number(m[1]) };
+    }
+    return null;
+}

package/dist/tui/images.d.ts

@@ -0,0 +1,12 @@
+export type ImageSupport = "kitty" | "iterm" | "none";
+export declare function imageSupport(env: NodeJS.ProcessEnv): ImageSupport;
+export declare function isImagePath(path: string): boolean;
+export declare function isImageDataUri(s: string): boolean;
+export declare function parseImageDataUri(s: string): {
+    bytes: Buffer;
+    mime: string;
+} | null;
+export declare function unquotePath(s: string): string;
+export declare function encodeImage(bytes: Buffer, support: ImageSupport): string;
+export declare function renderImageFile(absPath: string, env: NodeJS.ProcessEnv): string | null;
+export declare function renderImageBytes(bytes: Buffer, env: NodeJS.ProcessEnv): string | null;

package/dist/tui/images.js

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import { extname } from "node:path";
+// Rileva il supporto grafico dall'ambiente del terminale.
+export function imageSupport(env) {
+    if (env["TERM"] === "xterm-kitty" || env["KITTY_WINDOW_ID"])
+        return "kitty";
+    const prog = env["TERM_PROGRAM"];
+    // iTerm2 e Warp implementano il protocollo immagini di iTerm2.
+    if (prog === "iTerm.app" || prog === "WarpTerminal" || env["LC_TERMINAL"] === "iTerm2")
+        return "iterm";
+    return "none";
+}
+const IMAGE_EXT = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
+export function isImagePath(path) {
+    return IMAGE_EXT.has(extname(path).toLowerCase());
+}
+// Data URI immagine (es. "data:image/png;base64,iVBOR..."): alcuni terminali e
+// strumenti incollano l'immagine cosi'. Rilevato per estrarre il mime.
+const DATA_URI_RE = /^data:image\/([a-z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/i;
+export function isImageDataUri(s) {
+    return DATA_URI_RE.test(s.trim());
+}
+// Estrae bytes + mime da un data URI immagine, o null se non valido.
+export function parseImageDataUri(s) {
+    const m = DATA_URI_RE.exec(s.trim());
+    if (!m)
+        return null;
+    try {
+        const bytes = Buffer.from(m[2].replace(/\s+/g, ""), "base64");
+        if (bytes.length === 0)
+            return null;
+        return { bytes, mime: `image/${m[1].toLowerCase()}` };
+    }
+    catch {
+        return null;
+    }
+}
+// Toglie eventuali apici/virgolette attorno a un path incollato (i file manager
+// spesso copiano il path quotato, es. "C:\foto\img.png" o 'foto.png').
+export function unquotePath(s) {
+    const t = s.trim();
+    if (t.length >= 2 && ((t[0] === '"' && t.at(-1) === '"') || (t[0] === "'" && t.at(-1) === "'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+// Codifica i byte immagine nella sequenza di escape del protocollo.
+export function encodeImage(bytes, support) {
+    if (support === "iterm") {
+        const b64 = bytes.toString("base64");
+        return `\x1b]1337;File=inline=1;size=${bytes.length}:${b64}\x07`;
+    }
+    if (support === "kitty") {
+        const b64 = bytes.toString("base64");
+        const chunkSize = 4096;
+        let out = "";
+        for (let i = 0; i < b64.length; i += chunkSize) {
+            const chunk = b64.slice(i, i + chunkSize);
+            const more = i + chunkSize < b64.length ? 1 : 0;
+            // f=100: PNG/auto; a=T: trasmetti e mostra; m: continua se ci sono altri chunk.
+            const ctrl = i === 0 ? `a=T,f=100,m=${more}` : `m=${more}`;
+            out += `\x1b_G${ctrl};${chunk}\x1b\\`;
+        }
+        return out;
+    }
+    return "";
+}
+// Rende un file immagine come sequenza inline, o null se non supportato/illeggibile.
+export function renderImageFile(absPath, env) {
+    const support = imageSupport(env);
+    if (support === "none")
+        return null;
+    try {
+        return encodeImage(readFileSync(absPath), support);
+    }
+    catch {
+        return null;
+    }
+}
+// Rende byte immagine gia' in memoria (es. da un data URI) come sequenza inline,
+// o null se il terminale non supporta grafica.
+export function renderImageBytes(bytes, env) {
+    const support = imageSupport(env);
+    if (support === "none")
+        return null;
+    return encodeImage(bytes, support) || null;
+}

package/dist/tui/intro.d.ts

@@ -0,0 +1,13 @@
+import type { PiConfig } from "../core/config.js";
+import type { ThemeSpec } from "./theme.js";
+import type { StartupMeta } from "./branding.js";
+export interface IntroOptions {
+    readonly columns?: number;
+    readonly write: (s: string) => void;
+    readonly replaceTail?: (lines: readonly string[], count: number) => void;
+    readonly animate?: boolean;
+    readonly durationMs?: number;
+    readonly fps?: number;
+    readonly sweeps?: number;
+}
+export declare function playIntro(config: PiConfig, meta: StartupMeta, opts: IntroOptions, spec?: ThemeSpec): Promise<void>;

package/dist/tui/intro.js

@@ -0,0 +1,109 @@
+import { frostSilver, fgRgb, renderStartup, renderStartupLines } from "./branding.js";
+const RESET = "\x1b[0m";
+// Converte una riga ANSI del banner in celle, leggendo l'intensita' dal colore
+// SGR attivo a ogni carattere.
+function toCells(line) {
+    const cells = [];
+    let i = 0;
+    let intensity = 0.62;
+    while (i < line.length) {
+        if (line[i] === "\x1b" && line[i + 1] === "[") {
+            const end = line.indexOf("m", i);
+            if (end !== -1) {
+                intensity = intensityFromSgr(line.slice(i + 2, end), intensity);
+                i = end + 1;
+                continue;
+            }
+        }
+        const ch = line[i] ?? " ";
+        cells.push({ ch, base: ch === " " ? 0 : intensity });
+        i += 1;
+    }
+    return cells;
+}
+// Stima l'intensita' (0..1) da una sequenza SGR (truecolor -> luminanza; reset
+// -> default; dim -> basso).
+function intensityFromSgr(body, current) {
+    const parts = body.split(";").map((p) => Number(p));
+    if (body === "" || parts[0] === 0)
+        return 0.62;
+    if (parts[0] === 2)
+        return 0.4;
+    const idx = parts.indexOf(38);
+    if (idx !== -1 && parts[idx + 1] === 2) {
+        const r = parts[idx + 2] ?? 200;
+        const g = parts[idx + 3] ?? 200;
+        const b = parts[idx + 4] ?? 200;
+        const lum = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+        return Math.max(0.25, Math.min(1, lum));
+    }
+    return current;
+}
+// Disegna un frame: ogni cella usa l'argento-gelido al livello dato
+// dall'intensita' base modulata da un'onda di luce diagonale (sweep) che si
+// muove con `phase`. `settle` (0->1) attenua il riflesso verso lo stato fisso.
+function paintFrame(grid, width, phase, settle) {
+    const lines = [];
+    const height = grid.length;
+    const denom = width + height * 0.6 || 1;
+    for (let y = 0; y < height; y += 1) {
+        const row = grid[y] ?? [];
+        let out = "";
+        let lastEsc = "";
+        for (let x = 0; x < row.length; x += 1) {
+            const cell = row[x];
+            if (cell.ch === " " || cell.base <= 0) {
+                out += " ";
+                lastEsc = "";
+                continue;
+            }
+            const diag = (x + y * 0.6) / denom;
+            const d = diag - phase;
+            const glow = Math.exp(-(d * d) / 0.012);
+            const lift = glow * (0.45 + 0.55 * (1 - settle));
+            const t = Math.min(1, cell.base * (0.72 + 0.28 * settle) + lift * (1 - cell.base * 0.4));
+            const esc = fgRgb(frostSilver(t));
+            out += esc === lastEsc ? cell.ch : esc + cell.ch;
+            lastEsc = esc;
+        }
+        lines.push(out + RESET);
+    }
+    return lines;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Riproduce l'intro animata "argento gelido". Senza replaceTail o con
+// animate=false scrive il banner statico. Con animazione: scrive il blocco una
+// volta, poi ne aggiorna le righe frame per frame fino allo stato fisso.
+export async function playIntro(config, meta, opts, spec) {
+    const columns = opts.columns ?? 100;
+    const lines = renderStartupLines(config, meta, { columns }, spec);
+    const grid = lines.map((l) => toCells(l));
+    const width = Math.max(1, ...grid.map((row) => row.length));
+    const count = lines.length;
+    if (opts.animate === false || !opts.replaceTail) {
+        opts.write(renderStartup(config, meta, { columns }, spec));
+        return;
+    }
+    const fps = Math.max(12, Math.min(60, opts.fps ?? 28));
+    const duration = Math.max(300, opts.durationMs ?? 850);
+    const sweeps = Math.max(1, opts.sweeps ?? 2);
+    const frameMs = 1000 / fps;
+    const totalFrames = Math.max(1, Math.round(duration / frameMs));
+    // Primo frame (riflesso fuori scena) per riservare le righe nel log.
+    opts.write(paintFrame(grid, width, -0.3, 0).join("\n") + "\n");
+    for (let f = 1; f <= totalFrames; f += 1) {
+        const p = f / totalFrames;
+        const phase = ((p * sweeps) % 1) * 1.4 - 0.2;
+        const settle = Math.min(1, Math.max(0, (p - 0.55) / 0.45));
+        opts.replaceTail(paintFrame(grid, width, phase, settle), count);
+        await sleep(frameMs);
+    }
+    // Stato finale: le righe ORIGINALI del banner, non un frame ridipinto.
+    // paintFrame emette solo colori di foreground: sui mezzi-blocchi del logo
+    // (che usano coppie fg+bg per il dettaglio) il ridisegno perdeva meta' dei
+    // pixel e il logo restava "bucato", diverso da quello dell'avvio dev di
+    // Horizon. Il riflesso e' l'effetto; il banner vero e' lo stato stabile.
+    opts.replaceTail([...lines], count);
+}

package/dist/tui/language-preference.d.ts

@@ -0,0 +1,6 @@
+import { type Language, type LanguagePreference } from "./locales.js";
+import { type StatoOnboarding } from "./onboarding.js";
+export declare function languagePreference(state: StatoOnboarding, env: NodeJS.ProcessEnv): LanguagePreference;
+export declare function initializeLanguage(env: NodeJS.ProcessEnv): Language;
+export declare function saveLanguagePreference(env: NodeJS.ProcessEnv, preference: LanguagePreference): boolean;
+export declare function onboardingLanguage(state: StatoOnboarding, env: NodeJS.ProcessEnv): StatoOnboarding;

package/dist/tui/language-preference.js

@@ -0,0 +1,24 @@
+import { getLanguage, setLanguage, systemLanguage } from "./i18n.js";
+import { normalizePreference } from "./locales.js";
+import { leggiOnboarding, salvaOnboarding } from "./onboarding.js";
+export function languagePreference(state, env) {
+    return normalizePreference(env["TALOS_LANGUAGE"]) ?? state.languagePreference ?? state.lingua ?? "system";
+}
+export function initializeLanguage(env) {
+    const preference = languagePreference(leggiOnboarding(env), env);
+    const language = preference === "system" ? systemLanguage(env) : preference;
+    setLanguage(language);
+    return language;
+}
+export function saveLanguagePreference(env, preference) {
+    const language = preference === "system" ? systemLanguage(env) : preference;
+    if (!salvaOnboarding(env, { ...leggiOnboarding(env), lingua: language, languagePreference: preference }))
+        return false;
+    setLanguage(language);
+    return true;
+}
+// Persisting terms must retain automatic system selection, rather than turn
+// the currently detected language into a permanent explicit preference.
+export function onboardingLanguage(state, env) {
+    return { ...state, lingua: getLanguage(), languagePreference: languagePreference(state, env) };
+}

package/dist/tui/live-output.d.ts

@@ -0,0 +1,2 @@
+export declare function livePreview(value: string, cells: number): string;
+export declare function liveResultSummary(output: string, summary: string | null, columns: number): string;

package/dist/tui/live-output.js

@@ -0,0 +1,18 @@
+import { exceedsTerminalWidth, fitLine, oneLine, plainText, terminalWidth } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+// Una riga di log deve restare una riga anche con input multilinea o ANSI
+// esterno. Il dato originale resta nel ReviewStore, non in questa anteprima.
+export function livePreview(value, cells) {
+    return fitLine(oneLine(value), Math.max(0, cells));
+}
+export function liveResultSummary(output, summary, columns) {
+    const rows = plainText(output).trim().split("\n");
+    const first = summary ?? rows.find(row => row.trim()) ?? tr("nessun output", "no output");
+    const width = Math.max(1, columns - 7);
+    const hidden = rows.length > 1 || exceedsTerminalWidth(oneLine(first), width);
+    const hint = columns >= 48 ? tr(" · Ctrl+R dettagli", " · Ctrl+R details") : " · Ctrl+R";
+    if (!hidden)
+        return livePreview(first, width);
+    const suffix = (rows.length > 1 ? " · " + tr("{count} righe", "{count} lines", { count: rows.length }) : "") + hint;
+    return livePreview(first, Math.max(1, width - terminalWidth(suffix))) + fitLine(suffix, Math.max(0, width - 1));
+}

package/dist/tui/locales.d.ts

@@ -0,0 +1,19 @@
+export declare const SUPPORTED_LANGUAGES: readonly ["it", "en", "es", "de"];
+export type Language = typeof SUPPORTED_LANGUAGES[number];
+export type LanguagePreference = Language | "system";
+export declare const LANGUAGES: readonly [{
+    readonly id: "it";
+    readonly nome: "Italiano";
+}, {
+    readonly id: "en";
+    readonly nome: "English";
+}, {
+    readonly id: "es";
+    readonly nome: "Español";
+}, {
+    readonly id: "de";
+    readonly nome: "Deutsch";
+}];
+export declare function normalizeLanguage(value: unknown): Language | undefined;
+export declare function normalizePreference(value: unknown): LanguagePreference | undefined;
+export declare function detectLanguage(languages: readonly string[]): Language;

package/dist/tui/locales.js

@@ -0,0 +1,22 @@
+export const SUPPORTED_LANGUAGES = ["it", "en", "es", "de"];
+export const LANGUAGES = [
+    { id: "it", nome: "Italiano" }, { id: "en", nome: "English" },
+    { id: "es", nome: "Español" }, { id: "de", nome: "Deutsch" },
+];
+export function normalizeLanguage(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const base = value.trim().toLowerCase().split(/[-_.@]/)[0];
+    return SUPPORTED_LANGUAGES.find(language => language === base);
+}
+export function normalizePreference(value) {
+    return value === "system" || value === "auto" ? "system" : normalizeLanguage(value);
+}
+export function detectLanguage(languages) {
+    for (const locale of languages) {
+        const language = normalizeLanguage(locale);
+        if (language)
+            return language;
+    }
+    return "en";
+}

package/dist/tui/login-menu.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderRegistry } from "../providers/registry.js";
+export type LoginMethodId = "claude-code" | "chatgpt" | "openrouter" | "api-keys";
+export interface LoginRow {
+    readonly id: LoginMethodId;
+    readonly label: string;
+    readonly configured: boolean;
+    readonly needsRefresh: boolean;
+    readonly detail: string;
+    readonly command?: readonly string[];
+}
+/**
+ * Stato non sensibile dei metodi di accesso supportati da Talos.
+ * Le credenziali non lasciano mai i rispettivi store; qui arrivano soltanto
+ * presenza e scadenza, utili al menu `/login`.
+ */
+export declare function loginRows(env: NodeJS.ProcessEnv, registry: ProviderRegistry, now?: number): readonly LoginRow[];
+export declare function loginStatusLabel(row: LoginRow): string;

package/dist/tui/login-menu.js

@@ -0,0 +1,58 @@
+import { tr } from "./i18n.js";
+import { isExpired, readClaudeCreds, readCodexCreds } from "../providers/oauth-store.js";
+/**
+ * Stato non sensibile dei metodi di accesso supportati da Talos.
+ * Le credenziali non lasciano mai i rispettivi store; qui arrivano soltanto
+ * presenza e scadenza, utili al menu `/login`.
+ */
+export function loginRows(env, registry, now = Date.now()) {
+    const claude = readClaudeCreds(env);
+    const codex = readCodexCreds(env);
+    const claudeExpired = Boolean(claude && isExpired(claude, now));
+    const codexExpired = Boolean(codex && isExpired(codex, now));
+    const openRouterConfigured = Boolean(registry.get("openrouter"));
+    return [
+        {
+            id: "claude-code",
+            label: "Claude Code",
+            configured: Boolean(claude),
+            needsRefresh: claudeExpired,
+            detail: claude
+                ? (claudeExpired ? tr("sessione scaduta, accedi di nuovo", "session expired, sign in again") : tr("abbonamento rilevato", "subscription detected"))
+                : tr("accedi con Claude Pro o Max", "sign in with Claude Pro or Max"),
+            command: ["claude", "auth", "login"],
+        },
+        {
+            id: "chatgpt",
+            label: "ChatGPT / Codex",
+            configured: Boolean(codex),
+            needsRefresh: codexExpired,
+            detail: codex
+                ? (codexExpired ? tr("sessione scaduta, accedi di nuovo", "session expired, sign in again") : tr("abbonamento rilevato", "subscription detected"))
+                : tr("accedi con ChatGPT Plus o Pro", "sign in with ChatGPT Plus or Pro"),
+            command: ["codex", "login"],
+        },
+        {
+            id: "openrouter",
+            label: "OpenRouter",
+            configured: openRouterConfigured,
+            needsRefresh: false,
+            detail: openRouterConfigured ? tr("account o API key collegati", "account or API key connected") : tr("OAuth nel browser o API key", "browser OAuth or API key"),
+        },
+        {
+            id: "api-keys",
+            label: tr("Altri provider", "Other providers"),
+            configured: registry.list().some((provider) => provider.id !== "ollama" &&
+                provider.id !== "claude-code" &&
+                provider.id !== "chatgpt" &&
+                provider.id !== "openrouter"),
+            needsRefresh: false,
+            detail: tr("Anthropic, OpenAI, Gemini, Grok e altri via API key", "Anthropic, OpenAI, Gemini, Grok and others via API key"),
+        },
+    ];
+}
+export function loginStatusLabel(row) {
+    if (row.needsRefresh)
+        return tr("da rinnovare", "renew sign-in");
+    return row.configured ? tr("collegato", "connected") : tr("non collegato", "not connected");
+}

package/dist/tui/logo.d.ts

@@ -0,0 +1,8 @@
+export interface LogoRenderOptions {
+    readonly columns?: number;
+    readonly rows?: number;
+    readonly samples?: number;
+    readonly ansi?: boolean;
+}
+export declare function renderVascendTerminalLogo(options?: LogoRenderOptions): readonly string[];
+export declare function renderBlockLogo(svg: string, options?: LogoRenderOptions): readonly string[];