oakode 0.0.0-stage → 0.5.1

package/dist/main.js

@@ -0,0 +1,560 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { realpathSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { Agent } from "./agent.js";
+import { App } from "./app.js";
+import { Auth, clientIdSetting } from "./auth.js";
+import { billingLines } from "./account.js";
+import { CreditRate } from "./agents/budget.js";
+import { SubagentHost } from "./agents/host.js";
+import { subagentSettings } from "./agents/types.js";
+import { doctor } from "./doctor.js";
+import { refreshUpdateCache, updateCheckEnabled, updateNotice } from "./update.js";
+import { VERSION, baseUrl, configProblem, home, loadConfig, readJson, saveConfig, skillExcludes, writeJson } from "./config.js";
+import { join } from "node:path";
+import { explain } from "./errors.js";
+import { allowedModel, compatibilityNotice, curatedModels, defaultModel, describeModel, experimentalHint, experimentalModels, ignoredDefaultNotice, matchModels, notSupported, selectableModels } from "./models.js";
+import { makePrintEmitter, readAll } from "./print.js";
+import { OickiClient, OickiError } from "./oicki.js";
+import { Session } from "./session.js";
+import { killAllChildren } from "./tools.js";
+import { removeOutput, sweepOldOutput } from "./jobs.js";
+import { Tui } from "./tui/tui.js";
+import { ProjectTrust } from "./permissions.js";
+import { Mcp } from "./mcp.js";
+import { Skills } from "./skills.js";
+import { ago, bold, dim, gray, green, red, yellow } from "./ui.js";
+const HELP = `oakode ${VERSION} - coding agent powered by OICKI
+
+Usage:
+  oakode [options] [prompt]       interactive session (or one-shot with -p)
+  oakode login                    sign in with your OICKI account in the browser
+      --no-browser                  print the sign-in link instead of opening it (remote machines)
+      --expensive                   also allow expensive models
+      --api-key                     use an OICKI API key instead (hidden input, verified with OICKI)
+  oakode logout                   remove the credentials stored on this computer
+  oakode status                   account, credits and which credentials are in use
+  oakode doctor                   check the installation, credentials and connection
+  oakode models [all|text]        supported models, or search them (the whole catalog with experimentalModels)
+  oakode sessions                 your previous sessions in this directory
+
+Options:
+  -p, --print            run the prompt non-interactively and exit
+  -m, --model ID         a supported model (default: auto; others need "experimentalModels": true in config.json)
+  -c, --continue         resume the latest session in this directory
+  -r, --resume ID        resume a session by id (see: oakode sessions)
+  -y, --yes              NO APPROVAL PROMPTS: writes, edits and shell commands run unattended
+  -h, --help  -v, --version
+
+Inside a session type / for commands (/help lists them). Enter sends; Ctrl+J, Alt+Enter or Shift+Enter (kitty-style
+terminals) insert a newline. Pasted text is never sent by itself. Typing while the agent works queues a message.
+Esc or Ctrl+C interrupts a running turn. Every write, edit and shell command asks first. Approval is not a sandbox.
+Environment: OICKI_API_KEY, OAKODE_HOME, OAKODE_BASE_URL, OAKODE_CLIENT_ID, OAKODE_REDIRECT_PORT, OAKODE_MAX_OUTPUT_TOKENS,
+OAKODE_REASONING_EFFORT, OAKODE_NO_UPDATE_CHECK. Docs: README.md · problems: oakode doctor`;
+// a mistyped flag gets one line and a pointer to --help, not a stack trace
+const { values: opt, positionals } = (() => {
+    try {
+        return parseArgs({
+            allowPositionals: true,
+            options: {
+                print: { type: "boolean", short: "p" },
+                model: { type: "string", short: "m" },
+                continue: { type: "boolean", short: "c" },
+                resume: { type: "string", short: "r" },
+                yes: { type: "boolean", short: "y" },
+                help: { type: "boolean", short: "h" },
+                version: { type: "boolean", short: "v" },
+                "client-id": { type: "string" },
+                expensive: { type: "boolean" },
+                "api-key": { type: "boolean" },
+                "no-browser": { type: "boolean" },
+            },
+        });
+    }
+    catch (e) {
+        console.error(`oakode: ${e.message}\nSee \`oakode --help\`.`);
+        process.exit(2);
+    }
+})();
+if (!opt.help && !opt.version && configProblem())
+    console.error(yellow(configProblem())); // config.json is edited by hand
+const auth = new Auth();
+sweepOldOutput(); // output folders a crashed OAKODE left behind (a day old)
+auth.onSwitch = (m) => process.stderr.write(`oakode: ${m}\n`); // the interactive app shows it in the conversation
+const client = new OickiClient(baseUrl(), auth);
+const cwd = realpathSync.native(process.cwd()); // native: one spelling of a Windows drive letter, so sessions are found again
+const interactive = !opt.print && process.stdin.isTTY === true;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let tui;
+let printAbort;
+let printTurn;
+let app;
+let shuttingDown = false;
+let activeSession;
+/**
+ * The one teardown order for every exit path. The terminal comes LAST because restoring it can block when the
+ * terminal has stopped reading; everything that matters (commands, session data, locks) is settled before that.
+ */
+let cleaned = false;
+function cleanup() {
+    if (cleaned)
+        return;
+    cleaned = true;
+    try {
+        killAllChildren("SIGKILL");
+    }
+    catch { }
+    try {
+        removeOutput();
+    }
+    catch { }
+    try {
+        const dump = activeSession && !activeSession.flush() ? activeSession.emergencyDump() : undefined;
+        if (dump)
+            console.error(`Unsaved session entries were written to ${dump}`);
+    }
+    catch { }
+    try {
+        activeSession?.release();
+    }
+    catch { }
+    tui?.stop();
+}
+/** SIGTERM/SIGHUP/SIGINT: stop the turn (so every tool call gets a recorded result), then tear down. */
+async function shutdown(code) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    if (app?.currentTurn)
+        app.session.recordTurnEnd("terminated", `OAKODE received a stop signal while a turn was running`);
+    app?.abort?.abort();
+    printAbort?.abort();
+    tui?.cancelMenu();
+    await Promise.race([app?.currentTurn ?? printTurn ?? Promise.resolve(), sleep(3000)]);
+    cleanup();
+    process.exit(code);
+}
+process.on("SIGTERM", () => void shutdown(143));
+process.on("SIGHUP", () => void shutdown(129));
+process.on("SIGINT", () => void shutdown(130)); // raw-mode Ctrl+C is a key, not a signal; this is an external SIGINT
+process.on("exit", cleanup);
+process.on("uncaughtException", (e) => {
+    console.error(red(`Fatal: ${e.stack ?? e}`));
+    cleanup();
+    process.exit(1);
+});
+const howToSignIn = () => clientIdSetting()
+    ? "Run `oakode login` to sign in with your OICKI account (or set OICKI_API_KEY)."
+    : "Create an API key at https://oicki.vercel.app/dashboard/developer, then run `oakode login --api-key` (or set OICKI_API_KEY).";
+/** One keypress answer; Enter means yes. */
+async function askYesNo(prompt) {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    const ch = await new Promise((resolve) => stdin.once("data", (d) => resolve(d.toString()[0] ?? "")));
+    if (stdin.isTTY)
+        stdin.setRawMode(false);
+    stdin.pause();
+    process.stdout.write("\n");
+    if (ch === "\u0003")
+        process.exit(130);
+    return !/^[nN]/.test(ch);
+}
+async function readSecret(prompt) {
+    process.stderr.write(prompt);
+    return new Promise((resolve) => {
+        let buf = "";
+        const stdin = process.stdin;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        const onData = (d) => {
+            for (const ch of d.toString()) {
+                if (ch === "\r" || ch === "\n" || ch === "\u0004") {
+                    if (stdin.isTTY)
+                        stdin.setRawMode(false);
+                    stdin.off("data", onData);
+                    stdin.pause();
+                    process.stderr.write("\n");
+                    return resolve(buf.trim());
+                }
+                if (ch === "\u0003")
+                    process.exit(130);
+                if (ch === "\u007f")
+                    buf = buf.slice(0, -1);
+                else
+                    buf += ch;
+            }
+        };
+        stdin.on("data", onData);
+        stdin.once("end", () => resolve(buf.trim())); // input closed (piped, </dev/null): whatever arrived, or nothing
+    });
+}
+/** Non-billable: GET /v1/me identifies the API key (and proves OICKI accepts it). */
+async function checkKey(key) {
+    try {
+        const r = await fetch(baseUrl() + "/v1/me", { headers: { Authorization: `Bearer ${key}`, "User-Agent": `oakode/${VERSION}` }, signal: AbortSignal.timeout(10_000) });
+        if (r.ok)
+            return { state: "ok", label: String((await r.json()).label ?? "") };
+        if (r.status === 401)
+            return { state: "rejected" };
+        return { state: "unreachable", detail: `HTTP ${r.status}` };
+    }
+    catch (e) {
+        return { state: "unreachable", detail: e.message };
+    }
+}
+/** Ask for a key (hidden), verify it, store it (0600). Returns false if the user entered nothing. */
+async function promptForKey() {
+    const key = await readSecret("OICKI API key (input hidden, Enter to cancel): ");
+    if (!key)
+        return false;
+    if (!key.startsWith("oicki_sk_"))
+        throw new Error("That does not look like an OICKI API key (they start with oicki_sk_).");
+    const r = await checkKey(key);
+    if (r.state === "rejected")
+        throw new Error("OICKI rejected that key (401). Check that you copied all of it and that it has not been revoked. Nothing was saved.");
+    auth.setApiKey(key);
+    console.log(green(r.state === "ok" ? `Key saved and verified${r.label ? ` (label "${r.label}")` : ""}.` : `Key saved, but it could not be verified (${r.detail}). If requests fail, check your connection.`));
+    return true;
+}
+async function cmdLogin() {
+    if (opt["api-key"]) {
+        if (!(await promptForKey())) {
+            console.log("Cancelled; nothing saved.");
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (!opt["client-id"] && !clientIdSetting()) {
+        console.log(`Browser sign-in is not available in this build of OAKODE yet. Use an API key instead:\n  ${bold("oakode login --api-key")}`);
+        process.exitCode = 1;
+        return;
+    }
+    const ctl = new AbortController();
+    const onInt = () => ctl.abort();
+    process.once("SIGINT", onInt);
+    try {
+        const { scopes } = await auth.login({ clientId: opt["client-id"], expensive: opt.expensive, noBrowser: opt["no-browser"], log: (s) => console.log(s), signal: ctl.signal });
+        if (opt["client-id"])
+            saveConfig({ clientId: opt["client-id"] });
+        console.log(green("\n✓ Signed in to OICKI."));
+        if (!scopes.includes("billing:read"))
+            console.log(yellow("Credits will not be shown: the sign-in did not include \"see your plan and credits\"."));
+        if (opt.expensive && !scopes.includes("models:expensive"))
+            console.log(yellow("Expensive models were not allowed in the browser; they stay unavailable."));
+        const b = await client.billing(AbortSignal.timeout(10_000)).catch(() => undefined);
+        for (const l of billingLines(b, "oauth"))
+            console.log(l);
+        console.log(dim(`Credentials saved in ${home()}/auth.json (readable only by you). Start with: oakode`));
+    }
+    finally {
+        process.off("SIGINT", onInt);
+    }
+}
+async function cmdLogout() {
+    const kind = auth.source();
+    const revoked = await auth.logout();
+    rmSync(join(home(), "models-cache.json"), { force: true });
+    if (kind === "none")
+        return console.log("You were not signed in on this computer.");
+    console.log("Signed out: the credentials stored on this computer were deleted.");
+    if (kind === "oauth")
+        console.log(revoked ? dim("OICKI ended this sign-in (other computers stay signed in).") : yellow("OICKI could not be reached to end the sign-in; it expires on its own within 30 days, or remove OAKODE under Connected apps in your OICKI account."));
+    if (kind === "env")
+        console.log(yellow("OICKI_API_KEY is still set in your environment and will keep being used."));
+}
+async function cmdStatus() {
+    const src = auth.source();
+    console.log(`${bold("OAKODE")} ${VERSION}  ·  server ${baseUrl()}  ·  data ${home()}`);
+    if (src === "none") {
+        console.log(red("Not signed in."), howToSignIn());
+        process.exitCode = 1;
+        return;
+    }
+    if (src === "oauth") {
+        console.log(`Credentials: signed in with OICKI (scopes: ${auth.scopes().join(" ") || "?"}).`);
+        try {
+            await client.whoami(AbortSignal.timeout(10_000)); // proves the sign-in works, whatever was granted
+            console.log(green("OICKI accepts the sign-in."));
+            const b = await client.billing(AbortSignal.timeout(10_000));
+            for (const l of billingLines(b, "oauth"))
+                console.log(l);
+        }
+        catch (e) {
+            console.log(red(explain(e)));
+            process.exitCode = 1;
+        }
+    }
+    else {
+        console.log(`Credentials: API key ${src === "env" ? "from $OICKI_API_KEY" : `stored in ${home()}/auth.json`}.`);
+        let key;
+        try {
+            key = await auth.token();
+        }
+        catch (e) {
+            console.log(red(explain(e)));
+            process.exitCode = 1;
+            return;
+        }
+        const r = await checkKey(key);
+        if (r.state === "ok") {
+            const u = (await fetch(baseUrl() + "/v1/usage", { headers: { Authorization: `Bearer ${await auth.token()}` } }).then((x) => x.json()).catch(() => undefined));
+            console.log(green(`OICKI accepts it${r.label ? ` (label "${r.label}")` : ""}.`) + (u?.requestCount !== undefined ? ` Usage on this key: ${u.requestCount} requests, ${u.inputTokens} in / ${u.outputTokens} out tokens.` : ""));
+        }
+        else if (r.state === "rejected") {
+            console.log(red("OICKI rejected this key (401)."), `Replace it with ${bold("oakode login --api-key")}.`);
+            process.exitCode = 1;
+        }
+        else
+            console.log(yellow(`Could not reach OICKI to verify (${r.detail}).`));
+    }
+    const def = defaultModel();
+    console.log(`Default model: ${def.id}${def.ignored ? yellow(` (saved "${def.ignored}" is not supported, so ignored)`) : ""}  ·  sessions in this directory: ${Session.list(cwd).length}`);
+}
+function cmdSessions() {
+    const list = Session.list(cwd, 20);
+    if (!list.length)
+        return console.log(`No sessions for ${cwd}. Start one with ${bold("oakode")}.`);
+    console.log(bold(`Sessions in ${cwd}`));
+    for (const x of list)
+        console.log(`  ${x.id}  ${ago(x.mtime).padEnd(9)} ${(x.messages === undefined ? "large" : x.messages + " msgs").padEnd(9)} ${x.preview}`);
+    console.log(dim(`Resume the latest: oakode -c   ·   a specific one: oakode -r <id>`));
+}
+async function main() {
+    if (opt.help)
+        return console.log(HELP);
+    if (opt.version)
+        return console.log(VERSION);
+    const [cmd, ...rest] = positionals;
+    if (cmd === "login")
+        return cmdLogin();
+    if (cmd === "logout")
+        return cmdLogout();
+    if (cmd === "status")
+        return cmdStatus();
+    if (cmd === "doctor")
+        return void (process.exitCode = (await doctor(auth, client, cwd)) ? 0 : 1);
+    if (interactive && !cmd && updateCheckEnabled()) {
+        const n = updateNotice();
+        if (n)
+            console.error(yellow(n));
+        void refreshUpdateCache();
+    }
+    if (cmd === "sessions")
+        return cmdSessions();
+    if (cmd === "models") {
+        const catalog = await client.listModels();
+        const q = rest.join(" ");
+        const pool = (all) => (q === "all" ? all : q ? matchModels(all, q) : curatedModels(all));
+        const list = pool(selectableModels(catalog));
+        list.forEach((m) => console.log(describeModel(m)));
+        const hidden = experimentalModels() ? 0 : (q ? pool(catalog).length : catalog.length) - list.length;
+        if (!q)
+            console.error(dim(experimentalModels() ? `Supported models. Experimental models are on: oakode models all, or oakode models <text>.` : `Supported models. ${hidden} more in OICKI's catalog are experimental. ${experimentalHint()}`));
+        else
+            console.error(dim(`${list.length} model(s)${hidden ? `; ${hidden} more ${q === "all" ? "" : "matching "}are experimental. ${experimentalHint()}` : ""}`));
+        return;
+    }
+    if (auth.kind() === "none") {
+        const where = "Create an API key at https://oicki.vercel.app/dashboard/developer (leave \"Allow expensive models\" off).";
+        if (!interactive) {
+            console.error(`${red("Not signed in.")} ${howToSignIn()}`);
+            process.exit(1);
+        }
+        console.log(`${bold("Welcome to OAKODE.")} Sign in with your OICKI account to start.\n`);
+        if (clientIdSetting() && (await askYesNo("Open the browser to sign in? [Y/n] (n: use an API key instead) "))) {
+            await cmdLogin();
+            if (auth.kind() === "none")
+                process.exit(1);
+        }
+        else {
+            console.log(`${where}\nPaste the key below; it is checked with OICKI and stored in ${home()}/auth.json (readable only by you).\n`);
+            if (!(await promptForKey())) {
+                console.error(dim("No key entered. Run `oakode` again when you have one."));
+                process.exit(1);
+            }
+        }
+    }
+    // Raw mode first: keys typed while we talk to the network are captured, not left to the kernel's line editing.
+    if (interactive) {
+        tui = new Tui(process.stdin, process.stdout);
+        tui.onAbort = () => void shutdown(130); // Ctrl+C / Esc while starting
+        tui.setBusy(true); // Enter queues messages typed during startup
+        tui.footer = () => gray("starting…");
+        tui.start();
+    }
+    const fail = (e) => {
+        tui?.stop();
+        console.error(explain(e));
+        process.exit(1);
+    };
+    let models = [];
+    const cat = loadCatalog();
+    try {
+        models = await cat.models;
+    }
+    catch (e) {
+        fail(e);
+    }
+    cat.fresh?.then((fresh) => void models.splice(0, models.length, ...fresh), () => { }); // the cache was used: update in place
+    if (opt.model && !allowedModel(opt.model)) {
+        tui?.stop();
+        console.error(red(notSupported(opt.model)));
+        process.exit(2);
+    }
+    const saved = defaultModel();
+    const wanted = opt.model || saved.id;
+    let session;
+    try {
+        if (opt.resume || opt.continue) {
+            const sessions = Session.list(cwd); // only sessions recorded for this exact directory
+            // -c continues the latest session that has a conversation (files from older versions may hold none)
+            const matches = opt.resume ? sessions.filter((s) => s.id.startsWith(opt.resume)) : sessions.filter((s) => s.messages !== 0).slice(0, 1);
+            if (matches.length !== 1) {
+                tui?.stop();
+                console.error(red(matches.length ? `"${opt.resume}" matches ${matches.length} sessions; use a longer id.` : opt.resume ? `No session "${opt.resume}" for this directory. \`oakode sessions\` lists them.` : "No previous session in this directory. `oakode sessions` lists them."));
+                process.exit(1);
+            }
+            session = Session.open(matches[0].file, wanted, cwd);
+            if (opt.model)
+                session.setModel(opt.model);
+        }
+        else {
+            session = Session.create(cwd, wanted);
+        }
+    }
+    catch (e) {
+        return fail(e);
+    }
+    activeSession = session;
+    if (!models.some((m) => m.id === session.model))
+        console.error(yellow(`Model "${session.model}" is not in your model list; the server may reject it. See /models.`));
+    const resumed = !!(opt.resume || opt.continue);
+    const modelNotice = resumed && !allowedModel(session.model) ? compatibilityNotice(session.model) : !resumed && !opt.model && saved.ignored ? ignoredDefaultNotice(saved.ignored) : undefined;
+    // ---- print mode (-p, or piped stdin): plain text, no terminal control
+    if (!tui) {
+        const args = (cmd ? [cmd, ...rest] : []).join(" ").trim();
+        const piped = process.stdin.isTTY ? "" : (await readAll()).trim();
+        // with an instruction AND piped input, the model must see where the instruction ends and the data begins
+        const prompt = args && piped ? `${args}\n\n<stdin>\n${piped}\n</stdin>` : args || piped;
+        if (!prompt) {
+            console.error(red("No prompt given."));
+            process.exit(1);
+        }
+        if (opt.yes)
+            console.error(yellow("--yes: approval prompts are OFF. Writes, edits and shell commands run without asking."));
+        if (modelNotice)
+            console.error(yellow(modelNotice));
+        const out = makePrintEmitter();
+        const ctl = new AbortController();
+        printAbort = ctl;
+        const trust = new ProjectTrust(cwd);
+        const mcp = new Mcp({ cwd, trust });
+        await mcp.start();
+        const skills = new Skills({ cwd, extraDir: process.env.OAKODE_SKILLS_DIR, exclude: skillExcludes(), projectTrusted: (s, fp) => trust.skillStatus(s.name, fp) });
+        trust.endLegacyMigration();
+        // -p never delegates, except for evaluations (eval/run.ts): this variable, --yes and subagents.enabled all together
+        let parentCredits = 0;
+        const settings = subagentSettings();
+        const evalDelegation = process.env.OAKODE_EVAL_UNATTENDED_DELEGATION === "1" && !!opt.yes && settings.enabled;
+        if (evalDelegation)
+            console.error(yellow("Evaluation mode: subagent plans without validation errors are approved unattended, within the subagent budget."));
+        const subagents = evalDelegation
+            ? new SubagentHost({
+                settings, client, session: () => session, models: () => models, rate: CreditRate.stored(),
+                authorize: async () => null, // read-only tools only; print mode has no permission modes
+                confirm: async () => !!opt.yes,
+                autoApprove: () => !!opt.yes,
+                ui: { chooseFrom: async () => -1, ask: async () => null, print: () => { }, query: () => "" },
+                note: (t) => console.error(dim(t)),
+                repaint: () => { },
+                parentTurnCredits: () => parentCredits,
+                unattended: true,
+            })
+            : undefined;
+        subagents?.beginTurn();
+        const emit = (e) => {
+            if (e.type === "usage" && e.credits !== undefined)
+                parentCredits += e.credits;
+            out.emit(e);
+        };
+        // -p asks nothing: without --yes every action that needs approval is declined, and the run says so in its exit code
+        let declined = 0;
+        const agent = new Agent({ client, session, model: () => models.find((m) => m.id === session.model), lookup: (id) => models.find((m) => m.id === id), emit, confirm: async () => (opt.yes ? true : (declined++, false)), extraTools: () => [skills.tool(), ...mcp.tools(), subagents?.tool].filter((t) => !!t), systemExtra: () => skills.promptSection() });
+        let failed = false;
+        const resumeHint = dim(`The session is saved; continue it with: oakode -p -r ${session.id} "…"`);
+        const run = agent.run(prompt, ctl.signal).then(() => void (ctl.signal.aborted && console.error(yellow("\n⏹ Interrupted."))), (e) => ((failed = true), console.error("\n" + explain(e)), console.error(resumeHint)));
+        printTurn = run;
+        await run;
+        out.end();
+        await mcp.close();
+        // Scripts and CI read the exit status: 0 only for a turn that completed with nothing declined.
+        const reason = session.lastTurn?.reason;
+        const interrupted = ctl.signal.aborted || reason === "interrupted" || reason === "terminated";
+        if (!failed && !interrupted && reason && reason !== "complete")
+            console.error(yellow(`The turn did not complete (${reason}${session.lastTurn?.detail ? `: ${session.lastTurn.detail}` : ""}).`), "\n" + resumeHint);
+        if (declined)
+            console.error(yellow(`${declined} action${declined > 1 ? "s" : ""} needed approval and ${declined > 1 ? "were" : "was"} declined: -p cannot ask, so changes and commands need --yes.`));
+        process.exitCode = interrupted ? 130 : failed || (reason && reason !== "complete") || declined ? 1 : 0;
+        return;
+    }
+    // ---- interactive
+    const t = tui;
+    app = new App({ tui: t, client, auth, cwd, models, session, yes: !!opt.yes });
+    const early = t.takeQueued(); // messages submitted while starting are processed in order, as separate messages
+    let prefill = t.leftover();
+    t.setBusy(false);
+    app.banner(VERSION, resumed);
+    if (cwd === "/" || cwd === realpathSync(homedir()))
+        app.view.note(`Working directory is ${cwd}: the file tools can reach everything in it. cd into a project first.`, "warn");
+    if (opt.yes)
+        app.view.note("--yes: approval prompts are OFF. Writes, edits and shell commands run without asking.", "warn");
+    if (resumed)
+        app.resumeNotice();
+    else if (modelNotice)
+        app.view.note(modelNotice, "warn"); // resumeNotice covers a resumed session's model
+    await app.run(positionals, early, prefill);
+    await app.close();
+    cleanup();
+}
+/**
+ * The model catalog takes seconds to fetch, so start from a cached copy (under a day old, same server and kind of
+ * credential) and refresh it in the background. Without a usable cache, wait for the network; if that fails, an
+ * older cache still beats not starting.
+ */
+function loadCatalog() {
+    const file = join(home(), "models-cache.json");
+    const key = `${client.baseUrl} ${auth.kind()}`;
+    const cached = readJson(file);
+    const valid = cached?.key === key && Array.isArray(cached.data) && cached.data.length > 0 ? cached : undefined;
+    const fetched = client.listModels().then((data) => {
+        try {
+            writeJson(file, { at: Date.now(), key, data });
+        }
+        catch { }
+        return data;
+    });
+    fetched.catch(() => { }); // a failed background refresh is not an error: the cached copy is in use
+    if (valid && Date.now() - valid.at < 24 * 3600_000)
+        return { models: Promise.resolve(valid.data.slice()), fresh: fetched };
+    const models = fetched.catch((e) => {
+        // credentials problems must surface; only an unreachable or failing server falls back to the old copy
+        if (!valid || (e instanceof OickiError && (e.status === 401 || e.status === 403)))
+            throw e;
+        console.error(yellow(`Could not refresh the model list (${e.message}); using the copy from ${ago(new Date(valid.at))}.`));
+        return valid.data.slice();
+    });
+    return { models };
+}
+main().then(() => {
+    if (!shuttingDown)
+        process.exit(process.exitCode ?? 0); // a signal handler that is already shutting down owns the exit code
+}, (e) => {
+    console.error(explain(e));
+    cleanup();
+    process.exit(1);
+});

package/dist/mask.js

@@ -0,0 +1,63 @@
+export const MASK_KEEP = 30;
+export const MASK_STEP = 20;
+const BIG = 600;
+const boundary = (len, keep, step) => (len - keep < step ? 0 : Math.floor((len - keep) / step) * step);
+export const maskBoundary = (len) => boundary(len, MASK_KEEP, MASK_STEP);
+/**
+ * The model's own write/edit arguments are the biggest thing in a long coding session, and once applied the content is
+ * on disk. They are shrunk much sooner than everything else (still in steps, to keep the cached prefix stable).
+ */
+export const FILE_ARGS_KEEP = 8;
+export const FILE_ARGS_STEP = 8;
+export const fileArgsBoundary = (len) => boundary(len, FILE_ARGS_KEEP, FILE_ARGS_STEP);
+const FILE_TOOLS = new Set(["write", "edit"]);
+const bigFileCall = (c) => FILE_TOOLS.has(c.function.name) && c.function.arguments.length > BIG;
+const omitted = (n) => `[omitted ${n} chars to save context]`;
+function shrink(v) {
+    if (typeof v === "string")
+        return v.length > BIG ? omitted(v.length) : v;
+    if (Array.isArray(v))
+        return v.map(shrink);
+    if (v && typeof v === "object")
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, shrink(x)]));
+    return v;
+}
+function shrinkCall(c) {
+    if (c.function.arguments.length <= BIG)
+        return c;
+    try {
+        return { ...c, function: { ...c.function, arguments: JSON.stringify(shrink(JSON.parse(c.function.arguments))) } };
+    }
+    catch {
+        return c;
+    }
+}
+export function maskFileArgs(m) {
+    if (m.role !== "assistant" || !m.tool_calls?.some(bigFileCall))
+        return m;
+    return { ...m, tool_calls: m.tool_calls.map((c) => (bigFileCall(c) ? shrinkCall(c) : c)) };
+}
+export function maskMessage(m) {
+    if (m.role === "tool") {
+        if (m.content.length <= BIG)
+            return m;
+        const first = m.content.trimStart().split("\n")[0].slice(0, 120);
+        return { ...m, content: `[older tool result omitted to save context (${m.content.length} chars); it began: ${first}. Run the tool again if you need it.]` };
+    }
+    if (m.role === "assistant" && m.tool_calls?.length) {
+        return {
+            ...m,
+            tool_calls: m.tool_calls.map(shrinkCall),
+        };
+    }
+    if (m.role === "user" && m.images?.length) {
+        const { images, ...rest } = m;
+        return { ...rest, content: `${m.content}\n[${images.length} image${images.length > 1 ? "s" : ""} no longer in context: ${images.map((i) => i.path).join(", ")}; read the file again to see ${images.length > 1 ? "them" : "it"}]` };
+    }
+    return m;
+}
+export function maskTail(tail) {
+    const b = maskBoundary(tail.length);
+    const f = fileArgsBoundary(tail.length);
+    return b || f ? tail.map((m, i) => (i < b ? maskMessage(m) : i < f ? maskFileArgs(m) : m)) : tail;
+}