talos-code 0.1.0 → 0.2.0

package/dist/provider/openrouter-login.js

@@ -0,0 +1,172 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/*
+ * P21 (owner, 2026-09-26: "la possibilità di fare accesso oauth con Open Router, come fa l'applicazione desktop"; decisions
+ * the same day): sign in to OpenRouter from the CLI without pasting a key. The end of the flow is a plain OpenRouter API key,
+ * stored like a pasted one.
+ *
+ * The PKCE arithmetic is the desktop's own (`harness-ui/src/openrouter-oauth.mjs`, researched 2026-09-10 on OpenRouter's
+ * OAuth PKCE docs and RFC 7636): S256 always, the verifier never leaves this process, a single-use code that OpenRouter lets
+ * live 10 minutes, `state` carried in the callback PATH because OpenRouter documents no `state`, and error codes without
+ * response bodies. This file adds what a CLI needs, read on 2026-09-26:
+ * - a one-shot loopback server on 127.0.0.1 and a port the system picks, open only while the sign-in lasts (RFC 8252 §7.3,
+ *   §8.3: the IP literal, not `localhost`; listen on loopback only; close the port once the answer is in); the system browser,
+ *   never an embedded one (§8.12). Pi (`packages/ai/src/auth/oauth/openrouter.ts`) and Hermes (`hermes_cli/auth_openrouter.py`)
+ *   do the same, Codex for its own sign-in (`codex-rs/login/src/server.rs`);
+ * - a code pasted by hand, raced against the browser (Pi): the code alone or the whole address the browser landed on;
+ * - a remote session (SSH) goes to OpenRouter's no-callback mode at once, where the page SHOWS the code (Hermes).
+ */
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/** The desktop's PKCE module, from the checkout or from the package's own copy of the kernel (`vendor/harness-ui`). */
+export async function loadOpenRouterOAuth(repoRoot) {
+    return await import(__rewriteRelativeImportExtension(pathToFileURL(join(repoRoot, 'harness-ui', 'src', 'openrouter-oauth.mjs')).href));
+}
+/** What OpenRouter writes beside the key on the person's key page, so they can tell which program asked and revoke it. */
+export const LOGIN_LABEL = 'TALOS CLI';
+/** OpenRouter's code lives 10 minutes ("The code is single-use and expires after 10 minutes"); the wait is the same. */
+export const LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
+const EXCHANGE_TIMEOUT_MS = 30_000;
+export function isRemoteSession(env = process.env) {
+    return Boolean(env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY);
+}
+/** The code in what the person pasted: the code itself, or the address (or query) the browser landed on. */
+export function codeFromInput(input) {
+    const value = String(input ?? '').trim();
+    if (!value)
+        return null;
+    try {
+        const url = new URL(value);
+        return url.searchParams.get('code') || null;
+    }
+    catch { /* not an address */ }
+    if (value.includes('code=')) {
+        const code = new URLSearchParams(value.replace(/^[^?]*\?/u, '')).get('code');
+        return code || null;
+    }
+    return /\s/u.test(value) ? null : value;
+}
+/**
+ * Opens the address in the system browser, without a shell (on Windows `&` in an address would split a `cmd` line).
+ * A test profile never opens a window: the address is only shown.
+ */
+export function openInBrowser(url, { env = process.env, platform = process.platform, spawnImpl = spawn } = {}) {
+    if (env.TALOS_TEST_PROFILE === '1')
+        return false;
+    if (!/^https:\/\//u.test(url))
+        return false;
+    const [command, args] = platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]] : platform === 'darwin' ? ['open', [url]] : ['xdg-open', [url]];
+    try {
+        const child = spawnImpl(command, args, { detached: true, stdio: 'ignore', windowsHide: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class OpenRouterLoginError extends Error {
+    code;
+    status;
+    constructor(code, message, status = null) { super(message); this.name = 'OpenRouterLoginError'; this.code = code; this.status = status; }
+}
+const failure = (error) => error instanceof OpenRouterLoginError ? error : new OpenRouterLoginError(String(error?.code ?? 'OAUTH_FAILED'), 'The sign-in did not complete.', typeof error?.stato === 'number' ? error.stato : null);
+const PAGE = (title) => `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>TALOS</title></head><body style="font-family:sans-serif;margin:3em"><h1>${title}</h1></body></html>`;
+export async function startOpenRouterLogin({ oauth, env = process.env, paste = false, open = openInBrowser, fetchImpl = globalThis.fetch, timeoutMs = LOGIN_TIMEOUT_MS, label = LOGIN_LABEL }) {
+    const { verifier, challenge } = oauth.creaCoppiaPkce();
+    const state = oauth.creaStato();
+    const byHand = paste || isRemoteSession(env);
+    let settled = false, claimed = false, server = null, timer = null;
+    let resolveKey = () => { };
+    let rejectKey = () => { };
+    const key = new Promise((resolve, reject) => { resolveKey = resolve; rejectKey = reject; });
+    key.catch(() => { });
+    /* The port stops taking requests as soon as the sign-in is decided (RFC 8252 §8.3); the page the browser is waiting for is
+       still sent (a forced close there showed the person a broken connection instead of "Signed in"). Only a cancel or a
+       timeout drops the open connections too. */
+    const close = (force) => { if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    } if (server) {
+        server.close();
+        if (force)
+            server.closeAllConnections?.();
+        server = null;
+    } };
+    const finish = (outcome, force = false) => { if (settled)
+        return; settled = true; close(force); if ('key' in outcome)
+        resolveKey(outcome.key);
+    else
+        rejectKey(outcome.error); };
+    const fetchDiRete = ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(EXCHANGE_TIMEOUT_MS) }));
+    const exchange = async (code) => {
+        claimed = true;
+        try {
+            const { chiave } = await oauth.scambiaCodicePerChiave({ codice: code, verifier, fetchDiRete });
+            finish({ key: chiave });
+        }
+        catch (error) {
+            finish({ error: failure(error) });
+        }
+        return key;
+    };
+    let callbackUrl = null;
+    if (!byHand) {
+        const path = `/openrouter/callback/${encodeURIComponent(state)}`;
+        server = createServer((request, response) => {
+            const send = (status, title) => { response.statusCode = status; response.setHeader('content-type', 'text/html; charset=utf-8'); response.setHeader('cache-control', 'no-store'); response.setHeader('connection', 'close'); response.end(PAGE(title)); };
+            const requestUrl = new URL(request.url ?? '/', 'http://127.0.0.1');
+            if (request.method !== 'GET' || requestUrl.pathname !== path) {
+                send(404, 'Not found.');
+                return;
+            }
+            if (claimed || settled) {
+                send(409, 'This sign-in has already been used.');
+                return;
+            }
+            if (requestUrl.searchParams.get('error')) {
+                send(400, 'OpenRouter sign-in was cancelled. You can close this page.');
+                finish({ error: new OpenRouterLoginError('OAUTH_DENIED', 'OpenRouter sign-in was cancelled in the browser.') });
+                return;
+            }
+            const code = requestUrl.searchParams.get('code');
+            if (!code) {
+                send(400, 'OpenRouter returned no code.');
+                return;
+            }
+            void exchange(code).then(() => send(200, 'Signed in to OpenRouter. You can close this page and go back to TALOS.'), () => send(502, 'The sign-in did not complete. Go back to TALOS.'));
+        });
+        await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', () => { server.removeListener('error', reject); resolve(); }); });
+        const address = server.address();
+        if (!address || typeof address === 'string') {
+            close(true);
+            throw new OpenRouterLoginError('OAUTH_CALLBACK_UNAVAILABLE', 'TALOS could not listen for OpenRouter on this machine.');
+        }
+        callbackUrl = `http://127.0.0.1:${address.port}${path}`;
+    }
+    const url = oauth.indirizzoDiAutorizzazione({ challenge, callbackUrl, etichetta: label });
+    timer = setTimeout(() => finish({ error: new OpenRouterLoginError('OAUTH_TIMEOUT', 'The sign-in took longer than 10 minutes.') }, true), timeoutMs);
+    timer.unref?.();
+    const opened = byHand ? false : open(url);
+    return {
+        url, mode: byHand ? 'paste' : 'browser', opened, key,
+        async submit(input) {
+            if (settled || claimed)
+                return key;
+            const code = codeFromInput(input);
+            if (!code)
+                throw new OpenRouterLoginError('OAUTH_CODE_MISSING', 'That is not a code from OpenRouter.');
+            return exchange(code);
+        },
+        cancel() { finish({ error: new OpenRouterLoginError('OAUTH_CANCELLED', 'The sign-in was cancelled.') }, true); },
+    };
+}

