@vascend/talos 0.1.0

package/dist/tui/usage-footer.js

@@ -0,0 +1,123 @@
+import { formatTokenCount } from "./cost-tracker.js";
+import { isSubscription } from "./session-usage.js";
+import { buildStatusLine, DEFAULT_ORDER } from "./status-line.js";
+import { fitLine, oneLine, terminalWidth } from "./terminal-text.js";
+import { buildContextBar } from "./context-bar.js";
+import { getLanguage, tr } from "./i18n.js";
+export const SESSION_USAGE_EXPLANATION = "I token cumulati sono la somma delle chiamate della sessione, inclusi input ripetuti e cache: non sono il contesto di una singola richiesta. Talos seleziona informazioni rilevanti e gestisce la cronologia con recupero e compattazione secondo la configurazione. Questo non annulla i consumi registrati dal provider. ≥ indica un totale parziale: il consumo noto è almeno quello mostrato. Il contesto indicato è una stima locale, non una misura esatta del payload inviato.";
+const shortLabel = (label) => label.replace("Limite 5 ore", "5h").replace("Settimanale", tr("7g", "7d")).replace("Finestra ", "");
+const remainingPercent = (window) => window.status === "rejected" ? "0%"
+    : window.utilization !== undefined ? `${Math.round(Math.max(0, Math.min(1, 1 - window.utilization)) * 100)}%` : undefined;
+function windowText(limits, now, detail) {
+    const stale = now - limits.capturedAt > 5 * 60_000;
+    return limits.windows.map(window => {
+        const expired = window.resetAt !== undefined && window.resetAt <= now;
+        const percent = remainingPercent(window);
+        const remaining = percent !== undefined ? `${percent} ${tr("disponibile", "remaining")}`
+            : window.remaining !== undefined ? `${formatTokenCount(window.remaining)} ${window.unit ?? ""} ${tr("disponibili", "remaining")}` : tr("quota non comunicata", "quota unavailable");
+        const label = window.label === "Secondaria" ? tr("Quota 2 (durata ignota)", "Quota 2 (window unknown)") : window.label === "Primaria" ? tr("Quota 1 (durata ignota)", "Quota 1 (window unknown)") : shortLabel(window.label);
+        let text = `${label} ${remaining}`;
+        if (window.status === "rejected")
+            text += tr(" · limite raggiunto", " · limit reached");
+        if (expired || stale)
+            text += tr(" (dato non recente)", " (outdated)");
+        if (detail)
+            text += ` · ${resetCountdown(window.resetAt, now)}`
+                + (window.resetAt ? ` (${new Date(window.resetAt).toLocaleString(getLanguage())})` : "");
+        return text;
+    });
+}
+export function subscriptionDetails(providerId, limits, t, now = Date.now()) {
+    if (!isSubscription(providerId) && !limits)
+        return [];
+    const rows = [t.bold(`\n  ${isSubscription(providerId) ? tr("Abbonamento", "Subscription") : tr("Limiti provider", "Provider limits")} · ${providerId}`)];
+    if (!limits?.windows.length)
+        rows.push(t.dim(tr("    Quota non comunicata dal provider. Si aggiorna quando arriva una risposta con i limiti.", "    Quota unavailable. Updates when the provider reports limits in a response.")));
+    else {
+        rows.push(...windowText(limits, now, true).map(text => t.silver(`    ${text}`)));
+        rows.push(t.dim(`    ${tr("Ultimo aggiornamento", "Last update")}: ${new Date(limits.capturedAt).toLocaleString(getLanguage())}`));
+    }
+    if (isSubscription(providerId))
+        rows.push(t.dim(tr("    Quota condivisa dell'account, distinta dai token di questa sessione.", "    Shared account quota, separate from this session's token usage.")));
+    return rows;
+}
+function resetCountdown(resetAt, now) {
+    if (resetAt === undefined)
+        return tr("reset n/d", "reset n/a");
+    if (resetAt <= now)
+        return tr("reset atteso", "reset pending");
+    const minutes = Math.ceil((resetAt - now) / 60_000);
+    if (minutes >= 1440)
+        return `reset ${Math.floor(minutes / 1440)}${tr("g", "d")} ${Math.floor(minutes % 1440 / 60)}h`;
+    if (minutes >= 60)
+        return `reset ${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+    return `reset ${minutes}m`;
+}
+function footerWindows(limits, providerId) {
+    const session = limits?.windows.find(w => w.id === "5h" || w.label === "Limite 5 ore");
+    const weekly = limits?.windows.find(w => w.id === "7d" || w.label === "Settimanale");
+    const known = [session, weekly].filter((w) => w !== undefined);
+    // At narrow widths, keep the window that is actually blocking the account.
+    const blocked = limits?.windows.filter(w => w.status === "rejected" && !w.id.startsWith("overage")) ?? [];
+    for (const window of blocked)
+        if (!known.includes(window))
+            known.push(window);
+    known.sort((a, b) => Number(b.status === "rejected") - Number(a.status === "rejected"));
+    if (known.length)
+        return known;
+    if (isSubscription(providerId))
+        return [{ id: "5h", label: "Limite 5 ore" }, { id: "7d", label: "Settimanale" }];
+    return limits?.windows.slice(0, 1) ?? [];
+}
+function quotaText(window, limits, t, now, reset = false) {
+    const old = !!limits && (now - limits.capturedAt > 5 * 60_000 || (window.resetAt !== undefined && window.resetAt <= now));
+    const percent = remainingPercent(window);
+    const text = `${shortLabel(window.label)} ${old ? "~" : ""}${percent ?? tr("n/d", "n/a")}${percent ? ` ${tr("rim.", "left")}` : ""}`;
+    const paint = old || window.status === "rejected" || (window.utilization ?? 0) >= 0.9 ? t.yellow : t.muted;
+    return paint(text) + (reset ? t.dim(` · ${resetCountdown(window.resetAt, now)}`) : "");
+}
+export function buildUsageFooter(d, t, state, providerId, opts = {}, now = Date.now()) {
+    const width = Math.max(1, d.width - 3);
+    const known = d.contextTokens !== undefined && Number.isFinite(d.contextTokens) && d.contextTokens >= 0
+        && d.contextWindow !== undefined && Number.isFinite(d.contextWindow) && d.contextWindow > 0;
+    const warning = state.unsaved ? t.yellow(tr(" · non salvati", " · unsaved")) : "";
+    const context = known
+        ? buildContextBar(d.contextTokens, d.contextWindow, d.contextArchive ?? [], width, t, warning)
+        : t.muted(tr("Contesto~ n/d", "Context~ n/a")) + warning;
+    const limits = state.limits.get(providerId);
+    const windows = footerWindows(limits, providerId);
+    const separator = t.dim(" · ");
+    const effort = d.effort ? t.muted(oneLine(d.effort)) : "";
+    const suffix = [d.fast ? t.accent("fast") : "", effort].filter(Boolean).join(separator);
+    const model = oneLine(d.model).split("/").pop() || oneLine(d.model);
+    const quotaBudget = windows[0] && width >= 21 ? terminalWidth(quotaText(windows[0], limits, t, now)) + 2 : 0;
+    const modelBudget = Math.max(1, width - terminalWidth(suffix) - (suffix ? 3 : 0) - quotaBudget);
+    let runtime = t.silver(fitLine(model, modelBudget)) + (suffix ? separator + suffix : "");
+    // Due righe stabili: contesto sopra l'input, modello e quota sotto.
+    // I dettagli meno urgenti non aggiungono righe quando lo spazio finisce.
+    const fits = (left, right) => terminalWidth(left) + terminalWidth(right) + (right ? 2 : 0) <= width;
+    const parts = [];
+    for (const window of windows) {
+        const candidate = quotaText(window, limits, t, now);
+        if (fits(runtime, [...parts, candidate].join(separator)))
+            parts.push(candidate);
+        else
+            break;
+    }
+    for (let i = 0; i < parts.length; i++) {
+        if (windows[i].resetAt === undefined)
+            continue;
+        const withReset = [...parts];
+        withReset[i] = quotaText(windows[i], limits, t, now, true);
+        if (fits(runtime, withReset.join(separator)))
+            parts[i] = withReset[i];
+    }
+    const right = parts.join(separator);
+    const order = [...new Set(opts.order ?? DEFAULT_ORDER)].filter(id => !["usage", "ctx", "model", "effort"].includes(id));
+    const extra = order.length || opts.render ? buildStatusLine(d, t, { ...opts, order }).trim() : "";
+    if (extra && fits(runtime + separator + extra, right))
+        runtime += separator + extra;
+    if (right)
+        runtime += " ".repeat(Math.max(2, width - terminalWidth(runtime) - terminalWidth(right))) + right;
+    return [context, runtime].map(row => fitLine("  " + row, Math.max(1, d.width - 1)));
+}

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

@@ -0,0 +1,68 @@
+import { type ValutazioneProva } from "../core/licenza.js";
+export declare const VASCEND_AUTH_BASE = "https://api.vascend.it/api/v1/agent";
+type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+export interface LoginDeps {
+    readonly fetchImpl?: FetchLike;
+    readonly base?: string;
+}
+export interface EsitoRichiestaCodice {
+    readonly ok: boolean;
+    readonly nuovo?: boolean;
+    readonly attesaS?: number;
+    readonly error?: string;
+}
+export interface EsitoVerifica {
+    readonly ok: boolean;
+    readonly token?: string;
+    readonly nome?: string;
+    readonly tier?: string;
+    readonly serveSecondoFattore?: boolean;
+    readonly error?: string;
+}
+export interface EsitoSessione {
+    readonly language?: "it" | "en";
+    readonly stato: "valida" | "respinta" | "irraggiungibile";
+    readonly email?: string;
+    readonly nome?: string;
+    readonly tier?: string;
+    readonly error?: string;
+}
+export interface DecisioneCancello {
+    readonly azione: "prosegui" | "login";
+    readonly avviso?: string;
+    readonly email?: string;
+    readonly tier?: string;
+}
+export declare function baseOf(deps: LoginDeps, env: NodeJS.ProcessEnv): string;
+export declare function richiediCodice(env: NodeJS.ProcessEnv, p: {
+    email: string;
+    nome?: string;
+    cognome?: string;
+}, deps?: LoginDeps): Promise<EsitoRichiestaCodice>;
+export declare function verificaCodice(env: NodeJS.ProcessEnv, p: {
+    email: string;
+    codice: string;
+    totp?: string;
+}, deps?: LoginDeps): Promise<EsitoVerifica>;
+export declare function statoSessione(env: NodeJS.ProcessEnv, token: string, deps?: LoginDeps): Promise<EsitoSessione>;
+export declare function revocaSessione(env: NodeJS.ProcessEnv, token: string, deps?: LoginDeps): Promise<void>;
+export declare function decisioneCancello(token: string, sessione: EsitoSessione | null, offline?: ValutazioneProva | null): DecisioneCancello;
+export interface EsitoProvaOffline {
+    readonly ok: boolean;
+    readonly prova?: string;
+    readonly error?: string;
+}
+export declare function prendiProvaOffline(env: NodeJS.ProcessEnv, token: string, deps?: LoginDeps): Promise<EsitoProvaOffline>;
+interface LicenzaLocale {
+    readonly prova: string;
+    readonly massimoVisto: number;
+}
+export declare function leggiLicenzaLocale(env: NodeJS.ProcessEnv): LicenzaLocale | null;
+export declare function salvaLicenzaLocale(env: NodeJS.ProcessEnv, dati: LicenzaLocale): boolean;
+export declare function rimuoviLicenzaLocale(env: NodeJS.ProcessEnv): void;
+export declare function valutaLicenzaLocale(env: NodeJS.ProcessEnv, adesso?: number): ValutazioneProva | null;
+export declare function rinnovaProvaOffline(env: NodeJS.ProcessEnv, token: string, deps?: LoginDeps): Promise<void>;
+export declare function tokenVascend(env: NodeJS.ProcessEnv): string;
+export declare function salvaTokenVascend(env: NodeJS.ProcessEnv, token: string): boolean;
+export declare function rimuoviTokenVascend(env: NodeJS.ProcessEnv): boolean;
+export {};

package/dist/tui/vascend-login.js

@@ -0,0 +1,355 @@
+// Accesso Vascend per la TUI: lo STESSO cancello di Horizon.
+//
+// Talos e' il CLI di Horizon: per usarlo serve l'account Vascend, con lo
+// stesso flusso di Horizon (vascend-terminal/src/main/auth.js) e le stesse
+// rotte del backend agentico su api.vascend.it:
+//   POST /otp/request  { email, nome?, cognome? } -> { nuovo, inviato, attesa_s }
+//   POST /otp/verify   { email, codice, totp? }   -> { access_token, tier, ... }
+//   GET  /me           (Bearer)                   -> { email, name?, tier, ... }
+//   POST /logout       (Bearer, best-effort)
+//
+// Nessuna password: si scrive l'email, arriva un codice monouso, si entra. Un
+// indirizzo sconosciuto porta alla registrazione nello stesso flusso (nuovo:
+// true -> si chiedono nome e cognome). Chi ha acceso il secondo fattore lo
+// inserisce NELLA STESSA verifica (il backend controlla il TOTP prima di
+// consumare la sfida: sbagliarlo non brucia il codice email).
+//
+// Il token (JWT) si salva nello store credenziali di talos
+// (~/.talos/config.json, provider "vascend") e vale per gli avvii successivi.
+// Parte PURA e testabile: fetch iniettabile, niente stato di modulo.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { deleteCredential, loadCredentials, saveCredential } from "../core/credentials.js";
+import { talosConfigDir } from "../core/env-paths.js";
+import { valuta } from "../core/licenza.js";
+export const VASCEND_AUTH_BASE = "https://api.vascend.it/api/v1/agent";
+const AUTH_TIMEOUT_MS = 12_000;
+// Il confine col server e' territorio ostile in ENTRAMBE le direzioni: quello
+// che spediamo deve essere gia' nei limiti del contratto (niente payload
+// anomali costruiti tramite questo client), quello che riceviamo va trattato
+// come testo di chiunque PRIMA di finire sul terminale — una risposta con
+// sequenze di escape dentro `error` potrebbe altrimenti scrivere negli
+// appunti (OSC 52), cambiare il titolo o falsificare lo schermo.
+function pulisciTesto(valore, max = 200) {
+    return String(valore ?? "")
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, max);
+}
+// L'endpoint di accesso viaggia SOLO su https; http e' ammesso unicamente in
+// locale (sviluppo). Un override malformato o in chiaro non degrada il login
+// su un canale osservabile: si torna al default compilato.
+function baseValida(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol === "https:")
+            return true;
+        return parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+    }
+    catch {
+        return false;
+    }
+}
+export function baseOf(deps, env) {
+    const override = String(env["TALOS_VASCEND_AUTH_URL"] ?? "").trim();
+    const scelta = deps.base ?? (override || VASCEND_AUTH_BASE);
+    return (baseValida(scelta) ? scelta : VASCEND_AUTH_BASE).replace(/\/+$/, "");
+}
+// Un token di sessione e' un JWT: charset base64url + punti, lunghezza sana.
+// Tutto il resto (uno store manomesso, un valore incollato per sbaglio) NON
+// diventa un header Authorization: si tratta come assenza di sessione.
+function tokenPlausibile(token) {
+    return /^[A-Za-z0-9._-]{20,4096}$/.test(token);
+}
+function fetchDi(deps) {
+    const f = deps.fetchImpl ?? (typeof fetch !== "undefined" ? fetch : null);
+    if (!f)
+        throw new Error("fetch non disponibile in questo runtime");
+    return f;
+}
+function messaggio(err) {
+    return pulisciTesto(err?.message ?? err ?? "");
+}
+async function chiama(deps, env, path, init) {
+    const f = fetchDi(deps);
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timer = controller ? setTimeout(() => controller.abort(), AUTH_TIMEOUT_MS) : null;
+    let resp;
+    try {
+        resp = await f(baseOf(deps, env) + path, controller ? { ...init, signal: controller.signal } : init);
+    }
+    catch (err) {
+        return { ok: false, status: 0, data: {}, rete: true, error: "servizio Vascend non raggiungibile: " + messaggio(err) };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    let data = {};
+    try {
+        data = (await resp.json());
+    }
+    catch {
+        data = {};
+    }
+    if (!resp.ok) {
+        // Il testo arriva dal server (o da chi si spaccia per lui): si ripulisce
+        // QUI, una volta, prima che qualunque chiamante lo stampi.
+        const testo = typeof data["error"] === "string" && data["error"]
+            ? pulisciTesto(data["error"])
+            : typeof data["message"] === "string" && data["message"] ? pulisciTesto(data["message"]) : `errore ${resp.status}`;
+        return { ok: false, status: resp.status, data, error: testo };
+    }
+    return { ok: true, status: resp.status, data };
+}
+// Primo passo: chiede il codice per un indirizzo. `nuovo: true` = account da
+// registrare: si richiama con nome e cognome (stessa rotta, stesso flusso).
+export async function richiediCodice(env, p, deps = {}) {
+    // I limiti del contratto si rispettano PRIMA di spedire: questo client
+    // non deve poter essere usato per costruire payload anomali.
+    const email = p.email.trim().toLowerCase();
+    if (!email || email.length > 254 || !email.includes("@")) {
+        return { ok: false, error: "email non valida" };
+    }
+    const corpo = { email };
+    if (p.nome)
+        corpo["nome"] = pulisciTesto(p.nome, 120);
+    if (p.cognome)
+        corpo["cognome"] = pulisciTesto(p.cognome, 120);
+    const r = await chiama(deps, env, "/otp/request", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(corpo),
+    });
+    if (!r.ok)
+        return { ok: false, error: r.error ?? "richiesta codice fallita" };
+    const attesa = Number(r.data["attesa_s"] ?? 0);
+    return {
+        ok: true,
+        nuovo: r.data["nuovo"] === true,
+        attesaS: Number.isFinite(attesa) && attesa > 0 ? Math.min(attesa, 86_400) : 0,
+    };
+}
+// Secondo passo: il codice conferma. Un 401 che nomina il secondo fattore NON
+// e' un codice sbagliato: la UI deve chiedere il TOTP e riprovare con lo
+// STESSO codice email (ricominciare farebbe partire un'email a tentativo).
+export async function verificaCodice(env, p, deps = {}) {
+    const email = p.email.trim().toLowerCase();
+    const codice = p.codice.trim();
+    const totp = (p.totp ?? "").trim();
+    if (!email || email.length > 254)
+        return { ok: false, error: "email non valida" };
+    if (!codice || codice.length > 12)
+        return { ok: false, error: "codice non valido" };
+    if (totp.length > 32)
+        return { ok: false, error: "secondo fattore non valido" };
+    const corpo = { email, codice };
+    if (totp)
+        corpo["totp"] = totp;
+    // Talos e' un prodotto SEPARATO da Horizon: l'avviso "Da dove si e' entrati"
+    // e l'email di attivazione devono dire quello vero. Il server traduce da
+    // allowlist, qui si dichiara e basta.
+    corpo["client"] = "talos";
+    const r = await chiama(deps, env, "/otp/verify", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(corpo),
+    });
+    if (!r.ok) {
+        if (r.status === 401 && /secondo fattore/i.test(String(r.error ?? ""))) {
+            return { ok: false, serveSecondoFattore: true, error: r.error ?? "" };
+        }
+        return { ok: false, error: r.error ?? "verifica fallita" };
+    }
+    const token = String(r.data["access_token"] ?? "").trim();
+    // Anche il token si valida: uno malformato non deve mai diventare un
+    // header Authorization ne' finire nello store.
+    if (!tokenPlausibile(token))
+        return { ok: false, error: "verifica: risposta senza token valido" };
+    const nome = pulisciTesto(r.data["name"] ?? r.data["full_name"] ?? r.data["display_name"] ?? "", 80);
+    return {
+        ok: true,
+        token,
+        ...(nome ? { nome } : {}),
+        ...(typeof r.data["tier"] === "string" ? { tier: pulisciTesto(r.data["tier"], 40) } : {}),
+    };
+}
+// Stato della sessione salvata: GET /me col Bearer.
+export async function statoSessione(env, token, deps = {}) {
+    const r = await chiama(deps, env, "/me", {
+        method: "GET",
+        headers: { Authorization: "Bearer " + token },
+    });
+    if (r.ok) {
+        const nome = pulisciTesto(r.data["name"] ?? r.data["full_name"] ?? r.data["display_name"] ?? r.data["nome"] ?? "", 80);
+        return {
+            stato: "valida",
+            ...(r.data["language"] === "en" || r.data["language"] === "it" ? { language: r.data["language"] } : {}),
+            ...(typeof r.data["email"] === "string" ? { email: pulisciTesto(r.data["email"], 254) } : {}),
+            ...(nome ? { nome } : {}),
+            ...(typeof r.data["tier"] === "string" ? { tier: pulisciTesto(r.data["tier"], 40) } : {}),
+        };
+    }
+    if (r.rete)
+        return { stato: "irraggiungibile", ...(r.error ? { error: r.error } : {}) };
+    return { stato: "respinta", ...(r.error ? { error: r.error } : {}) };
+}
+// Revoca best-effort lato backend; il token locale lo rimuove il chiamante.
+export async function revocaSessione(env, token, deps = {}) {
+    if (!token)
+        return;
+    try {
+        await fetchDi(deps)(baseOf(deps, env) + "/logout", {
+            method: "POST",
+            headers: { Authorization: "Bearer " + token },
+        });
+    }
+    catch {
+        // best-effort: il logout locale prosegue comunque
+    }
+}
+// Decisione del cancello d'avvio, PURA rispetto alla rete: il chiamante passa
+// il token salvato, l'esito di /me e la VALUTAZIONE della prova offline.
+//
+// Senza rete NON basta avere "una sessione salvata": un token si fabbrica in
+// un file di config, una prova firmata Ed25519 no. Quindi: rete giu' + prova
+// firmata valida (firma, scadenza, orologio ancorato) = si lavora offline;
+// rete giu' senza prova valida = login (che offline non riesce: per lavorare
+// scollegati serve una prova VERA, presa da connessi). Un 401 resta
+// fail-closed: sessione scaduta o revocata, si rientra.
+export function decisioneCancello(token, sessione, offline = null) {
+    if (!token)
+        return { azione: "login" };
+    if (!sessione)
+        return { azione: "login" };
+    if (sessione.stato === "valida") {
+        return {
+            azione: "prosegui",
+            ...(sessione.email ? { email: sessione.email } : {}),
+            ...(sessione.tier ? { tier: sessione.tier } : {}),
+        };
+    }
+    if (sessione.stato === "irraggiungibile") {
+        if (offline && offline.ok) {
+            const scade = offline.claims && Number.isFinite(offline.claims.exp)
+                ? new Date(offline.claims.exp * 1000).toISOString().slice(0, 10)
+                : "";
+            return {
+                azione: "prosegui",
+                avviso: "rete non raggiungibile: prova offline firmata valida" + (scade ? ` (fino al ${scade})` : ""),
+                ...(offline.claims?.email ? { email: offline.claims.email } : {}),
+                ...(offline.claims?.tier ? { tier: offline.claims.tier } : {}),
+            };
+        }
+        const motivo = offline ? ` (prova offline: ${offline.motivo ?? "non valida"})` : " (nessuna prova offline)";
+        return { azione: "login", avviso: "rete non raggiungibile e nessuna prova offline valida" + motivo };
+    }
+    return { azione: "login", avviso: sessione.error ?? "sessione scaduta o revocata" };
+}
+// GET /licenza/offline (Bearer): rilascia la prova firmata da conservare per
+// quando la rete non ci sara'. Rinnovo a finestra scorrevole: si riprende a
+// ogni accesso online e chi lavora connesso non se ne accorge.
+export async function prendiProvaOffline(env, token, deps = {}) {
+    const r = await chiama(deps, env, "/licenza/offline", {
+        method: "GET",
+        headers: { Authorization: "Bearer " + token },
+    });
+    if (!r.ok)
+        return { ok: false, error: r.error ?? "prova offline non disponibile" };
+    const prova = String(r.data["prova"] ?? "").trim();
+    // Stessa igiene del token: la prova e' un JWT, tutto il resto si scarta
+    // (e non finisce mai scritto su disco).
+    if (!provaPlausibile(prova))
+        return { ok: false, error: "risposta senza prova valida" };
+    return { ok: true, prova };
+}
+// Una prova e' un JWT (piu' lungo di un access token: porta i claims della
+// licenza), mai oltre gli 8KB: oltre, o fuori charset, e' spazzatura.
+function provaPlausibile(prova) {
+    return /^[A-Za-z0-9._-]{20,8192}$/.test(prova);
+}
+function licenzaPath(env) {
+    if (env["TALOS_NO_GLOBAL_CONFIG"] === "1")
+        return null;
+    return join(talosConfigDir(env), "licenza.json");
+}
+export function leggiLicenzaLocale(env) {
+    const path = licenzaPath(env);
+    if (!path || !existsSync(path))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        const prova = String(raw["prova"] ?? "").trim();
+        if (!provaPlausibile(prova))
+            return null;
+        const visto = Number(raw["massimoVisto"] ?? 0);
+        return { prova, massimoVisto: Number.isFinite(visto) && visto > 0 ? visto : 0 };
+    }
+    catch {
+        return null;
+    }
+}
+export function salvaLicenzaLocale(env, dati) {
+    const path = licenzaPath(env);
+    if (!path)
+        return false;
+    if (!provaPlausibile(dati.prova))
+        return false;
+    try {
+        mkdirSync(talosConfigDir(env), { recursive: true });
+        writeFileSync(path, JSON.stringify({ prova: dati.prova, massimoVisto: dati.massimoVisto }), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function rimuoviLicenzaLocale(env) {
+    const path = licenzaPath(env);
+    if (!path || !existsSync(path))
+        return;
+    try {
+        writeFileSync(path, JSON.stringify({}), "utf8");
+    }
+    catch { /* best-effort */ }
+}
+// Valuta la prova offline conservata QUI e ORA (firma, scadenza, orologio
+// ancorato) e aggiorna il massimo orario visto. null = nessuna prova locale.
+export function valutaLicenzaLocale(env, adesso) {
+    const locale = leggiLicenzaLocale(env);
+    if (!locale)
+        return null;
+    const esito = valuta({
+        token: locale.prova,
+        ...(Number.isFinite(adesso) ? { adesso: adesso } : {}),
+        massimoVisto: locale.massimoVisto,
+    });
+    salvaLicenzaLocale(env, { prova: locale.prova, massimoVisto: esito.massimoVisto });
+    return esito;
+}
+// Rinnovo best-effort della prova offline, da fare a ogni accesso online
+// riuscito: chi lavora connesso non se ne accorge, chi parte ha in mano i
+// giorni della finestra e non uno di piu'.
+export async function rinnovaProvaOffline(env, token, deps = {}) {
+    const esito = await prendiProvaOffline(env, token, deps);
+    if (esito.ok && esito.prova) {
+        salvaLicenzaLocale(env, { prova: esito.prova, massimoVisto: Math.floor(Date.now() / 1000) });
+    }
+}
+// --- Persistenza del token (store credenziali di talos) --------------------
+const PROVIDER_ID = "vascend";
+export function tokenVascend(env) {
+    // Uno store manomesso (o un valore incollato a mano) non diventa un header:
+    // un token non plausibile equivale a nessuna sessione.
+    const token = String(loadCredentials(env)[PROVIDER_ID]?.apiKey ?? "").trim();
+    return tokenPlausibile(token) ? token : "";
+}
+export function salvaTokenVascend(env, token) {
+    if (!tokenPlausibile(token))
+        return false;
+    return saveCredential(env, PROVIDER_ID, { apiKey: token });
+}
+export function rimuoviTokenVascend(env) {
+    return deleteCredential(env, PROVIDER_ID);
+}

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

@@ -0,0 +1,28 @@
+import { type LoginDeps } from "./vascend-login.js";
+import type { Lingua } from "./onboarding.js";
+export declare class WebLoginError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export interface WebGrant {
+    readonly deviceCode: string;
+    readonly verifier: string;
+    readonly userCode: string;
+    readonly url: string;
+    readonly expiresIn: number;
+    readonly interval: number;
+}
+export interface WebSession {
+    readonly token: string;
+    readonly email: string;
+    readonly language: Lingua;
+    readonly tier?: string;
+}
+type Deps = LoginDeps & {
+    readonly wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    readonly now?: () => number;
+};
+export declare function verificationUrl(value: unknown, code: string): string;
+export declare function startWebLogin(env: NodeJS.ProcessEnv, language: Lingua, deps?: Deps, signal?: AbortSignal): Promise<WebGrant>;
+export declare function waitForWebLogin(env: NodeJS.ProcessEnv, grant: WebGrant, deps?: Deps, signal?: AbortSignal): Promise<WebSession>;
+export {};