@vascend/talos 0.1.4 → 0.1.6

package/dist/providers/cli-models.js

@@ -0,0 +1,194 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, dirname, isAbsolute, join } from "node:path";
+import { talosConfigDir } from "../core/env-paths.js";
+const QUERY_TIMEOUT_MS = 20_000;
+function cachePath(env) {
+    if (env["TALOS_NO_GLOBAL_CONFIG"] === "1" || env["TALOS_DISABLE_CLI_MODELS"] === "1")
+        return null;
+    return join(talosConfigDir(env), "cli-models.json");
+}
+/** Primo CLI nel PATH con l'impronta del binario reale (symlink risolti), o null se non installato. */
+export function findCli(name, env) {
+    const names = process.platform === "win32" ? [`${name}.exe`, `${name}.cmd`] : [name];
+    for (const directory of String(env["PATH"] ?? env["Path"] ?? "").split(delimiter)) {
+        if (!directory || !isAbsolute(directory))
+            continue;
+        for (const file of names) {
+            const candidate = join(directory, file);
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const real = realpathSync(candidate);
+                return { executable: candidate, stamp: `${real}@${statSync(real).mtimeMs}` };
+            }
+            catch {
+                // Voce del PATH non leggibile: si prova la successiva.
+            }
+        }
+    }
+    return null;
+}
+function readCache(env) {
+    const path = cachePath(env);
+    if (!path || !existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Modelli in cache per il CLI installato ora, o undefined se assenti o superati da un aggiornamento. */
+export function cachedCliModels(name, env) {
+    if (!cachePath(env))
+        return undefined;
+    const cli = findCli(name, env);
+    const entry = readCache(env)[name];
+    if (!cli || !entry || entry.stamp !== cli.stamp)
+        return undefined;
+    const models = Array.isArray(entry.models) ? entry.models.filter((model) => typeof model?.id === "string" && model.id && typeof model.label === "string") : [];
+    return models.length ? models : undefined;
+}
+/**
+ * Righe di `initialize` del CLI Claude Code. Gli alias (default, opus, sonnet)
+ * diventano il modello versionato che eseguono: una voce per modello reale,
+ * nell'ordine del CLI.
+ */
+export function claudeModelsFromInitialize(models) {
+    const out = new Map();
+    for (const raw of Array.isArray(models) ? models : []) {
+        const row = raw;
+        if (row["value"] === "default")
+            continue;
+        const id = String(row["resolvedModel"] || row["value"] || "").trim();
+        if (!id || out.has(id))
+            continue;
+        const label = String(row["displayName"] || id).trim();
+        const description = String(row["description"] ?? "").trim();
+        out.set(id, { id, label, ...(description ? { description } : {}) });
+    }
+    return [...out.values()];
+}
+/** Righe di `model/list` dell'app-server Codex, senza i modelli nascosti. */
+export function codexModelsFromList(data) {
+    const out = new Map();
+    for (const raw of Array.isArray(data) ? data : []) {
+        const row = raw;
+        if (row["hidden"] === true)
+            continue;
+        const id = String(row["model"] || row["id"] || "").trim();
+        if (!id || out.has(id))
+            continue;
+        const label = String(row["displayName"] || id).trim();
+        const description = String(row["description"] ?? "").trim();
+        out.set(id, { id, label, ...(description ? { description } : {}) });
+    }
+    return [...out.values()];
+}
+// Avvia il CLI, scrive le richieste JSONL e attende la prima riga che `pick`
+// riconosce. Il processo viene sempre terminato, anche su timeout o errore.
+function queryCli(executable, args, requests, pick, env, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, [...args], {
+            env, cwd: tmpdir(), stdio: ["pipe", "pipe", "ignore"], windowsHide: true,
+            shell: process.platform === "win32" && executable.toLowerCase().endsWith(".cmd"),
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new Error(`${executable} did not answer in time`)), timeoutMs);
+        child.on("error", (error) => finish(error));
+        child.on("close", () => finish(new Error(`${executable} exited before answering`)));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buffer += chunk;
+            let newline;
+            while ((newline = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (!line.startsWith("{"))
+                    continue;
+                try {
+                    const value = pick(JSON.parse(line));
+                    if (value !== undefined)
+                        finish(null, value);
+                }
+                catch {
+                    // Righe non JSON (log) ignorate.
+                }
+            }
+        });
+        child.stdin.on("error", () => { });
+        child.stdin.write(requests.map((request) => JSON.stringify(request)).join("\n") + "\n");
+    });
+}
+async function queryClaudeModels(executable, env, timeoutMs) {
+    const response = await queryCli(executable, ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"], [{ type: "control_request", request_id: "talos-models", request: { subtype: "initialize" } }], (message) => {
+        const body = message["response"];
+        return message["type"] === "control_response" && body?.["request_id"] === "talos-models" ? body : undefined;
+    }, env, timeoutMs);
+    if (response["subtype"] !== "success")
+        throw new Error(String(response["error"] ?? "Claude Code initialize failed"));
+    return claudeModelsFromInitialize(response["response"]?.["models"]);
+}
+async function queryCodexModels(executable, env, timeoutMs) {
+    const response = await queryCli(executable, ["app-server"], [
+        { id: 1, method: "initialize", params: { clientInfo: { name: "talos", version: "1" } } },
+        { method: "initialized" },
+        { id: 2, method: "model/list", params: {} },
+    ], (message) => message["id"] === 2 ? message : undefined, env, timeoutMs);
+    if (response["error"])
+        throw new Error(JSON.stringify(response["error"]));
+    return codexModelsFromList(response["result"]?.["data"]);
+}
+/**
+ * Rilegge i modelli dai CLI installati la cui cache manca o e' superata, e la
+ * salva. Un CLI assente, lento o in errore lascia la cache com'e': il catalogo
+ * ripiega su quello statico.
+ */
+export async function refreshCliModels(env, options = {}) {
+    const path = cachePath(env);
+    if (!path)
+        return;
+    const timeoutMs = options.timeoutMs ?? QUERY_TIMEOUT_MS;
+    const queries = { claude: queryClaudeModels, codex: queryCodexModels };
+    const updates = await Promise.all(Object.keys(queries).map(async (name) => {
+        if (!options.force && cachedCliModels(name, env))
+            return null;
+        const cli = findCli(name, env);
+        if (!cli)
+            return null;
+        try {
+            const models = await queries[name](cli.executable, env, timeoutMs);
+            return models.length ? [name, { stamp: cli.stamp, models }] : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    const fresh = updates.filter((update) => update !== null);
+    if (!fresh.length)
+        return;
+    const cache = { ...readCache(env), ...Object.fromEntries(fresh) };
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(cache, null, 2) + "\n", { mode: 0o600 });
+    }
+    catch {
+        // Cache non scrivibile: il catalogo resta quello statico.
+    }
+}

package/dist/providers/model-effort.js

@@ -26,7 +26,7 @@ export function modelEfforts(fullModel, metadata = modelCapabilities(fullModel))
             return ["", "low", "medium", "high"];
     }
     if (provider === "openai") {
-        if (/gpt-6-astra/.test(id))
+        if (/gpt-6/.test(id))
             return ["", "low", "medium", "high", "xhigh", "max"];
         if (/gpt-5\.[456]/.test(id))
             return ["", "low", "medium", "high", "xhigh"];

package/dist/providers/openai-oauth.d.ts

@@ -1,3 +1,4 @@
+import type { CliModel } from "./cli-models.js";
 import type { CompletionRequest, ModelTurn, Provider } from "../core/types.js";
 import { type OAuthCreds } from "./oauth-store.js";
 export declare class OpenAIOAuthProvider implements Provider {
@@ -5,10 +6,14 @@ export declare class OpenAIOAuthProvider implements Provider {
     private readonly env;
     private readonly now;
     readonly id = "chatgpt";
-    readonly label = "ChatGPT (abbonamento)";
-    readonly models: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra", "gpt-5-codex", "gpt-5", "gpt-5-mini", "o4-mini"];
+    readonly label = "ChatGPT";
+    readonly models: readonly string[];
+    readonly modelLabels?: ReadonlyMap<string, {
+        readonly label: string;
+        readonly description?: string;
+    }>;
     readonly supportsFastMode = true;
-    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number);
+    constructor(creds: OAuthCreds, env: NodeJS.ProcessEnv, now?: () => number, cliModels?: readonly CliModel[]);
     private ensureToken;
     complete(req: CompletionRequest): Promise<ModelTurn>;
 }

package/dist/providers/openai-oauth.js

@@ -105,13 +105,19 @@ export class OpenAIOAuthProvider {
     env;
     now;
     id = "chatgpt";
-    label = "ChatGPT (abbonamento)";
-    models = CHATGPT_MODELS;
+    label = "ChatGPT";
+    models;
+    modelLabels;
     supportsFastMode = true;
-    constructor(creds, env, now = () => Date.now()) {
+    constructor(creds, env, now = () => Date.now(), 
+    // Modelli del CLI ufficiale installato; senza, il catalogo statico.
+    cliModels) {
         this.creds = creds;
         this.env = env;
         this.now = now;
+        this.models = cliModels?.length ? cliModels.map((model) => model.id) : CHATGPT_MODELS;
+        if (cliModels?.length)
+            this.modelLabels = new Map(cliModels.map((model) => [model.id, model]));
     }
     async ensureToken(signal) {
         if (!isExpired(this.creds, this.now()) || !this.creds.refreshToken) {

package/dist/providers/openrouter-manual-fallback.d.ts

@@ -1,16 +1,18 @@
 import type { OAuthFlow } from "./openrouter-auth.js";
+export type ManualTranslator = (italian: string, english: string, values?: Readonly<Record<string, string | number>>) => string;
 export declare function normalizeAuthCode(raw: string): string;
 export declare function isLikelyAuthCode(value: string): boolean;
 export interface ManualInstructions {
     readonly lines: readonly string[];
     readonly authUrl: string;
 }
-export declare function buildManualInstructions(authUrl: string, reason?: string): ManualInstructions;
+export declare function buildManualInstructions(authUrl: string, reason?: string, tr?: ManualTranslator): ManualInstructions;
 export interface ManualFallbackIo {
     print(line: string): void;
     prompt(label: string): Promise<string | null>;
 }
 export interface ManualFallbackOptions {
+    readonly translate?: ManualTranslator;
     readonly reason?: string;
     readonly maxAttempts?: number;
     readonly signal?: AbortSignal;

package/dist/providers/openrouter-manual-fallback.js

@@ -13,6 +13,7 @@
 // (niente accesso diretto a stdin/stdout/console), e lo scambio del code arriva
 // dall'OAuthFlow.complete gia' fornito da openrouter-auth.ts. Nessun side effect
 // nascosto, niente dipendenze a runtime.
+const defaultTranslation = (italian, _english, values) => italian.replace(/\{(\w+)\}/g, (match, key) => String(values?.[key] ?? match));
 // ---------------------------------------------------------------------------
 // Validazione / normalizzazione del code incollato
 // ---------------------------------------------------------------------------
@@ -91,26 +92,24 @@ export function isLikelyAuthCode(value) {
 // Costruisce le istruzioni per il percorso manuale. `reason` (opzionale) spiega
 // perche' siamo qui (es. "porta 8976 occupata", "nessun browser disponibile"):
 // se assente usiamo un messaggio neutro.
-export function buildManualInstructions(authUrl, reason) {
+export function buildManualInstructions(authUrl, reason, tr = defaultTranslation) {
     const why = (reason ?? "").trim();
     const lines = [];
-    lines.push("Login OpenRouter — modalita' manuale");
+    lines.push(tr("Login OpenRouter — modalita' manuale", "OpenRouter sign-in — manual mode"));
     if (why) {
-        lines.push(`(callback automatico non disponibile: ${why})`);
+        lines.push(tr("(callback automatico non disponibile: {reason})", "(automatic callback unavailable: {reason})", { reason: why }));
     }
     else {
-        lines.push("(callback automatico non disponibile: completiamo a mano)");
+        lines.push(tr("(callback automatico non disponibile: completiamo a mano)", "(automatic callback unavailable: complete sign-in manually)"));
     }
     lines.push("");
-    lines.push("1. Apri questo link nel browser (copialo se non e' cliccabile):");
+    lines.push(tr("1. Apri questo link nel browser (copialo se non e' cliccabile):", "1. Open this link in the browser (copy it if it is not clickable):"));
     lines.push(`   ${authUrl}`);
     lines.push("");
-    lines.push("2. Autorizza l'accesso su OpenRouter.");
-    lines.push("3. Verrai rediretto a un indirizzo localhost che potrebbe non");
-    lines.push("   aprirsi (\"impossibile raggiungere il sito\"): e' normale.");
-    lines.push("4. Copia il valore del parametro `code` dalla barra degli indirizzi");
-    lines.push("   (oppure incolla l'intero URL: estraggo io il code).");
-    lines.push("5. Incollalo qui sotto e premi Invio.");
+    lines.push(tr("2. Autorizza l'accesso su OpenRouter.", "2. Authorize access on OpenRouter."));
+    lines.push(tr("3. Verrai rediretto a un indirizzo localhost che potrebbe non aprirsi: e' normale.", "3. You will be redirected to a localhost address that may not open: this is normal."));
+    lines.push(tr("4. Copia il parametro `code` dalla barra degli indirizzi (oppure incolla l'intero URL).", "4. Copy the `code` parameter from the address bar (or paste the entire URL)."));
+    lines.push(tr("5. Incollalo qui sotto e premi Invio.", "5. Paste it below and press Enter."));
     return { lines, authUrl };
 }
 // Esegue il percorso di fallback manuale: mostra link+istruzioni, chiede il
@@ -118,15 +117,16 @@ export function buildManualInstructions(authUrl, reason) {
 // input invalido o scambio fallito, fino a maxAttempts o annullamento.
 export async function runManualCodeFallback(io, flow, opts = {}) {
     const maxAttempts = Math.max(1, Math.floor(opts.maxAttempts ?? 3));
-    const instructions = buildManualInstructions(flow.authUrl, opts.reason);
+    const tr = opts.translate ?? defaultTranslation;
+    const instructions = buildManualInstructions(flow.authUrl, opts.reason, tr);
     for (const line of instructions.lines)
         io.print(line);
     let attempts = 0;
     let lastError = "";
     while (attempts < maxAttempts) {
         const remaining = maxAttempts - attempts;
-        const hint = attempts === 0 ? "" : ` (tentativi rimasti: ${remaining})`;
-        const raw = await io.prompt(`Incolla il code${hint}`);
+        const hint = attempts === 0 ? "" : tr(" (tentativi rimasti: {count})", " (attempts remaining: {count})", { count: remaining });
+        const raw = await io.prompt(tr("Incolla il code{hint}", "Paste the code{hint}", { hint }));
         // Annullamento esplicito (Esc/EOF): usciamo subito senza consumare logica.
         if (raw === null) {
             return { ok: false, error: "cancelled", attempts };
@@ -134,9 +134,9 @@ export async function runManualCodeFallback(io, flow, opts = {}) {
         attempts += 1;
         const code = normalizeAuthCode(raw);
         if (!isLikelyAuthCode(code)) {
-            lastError = "code non riconosciuto";
+            lastError = tr("code non riconosciuto", "unrecognized code");
             if (attempts < maxAttempts) {
-                io.print("Input non valido: incolla il code (o l'intero URL del callback). Riprova.");
+                io.print(tr("Input non valido: incolla il code (o l'intero URL del callback). Riprova.", "Invalid input: paste the code (or the entire callback URL). Try again."));
             }
             continue;
         }
@@ -148,14 +148,14 @@ export async function runManualCodeFallback(io, flow, opts = {}) {
             result = { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
         if (result.ok && result.apiKey) {
-            io.print("Autenticazione completata: API key ottenuta e salvata.");
+            io.print(tr("Autenticazione completata: API key ottenuta e salvata.", "Authentication complete: API key obtained and saved."));
             return { ok: true, apiKey: result.apiKey, attempts };
         }
-        lastError = result.error ?? "scambio fallito";
+        lastError = result.error ?? tr("scambio fallito", "exchange failed");
         if (attempts < maxAttempts) {
-            io.print(`Scambio fallito: ${lastError}. Verifica di aver copiato il code giusto e riprova.`);
+            io.print(tr("Scambio fallito: {error}. Verifica di aver copiato il code giusto e riprova.", "Exchange failed: {error}. Check that you copied the correct code and try again.", { error: lastError }));
         }
     }
-    io.print("Tentativi esauriti: login manuale non riuscito.");
+    io.print(tr("Tentativi esauriti: login manuale non riuscito.", "No attempts left: manual sign-in failed."));
     return { ok: false, error: lastError || "exhausted", attempts };
 }

package/dist/providers/registry.js

@@ -3,6 +3,7 @@ import { AnthropicOAuthProvider } from "./anthropic-oauth.js";
 import { OpenAIOAuthProvider } from "./openai-oauth.js";
 import { OpenAICompatProvider } from "./openai-compat.js";
 import { readClaudeCreds, readCodexCreds } from "./oauth-store.js";
+import { cachedCliModels } from "./cli-models.js";
 import { readOpenRouterCreds } from "./openrouter-auth.js";
 import { PROVIDER_CATALOG } from "./catalog.js";
 import { retryConfigFromEnv, withRetry } from "./retry.js";
@@ -202,11 +203,11 @@ export function defaultRegistry(env, opts = {}) {
     if (opts.detectOAuth !== false) {
         const claude = readClaudeCreds(env);
         if (claude)
-            add(new AnthropicOAuthProvider(claude, env));
+            add(new AnthropicOAuthProvider(claude, env, undefined, cachedCliModels("claude", env)));
         if (env["TALOS_DISABLE_CHATGPT_OAUTH"] !== "1") {
             const codex = readCodexCreds(env);
             if (codex)
-                add(new OpenAIOAuthProvider(codex, env));
+                add(new OpenAIOAuthProvider(codex, env, undefined, cachedCliModels("codex", env)));
         }
     }
     return reg;

package/dist/providers/retry.d.ts

@@ -1,5 +1,6 @@
 import type { CompletionRequest, ModelTurn, PlanLimits, Provider } from "../core/types.js";
 export interface RetryConfig {
+    readonly autoResumeSession?: boolean;
     readonly maxRetries: number;
     readonly baseDelayMs: number;
     readonly timeoutMs: number;
@@ -25,12 +26,14 @@ export declare class RetryProvider implements Provider {
     get id(): string;
     get label(): string | undefined;
     get models(): readonly string[];
+    get modelLabels(): Provider["modelLabels"];
     get supportsFastMode(): boolean;
     private get netMax();
     private get netDelay();
     private get overloadMaxAttempts();
     private overloadDelay;
     private waitForOverload;
+    private waitForSessionReset;
     complete(req: CompletionRequest): Promise<ModelTurn>;
     private backoff;
 }

package/dist/providers/retry.js

@@ -194,6 +194,9 @@ export class RetryProvider {
     get models() {
         return this.inner.models;
     }
+    get modelLabels() {
+        return this.inner.modelLabels;
+    }
     get supportsFastMode() { return this.inner.supportsFastMode === true; }
     get netMax() {
         return this.cfg.networkMaxRetries ?? 0;
@@ -218,6 +221,31 @@ export class RetryProvider {
             req.onActivity?.(`Modello sovraccarico · nuovo tentativo (${nextAttempt}/${this.overloadMaxAttempts}) · ${seconds}s`);
         });
     }
+    async waitForSessionReset(req, limits) {
+        if (this.cfg.autoResumeSession === false)
+            return false;
+        const rejected = rejectedQuotaWindows(limits);
+        const resetAt = quotaResetAt(limits);
+        // Never guess a reset or wait on credit/weekly exhaustion. Every rejected
+        // window must be the session window, with a future reset supplied by the provider.
+        const session = rejected.find(w => w.id === "5h");
+        // Claude also rejects the aggregate unified window when its 5h window
+        // is exhausted. It is not an independent weekly/credit limit.
+        if (!session || rejected.some(w => w.id !== "5h" && w.id !== "unified") || resetAt === undefined || resetAt <= Date.now())
+            return false;
+        if (req.signal.aborted)
+            return true;
+        const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const time = new Date(resetAt).toLocaleTimeString("it-IT", { hour: "2-digit", minute: "2-digit", timeZone: zone });
+        req.onActivity?.(`Limite sessione di 5 ore raggiunto · reset alle ${time} (${zone}) · riprendo automaticamente al reset · Esc per annullare`);
+        // Short slices avoid timer overflow and remain responsive to clock changes.
+        while (!req.signal.aborted && Date.now() < resetAt) {
+            await delay(Math.min(60_000, resetAt - Date.now()), req.signal);
+        }
+        if (!req.signal.aborted)
+            req.onActivity?.("Limite sessione reimpostato · riprendo automaticamente il lavoro");
+        return true;
+    }
     async complete(req) {
         let netAttempt = 0;
         let genAttempt = 0;
@@ -248,13 +276,26 @@ export class RetryProvider {
                             delivered = true;
                             req.onToolDelta(event);
                         } } : {}),
+                    ...(req.onReasoning ? { onReasoning: (chunk) => {
+                            if (!active || tm.signal.aborted)
+                                return;
+                            if (chunk)
+                                delivered = true;
+                            req.onReasoning(chunk);
+                        } } : {}),
+                    ...(req.onActivity ? { onActivity: (label) => {
+                            if (active && !tm.signal.aborted)
+                                req.onActivity(label);
+                        } } : {}),
                 });
                 active = false;
                 tm.cleanup();
                 if (result.stopReason === "error") {
-                    // 1. Limite/quota abbonamento: stop, messaggio chiaro (no retry).
+                    // 1. Sessione 5h: ripresa al reset solo se lo stream non e' iniziato.
                     if (isQuotaError(result.text) || rejectedQuotaWindows(result.limits).length > 0) {
                         const limits = quotaLimitsFromError(this.id, result.text, result.limits);
+                        if (!delivered && await this.waitForSessionReset(req, limits))
+                            continue;
                         return { ...result, toolCalls: [], text: quotaMessage(this.id, result.text, limits), ...(limits ? { limits } : {}) };
                     }
                     if (delivered)
@@ -301,6 +342,8 @@ export class RetryProvider {
                 const thrownText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
                 if (!userAbort && isQuotaError(thrownText)) {
                     const limits = quotaLimitsFromError(this.id, thrownText);
+                    if (!delivered && await this.waitForSessionReset(req, limits))
+                        continue;
                     return { text: quotaMessage(this.id, thrownText, limits), toolCalls: [], stopReason: "error", ...(limits ? { limits } : {}) };
                 }
                 if (delivered)

package/dist/remote/cifratura.d.ts

@@ -0,0 +1,12 @@
+export type Direzione = "ev" | "cmd";
+export declare class CifraturaError extends Error {
+    readonly code: "chiave" | "corpo" | "autenticazione";
+    constructor(code: "chiave" | "corpo" | "autenticazione");
+}
+export declare function nuovaChiave(): Promise<{
+    readonly chiave: CryptoKey;
+    readonly testo: string;
+}>;
+export declare function importaChiave(testo: string): Promise<CryptoKey>;
+export declare function cifra(chiave: CryptoKey, sessione: string, direzione: Direzione, dati: unknown): Promise<string>;
+export declare function decifra(chiave: CryptoKey, sessione: string, direzione: Direzione, b: string): Promise<unknown>;

package/dist/remote/cifratura.js

@@ -0,0 +1,66 @@
+// Cifratura fra Talos e i dispositivi abbinati (telefono, web): AES-256-GCM.
+//
+// La chiave nasce qui, una per sessione, e arriva al telefono solo dentro il
+// link di abbinamento, dopo il "#": il browser non manda mai quella parte a
+// nessun server. Relay, Redis, Kafka e Flink vedono solo testo cifrato.
+//
+// Formato del campo `b`: base64url(iv 12 byte || testo cifrato con tag).
+// I dati aggiuntivi autenticati legano ogni messaggio alla sessione e alla
+// direzione: il relay non puo' spostare un evento in un'altra sessione ne'
+// far passare un evento di Talos per un comando del telefono.
+const TE = new TextEncoder();
+const TD = new TextDecoder();
+const VERSIONE = "vascend-relay/1";
+export class CifraturaError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+function subtle() {
+    const s = globalThis.crypto?.subtle;
+    if (!s)
+        throw new CifraturaError("chiave");
+    return s;
+}
+function aad(sessione, direzione) {
+    return TE.encode(`${VERSIONE}|${sessione}|${direzione}`);
+}
+// Chiave nuova e la sua forma da mettere nel link (base64url, 43 caratteri).
+export async function nuovaChiave() {
+    const grezza = globalThis.crypto.getRandomValues(new Uint8Array(32));
+    const chiave = await subtle().importKey("raw", grezza, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+    return { chiave, testo: Buffer.from(grezza).toString("base64url") };
+}
+export async function importaChiave(testo) {
+    if (!/^[A-Za-z0-9_-]{43}$/.test(testo))
+        throw new CifraturaError("chiave");
+    return subtle().importKey("raw", Buffer.from(testo, "base64url"), { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+export async function cifra(chiave, sessione, direzione, dati) {
+    const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+    const ct = new Uint8Array(await subtle().encrypt({ name: "AES-GCM", iv, additionalData: aad(sessione, direzione) }, chiave, TE.encode(JSON.stringify(dati))));
+    const out = new Uint8Array(12 + ct.length);
+    out.set(iv);
+    out.set(ct, 12);
+    return Buffer.from(out).toString("base64url");
+}
+export async function decifra(chiave, sessione, direzione, b) {
+    if (typeof b !== "string" || b.length < 40 || !/^[A-Za-z0-9_-]+$/.test(b))
+        throw new CifraturaError("corpo");
+    const raw = Buffer.from(b, "base64url");
+    let chiaro;
+    try {
+        chiaro = await subtle().decrypt({ name: "AES-GCM", iv: raw.subarray(0, 12), additionalData: aad(sessione, direzione) }, chiave, raw.subarray(12));
+    }
+    catch {
+        throw new CifraturaError("autenticazione");
+    }
+    try {
+        return JSON.parse(TD.decode(chiaro));
+    }
+    catch {
+        throw new CifraturaError("corpo");
+    }
+}

package/dist/remote/index.d.ts

@@ -0,0 +1,15 @@
+import type { AgentEvent } from "../core/types.js";
+import { type StatoRelay } from "./relay-client.js";
+import { SessioneRemota, type ManiRemote } from "./sessione-remota.js";
+export { RelayError } from "./relay-client.js";
+export type { StatoRelay } from "./relay-client.js";
+export declare function collegaMani(m: ManiRemote | null): void;
+export declare function sessioneRemota(): SessioneRemota | null;
+export declare function avviaRemoto(env: NodeJS.ProcessEnv, cwd: string, eventi?: {
+    readonly onStato?: (stato: StatoRelay, motivo?: string) => void;
+    readonly onPresenza?: (n: number) => void;
+}): Promise<SessioneRemota>;
+export declare function fermaRemoto(): Promise<boolean>;
+export declare function osservaEvento(event: AgentEvent): void;
+export declare function messaggioUtente(testo: string): void;
+export declare function permessoConGara(azione: string, dettaglio: string, signal: AbortSignal, tui: (signal: AbortSignal) => Promise<boolean>): Promise<boolean>;

package/dist/remote/index.js

@@ -0,0 +1,65 @@
+// Controllo remoto di Talos: una sessione per processo, accesa con /remote.
+// La TUI chiama queste funzioni nei suoi punti di passaggio (eventi
+// dell'agente, messaggi dell'utente, permessi): a controllo spento non fanno
+// niente e non costano niente.
+import { RELAY_RESOURCE, tokenRisorsa } from "../tui/vascend-id.js";
+import { RelayError, relayOf } from "./relay-client.js";
+import { SessioneRemota } from "./sessione-remota.js";
+export { RelayError } from "./relay-client.js";
+let mani = null;
+let attiva = null;
+let avvio = null;
+// La TUI si presenta una volta: senza mani (input classico) il remoto non parte.
+export function collegaMani(m) { mani = m; }
+export function sessioneRemota() { return attiva; }
+export async function avviaRemoto(env, cwd, eventi = {}) {
+    if (attiva)
+        return attiva;
+    if (avvio)
+        return avvio;
+    if (!mani)
+        throw new RelayError("risposta");
+    const token = async () => {
+        const esito = await tokenRisorsa(env, RELAY_RESOURCE);
+        if (esito.token)
+            return esito.token;
+        throw new RelayError(esito.errore === "rete" ? "rete" : "token");
+    };
+    avvio = SessioneRemota.avvia({
+        base: relayOf(env),
+        cwd,
+        mani,
+        token,
+        onStato: (stato, motivo) => {
+            // Chiusa dal relay (altro dispositivo, piano scaduto): il remoto si spegne.
+            if (stato === "chiuso" && attiva)
+                attiva = null;
+            eventi.onStato?.(stato, motivo);
+        },
+        onPresenza: eventi.onPresenza,
+    });
+    try {
+        attiva = await avvio;
+        return attiva;
+    }
+    finally {
+        avvio = null;
+    }
+}
+export async function fermaRemoto() {
+    const s = attiva;
+    attiva = null;
+    if (!s)
+        return false;
+    await s.chiudi();
+    return true;
+}
+export function osservaEvento(event) {
+    attiva?.osserva(event);
+}
+export function messaggioUtente(testo) {
+    attiva?.messaggioUtente(testo);
+}
+export function permessoConGara(azione, dettaglio, signal, tui) {
+    return attiva ? attiva.permessoConGara(azione, dettaglio, signal, tui) : tui(signal);
+}