package/dist/runtime/context-archive.js

@@ -0,0 +1,69 @@
+/*
+ * P12 (owner, 2026-09-25, "quando riprendo sessione mi dà CTX_HISTORY_DIVERGED"). Measured on a copy of the owner's
+ * session and Context Engine archive: the archive held 10 messages, the last an assistant message with a tool call and NO
+ * result (12:16:45, the turn interrupted there); the session's own history had dropped that unanswered call, as it must (a
+ * call without its result is not sent back to a model), and gone on with the next person's messages. From then on the
+ * archive was no longer a prefix of the history, `syncOriginals` (harness-ui/src/context-desktop-service.mjs:202) refused
+ * every turn, and the session could not be resumed.
+ * Where the unanswered call came from: the kernel archives the whole history at several points of a turn, among them
+ * right after the model's answer, BEFORE the tools run (talosHarness.mjs `capture` reason 'response'). The cure, on the
+ * CLI's side of the bridge (the kernel and the service are not edited): `capture` never archives an assistant message
+ * whose tool calls do not all have a result yet, nor the partial results after it. The next capture, once the results
+ * are in, archives the exchange whole; if the turn stops first, nothing unanswered was archived. The archive stays a
+ * prefix of the history in both cases.
+ */
+/** The longest prefix of `messages` that does not end inside an unanswered tool exchange. */
+export function archivableHistory(messages) {
+    const rows = messages;
+    for (let index = rows.length - 1; index >= 0; index--) {
+        const message = rows[index];
+        if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0)
+            continue;
+        const wanted = new Set(message.tool_calls.map((call) => call?.id).filter((id) => typeof id === 'string' && id));
+        for (let later = index + 1; later < rows.length && rows[later]?.role === 'tool'; later++)
+            wanted.delete(rows[later].tool_call_id);
+        /* The last tool exchange decides: complete, the whole history is archivable; unanswered, it and what follows wait. */
+        return wanted.size === 0 ? [...messages] : messages.slice(0, index);
+    }
+    return [...messages];
+}
+/*
+ * The same measurement found a race: `syncOriginals` reads the session revision, then appends with it
+ * (context-desktop-service.mjs:199-204), while a Context Engine compaction running in the background can commit a version
+ * in between (outside that session's queue). The append is then refused with CTX_STALE_REVISION and the TURN failed
+ * (r5a-coord-ce-compaction: 3 of 8 runs once capture waited for whole tool exchanges, 0 of 11 before; the race existed
+ * before too, only rarer). A retry is safe: `syncOriginals` rereads the revision and appends only what is missing, and
+ * `prepare` recomputes from the archive. So `capture` and `prepare` retry a stale revision, briefly.
+ * The shape follows Hermes' SQLite write retry (hermes_state.py:467-489, read 2026-09-26): patience is TIME-based, since
+ * "attempt-counted budgets destroyed turns on a healthy store", and each wait is RANDOM (20-150 ms), so two writers that
+ * lost the same race do not collide again in step (the "full jitter" of AWS's "Exponential Backoff and Jitter"). The
+ * budget is short, like Hermes' wait on a live compression lock: a compaction's commit is one write, and the revision reread
+ * after it succeeds; a revision that keeps moving for two seconds is a real conflict, and the error goes on.
+ */
+const STALE_PATIENCE_MS = 2_000, STALE_WAIT_MIN_MS = 20, STALE_WAIT_MAX_MS = 150;
+async function retryStale(operation, patienceMs) {
+    const deadline = Date.now() + patienceMs;
+    for (;;) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const remaining = deadline - Date.now();
+            if (error?.code !== 'CTX_STALE_REVISION' || remaining <= 0)
+                throw error;
+            const wait = STALE_WAIT_MIN_MS + Math.random() * (STALE_WAIT_MAX_MS - STALE_WAIT_MIN_MS);
+            await new Promise(resolve => setTimeout(resolve, Math.min(wait, remaining)));
+        }
+    }
+}
+/** The service's kernel hooks: `capture` archives only whole tool exchanges; `capture` and `prepare` retry a stale revision. */
+export function withArchivableCapture(hooks, { stalePatienceMs = STALE_PATIENCE_MS } = {}) {
+    if (!hooks || typeof hooks.capture !== 'function')
+        return hooks;
+    const capture = hooks.capture, prepare = hooks.prepare;
+    return {
+        ...hooks,
+        capture: (input) => retryStale(() => capture({ ...input, messages: Array.isArray(input?.messages) ? archivableHistory(input.messages) : input?.messages }), stalePatienceMs),
+        ...(typeof prepare === 'function' ? { prepare: (input) => retryStale(() => prepare(input), stalePatienceMs) } : {}),
+    };
+}

package/dist/runtime/supervisor.js

@@ -158,9 +158,12 @@ export function createRuntimeSupervisor(options) {
                 return;
             const sequence = nativeSequence(event);
             if (sequence !== null) {
-                const added = replay.push(sessionId, event);
-                if (!added || sequence <= cursor)
+                /* P13 (2026-09-26): what this subscriber has seen is ITS cursor. The buffer is shared by every subscriber of the
+                   session, so "already in the buffer" dropped the whole history of a second subscriber (a reopened agent view came
+                   up empty); it still records the event, and a different event at a known sequence still throws a conflict. */
+                if (sequence <= cursor)
                     return;
+                replay.push(sessionId, event);
                 cursor = sequence;
             }
             sink(event);

package/dist/runtime/talos-composition.js

@@ -12,6 +12,7 @@ import { secretValuesFromEnvironment } from "../diagnostics/redact.js";
 import { isTestProfile } from "../provider/store.js";
 import { compactionEvent, createCliEventHub, createRunObserver, RETRY_AFTER_MAX_MS, summaryRequestedEvent } from "./provider-attempts.js";
 import { createToolOutputStore, pruneToolOutput } from "./output-store.js";
+import { withArchivableCapture } from "./context-archive.js";
 import { CONTEXT_ENGINE_MIN_WINDOW, configureModelProfiles, createModelsDevLoader, modelProfile, modelProfileEvidence, ollamaWindow, rememberOllamaWindow, setModelOverrides } from "./model-profile.js";
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
@@ -34,7 +35,7 @@ import { attachKeyOrigin, createEnvironmentKeyConsent, describeKeyOrigin, provid
 import { createProviderControlPlane } from "../provider/control-plane.js";
 function remapService(s) { return s.replace(/^talos-harness-/u, 'talos-cli-'); }
 function contextProfileValue(value) { return Number.isSafeInteger(value) && Number(value) > 0 ? Number(value) : null; }
-function createCliContextBridge({ repoRoot, paths, registry, providerRegistry, providerStore, ownerRuntime, chatImageStore, separaFonteModello, prepareProfile, onSummaryRequest }) {
+export function createCliContextBridge({ repoRoot, paths, registry, providerRegistry, providerStore, ownerRuntime, chatImageStore, separaFonteModello, prepareProfile, onSummaryRequest }) {
     /*
      * ⭐ R5a lane R, S2 (owner decision Q-R5-3): the profile — window and reserve — comes from `modelProfile` (model-profile.ts),
      * which layers the person's override, a local Ollama's own window, the provider's rows, the registry's documented rows and
@@ -215,8 +216,10 @@ function createCliContextBridge({ repoRoot, paths, registry, providerRegistry, p
         return service.request({ sessionId, method: 'GET', path: '/' });
     };
     return {
+        /* P12: `capture` archives only whole tool exchanges (context-archive.ts), so an interrupted turn cannot leave an
+           unanswered call in the archive that the history then drops (CTX_HISTORY_DIVERGED on every later turn). */
         async hooks(input) { await prepareForSession(input.sessionId); const profile = profileForSession(input.sessionId); if (!profile)
-            return undefined; const { service } = await load(); await ensureSettings(service, input.sessionId); return service.createKernelHooks(input); },
+            return undefined; const { service } = await load(); await ensureSettings(service, input.sessionId); return withArchivableCapture(await service.createKernelHooks(input)); },
         async compact(input) { await prepareForSession(input.sessionId); const profile = profileForSession(input.sessionId); if (!profile)
             return undefined; const { service } = await load(); await ensureSettings(service, input.sessionId); return service.compact(input); },
         async status(sessionId) {
@@ -962,6 +965,8 @@ export async function composeTalosRuntime({ repoRoot, projectRoot, paths, model,
         createProbe: storeProbe, environmentKey: (id) => environmentKeys === 'use' ? null : consent.stateFor(id),
     });
     tuiCatalog = createTuiCatalogService({
+        /* P21: OpenRouter sign-in with the kernel's PKCE module (the checkout's, or the package's vendor copy). */
+        openRouterLogin: async (input) => { const { loadOpenRouterOAuth, startOpenRouterLogin } = await import("../provider/openrouter-login.js"); return startOpenRouterLogin({ oauth: await loadOpenRouterOAuth(repoRoot), ...(input?.paste ? { paste: true } : {}) }); },
         publicProviders: () => { try {
             return providerStore.listPublic?.() ?? [];
         }

package/dist/tui/agent-view.js

@@ -0,0 +1,51 @@
+import { createTuiEventAdapter } from "./event-adapter.js";
+import { createTranscriptModel, reduceTranscriptEvent } from "./transcript-model.js";
+const TERMINAL = new Set(['run.completed', 'run.failed', 'run.cancelled']);
+/** Folds a child's events into its view: the transcript, and whether its run is running or over. */
+export function reduceAgentView(state, event) {
+    const transcript = reduceTranscriptEvent(state.transcript, event);
+    if (event.type === 'run.started')
+        return { ...state, transcript, running: true, done: false };
+    if (TERMINAL.has(event.type))
+        return { ...state, transcript, running: false, done: true };
+    return transcript === state.transcript ? state : { ...state, transcript };
+}
+export function createAgentView({ runtime, target, secretValues = [], onChange, batchMs = 16 }) {
+    const adapter = createTuiEventAdapter(secretValues);
+    adapter.bindSession(target.sessionId);
+    let state = { ...target, transcript: createTranscriptModel(), running: false, done: false };
+    let replaying = true, closed = false, timer = null;
+    /* A streamed answer is many small events: the screen is told at most once per frame. */
+    const notify = () => {
+        if (closed || replaying || timer)
+            return;
+        timer = setTimeout(() => { timer = null; if (!closed)
+            onChange(state); }, batchMs);
+    };
+    let off = () => { };
+    try {
+        off = runtime.subscribe(target.sessionId, raw => {
+            if (closed)
+                return;
+            for (const event of adapter.translateAll(raw))
+                state = reduceAgentView(state, replaying && event.type === 'run.started' ? { ...event, history: true } : event);
+            notify();
+        });
+    }
+    finally {
+        replaying = false;
+    }
+    if (!closed)
+        onChange(state);
+    return {
+        state: () => state,
+        close() { if (closed)
+            return; closed = true; if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        } try {
+            off();
+        }
+        catch { /* nothing left to undo */ } },
+    };
+}