oharness 0.1.0

package/dist/ui/main.js

@@ -0,0 +1,1062 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { errorMessage } from "@oharness/engine/core/errors.ts";
+import { Harness } from "@oharness/engine/harness.ts";
+import { MODE_DESCRIPTIONS, MODE_LABELS, PERMISSION_MODES, } from "@oharness/engine/agent/permissions.ts";
+import { getTodos, renderTodos } from "@oharness/engine/tools/builtin/todo.ts";
+import { printAuthStatus, runLogin, runLogout } from "./auth.js";
+import { messageText } from "@oharness/engine/core/types.ts";
+import { previewJson } from "@oharness/engine/util/json.ts";
+import { c, newRenderState, renderEvent } from "./render.js";
+import { select } from "./select.js";
+/** The interactive readline, when there is one. Pickers need it to pause. */
+let activeReadline;
+function parseArgs(argv) {
+    const args = { continueLast: false, print: false, help: false };
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case "-m":
+            case "--model":
+                args.model = argv[++i];
+                break;
+            case "-r":
+            case "--resume":
+                args.resume = argv[++i];
+                break;
+            case "-c":
+            case "--continue":
+                args.continueLast = true;
+                break;
+            case "-p":
+            case "--print":
+                args.print = true;
+                break;
+            case "--permission-mode":
+                args.permissionMode = argv[++i];
+                break;
+            case "--dangerously-skip-permissions":
+                args.permissionMode = "bypassPermissions";
+                break;
+            case "-h":
+            case "--help":
+                args.help = true;
+                break;
+            default:
+                rest.push(arg);
+        }
+    }
+    if (rest.length)
+        args.prompt = rest.join(" ");
+    return args;
+}
+const HELP = `oharness — a model-agnostic agent harness
+
+Usage:
+  oharness [options] [prompt]
+  oharness auth <login|logout|list> [provider]
+  oharness schedule <list|run|daemon> [name]
+  oharness session <list|show|fork|rename|delete> [id]
+
+Options:
+  -m, --model <id>            Model alias or provider/model (default: from config)
+  -p, --print                 Run one prompt, print the result, and exit
+  -c, --continue              Resume the most recent session in this directory
+  -r, --resume <id>           Resume a specific session
+      --permission-mode <m>   default | acceptEdits | plan | auto | bypassPermissions
+      --dangerously-skip-permissions
+  -h, --help                  Show this help
+
+Slash commands (interactive):
+  /model [id]     Show or switch the model mid-session
+  /models         List registered models (/models refresh to re-query providers)
+  /login [prov]   Sign in to a provider (API key or subscription)
+  /logout <prov>  Remove stored credentials
+  /auth           Show authentication status
+  /tools          List available tools
+  /skills         List installed skills
+  /agents         List available subagents
+  /schedules      List configured schedules
+  /plugins        List active plugin bundles
+  /mcp            Show MCP server status
+  /permissions    Show rules; allow/deny/ask <pattern> [scope] to persist one
+  /mode [m]       Pick the permission mode (no argument opens the picker)
+  /compact        Summarize the conversation now
+  /todos          Show the current task list
+  (attach an image by writing @path/to/shot.png in your message)
+  /cost           Show token usage and estimated cost
+  /sessions       List recent sessions
+  /sync [on|off]  Whether this machine mirrors sessions to a sync server
+  /fork [n]       Branch this session, optionally rewound to n messages
+  /rename <text>  Title this session
+  /clear          Start a fresh session
+  /exit           Quit`;
+async function main() {
+    const argv = process.argv.slice(2);
+    // `auth` is a subcommand, not a prompt — handle it before anything that
+    // would try to pick a model or open a session.
+    if (argv[0] === "auth") {
+        await runAuthCommand(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "schedule") {
+        await runScheduleCommand(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "session") {
+        await runSessionCommand(argv.slice(1));
+        return;
+    }
+    const args = parseArgs(argv);
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    const rl = args.print
+        ? undefined
+        : createInterface({ input: process.stdin, output: process.stdout });
+    activeReadline = rl;
+    // Attach at creation, not at first use: readline starts consuming stdin the
+    // moment it exists, and `line` events with no listener are gone for good.
+    const readLine = rl ? makeLineReader(rl) : undefined;
+    // Indirection so the prompt can be replaced once the TUI exists: agents
+    // capture this closure, and it reads the current implementation per call.
+    let activePrompt = rl ? makePermissionPrompt(rl) : denyAll;
+    // The full-screen frontend owns the terminal, so engine diagnostics cannot
+    // go to stderr while it runs — they would paint over the frame. They are
+    // buffered until the transcript exists and then shown inside it. The
+    // line-based loop keeps stderr, which is what a pipeline expects.
+    const tui = useTui(args);
+    const pendingLogs = [];
+    let logLine = (line) => pendingLogs.push(line);
+    const harness = await Harness.create({
+        permissionPrompt: (request) => activePrompt(request),
+        ...(tui ? { logSink: (line) => logLine(line) } : {}),
+    });
+    if (args.permissionMode)
+        harness.config.permissionMode = args.permissionMode;
+    let session = await openSession(harness, args);
+    let agent = harness.agent(session);
+    const runPrompt = async (rawPrompt) => {
+        const prompt = await attachImages(rawPrompt, harness.cwd);
+        const state = newRenderState();
+        const controller = new AbortController();
+        const onSigint = () => {
+            controller.abort();
+            process.stdout.write(c.yellow("\n(interrupted)\n"));
+        };
+        process.on("SIGINT", onSigint);
+        try {
+            for await (const event of agent.run(prompt, { signal: controller.signal })) {
+                renderEvent(event, state);
+            }
+        }
+        catch (err) {
+            process.stdout.write(c.red(`\n✗ ${errorMessage(err)}\n`));
+        }
+        finally {
+            process.off("SIGINT", onSigint);
+        }
+    };
+    if (args.print) {
+        if (!args.prompt) {
+            console.error("--print requires a prompt");
+            process.exitCode = 1;
+            return;
+        }
+        await runPrompt(args.prompt);
+        await agent.end();
+        await harness.close();
+        return;
+    }
+    // A full-screen interface needs a terminal to own. Piped input, CI and dumb
+    // terminals fall through to the line-based loop below, which behaves the
+    // same and stays scriptable.
+    if (tui) {
+        rl?.close();
+        activeReadline = undefined;
+        await runTui(harness, session, agent, args, (prompt) => {
+            activePrompt = prompt;
+        }, (sink) => {
+            logLine = sink;
+            for (const line of pendingLogs.splice(0))
+                sink(line);
+        });
+        await harness.close();
+        return;
+    }
+    await printBanner(harness, session);
+    if (args.prompt)
+        await runPrompt(args.prompt);
+    while (true) {
+        const next = await readLine(c.cyan("\n› "));
+        if (next === undefined)
+            break; // stdin closed
+        const line = next.trim();
+        if (line === "")
+            continue;
+        if (line.startsWith("/")) {
+            const outcome = await handleSlashCommand(line, harness, session, agent);
+            if (outcome === "exit")
+                break;
+            if (outcome && typeof outcome === "object") {
+                if ("login" in outcome)
+                    await runLogin(harness.auth, rl, outcome.login);
+                else {
+                    session = outcome.session;
+                    agent = outcome.agent;
+                }
+            }
+            continue;
+        }
+        await runPrompt(line);
+    }
+    rl?.close();
+    await agent.end();
+    await harness.close();
+}
+async function openSession(harness, args) {
+    if (args.resume) {
+        const resumed = await harness.resumeSession(args.resume, args.model);
+        if (resumed)
+            return reportRepair(resumed);
+        console.error(c.yellow(`No session ${args.resume}; starting a new one.`));
+    }
+    else if (args.continueLast) {
+        const recent = await harness.store.mostRecent(harness.cwd);
+        if (recent) {
+            const resumed = await harness.resumeSession(recent.id, args.model);
+            if (resumed)
+                return reportRepair(resumed);
+        }
+        console.error(c.yellow("No previous session here; starting a new one."));
+    }
+    return harness.createSession({ model: args.model });
+}
+/** Say so when loading had to discard an interrupted turn. */
+function reportRepair(session) {
+    if (session.droppedOnLoad > 0) {
+        const n = session.droppedOnLoad;
+        console.error(c.yellow(`Discarded ${n} unfinished message${n === 1 ? "" : "s"} from the end of this session — ` +
+            "a turn was interrupted while its tools were running."));
+    }
+    return session;
+}
+async function printBanner(harness, session) {
+    const mcp = harness.mcpStatus().filter((s) => s.connected);
+    const lines = [
+        c.bold("oharness"),
+        c.gray(`session ${session.id}  ·  ${session.cwd}`),
+        c.gray(`model ${session.model.id} (${session.model.provider})  ·  ${harness.tools.visible().length} tools` +
+            (mcp.length ? `  ·  ${mcp.length} MCP server${mcp.length === 1 ? "" : "s"}` : "")),
+        c.gray("/help for commands"),
+    ];
+    console.log(`${lines.join("\n")}\n`);
+    // The default model comes from catalog order, which need not match the
+    // credentials on this machine. Saying so now beats a 401 on the first
+    // message with no hint about which key is missing.
+    const authenticated = await harness.configuredProviders();
+    if (!authenticated.has(session.model.provider)) {
+        const entry = harness.providers.catalogEntry(session.model.provider);
+        const envVars = entry?.envVars.join(" or ");
+        console.log(c.yellow(`No credentials for ${session.model.provider}. ` +
+            (envVars ? `Set ${envVars}, ` : "") +
+            `run \`oharness auth login ${session.model.provider}\`, or pick another model with /model.`));
+        const usable = harness.listModels().filter((m) => authenticated.has(m.provider));
+        if (usable.length > 0) {
+            console.log(c.gray(`Available now: ${usable.slice(0, 6).map((m) => m.id).join(", ")}`));
+        }
+        console.log("");
+    }
+}
+async function handleSlashCommand(line, harness, session, agent) {
+    const [command, ...rest] = line.slice(1).split(/\s+/);
+    const arg = rest.join(" ").trim();
+    switch (command) {
+        case "help":
+            console.log(HELP);
+            return undefined;
+        case "exit":
+        case "quit":
+            return "exit";
+        case "model": {
+            if (!arg) {
+                console.log(`${session.model.id} — ${session.model.displayName} (${session.model.provider})`);
+                return undefined;
+            }
+            try {
+                // Route through the agent so `model_changed` is emitted rather than
+                // silently mutating the session.
+                for await (const event of agent.switchModel(arg)) {
+                    if (event.type === "model_changed") {
+                        console.log(c.green(`⇄ ${event.from} → ${event.to}`));
+                    }
+                }
+            }
+            catch (err) {
+                console.log(c.red(errorMessage(err)));
+            }
+            return undefined;
+        }
+        case "login": {
+            // handled by the caller, which owns the readline instance
+            return { login: arg || undefined };
+        }
+        case "logout": {
+            if (!arg) {
+                console.log("Usage: /logout <provider>");
+                return undefined;
+            }
+            await runLogout(harness.auth, arg);
+            return undefined;
+        }
+        case "skills": {
+            const skills = harness.skills.list();
+            if (skills.length === 0) {
+                console.log(c.gray("No skills installed."));
+                console.log(c.gray("Add one at .oharness/skills/<name>/SKILL.md"));
+                return undefined;
+            }
+            for (const skill of skills) {
+                console.log(`${c.bold(skill.name.padEnd(20))} ${c.gray(skill.source)}`);
+                console.log(`  ${skill.description}`);
+            }
+            return undefined;
+        }
+        case "agents": {
+            const agents = harness.subagents.list();
+            if (agents.length === 0) {
+                console.log(c.gray("No subagents configured."));
+                return undefined;
+            }
+            for (const definition of agents) {
+                const model = definition.model ? c.gray(` [${definition.model}]`) : "";
+                console.log(`${c.bold(definition.name.padEnd(20))}${model}`);
+                console.log(`  ${definition.description}`);
+            }
+            return undefined;
+        }
+        case "plugins": {
+            if (harness.plugins.length === 0) {
+                console.log(c.gray("No plugins active. Add one at .oharness/plugins/<name>/oharness.plugin.json"));
+                return undefined;
+            }
+            for (const plugin of harness.plugins) {
+                const version = plugin.version ? c.gray(` v${plugin.version}`) : "";
+                console.log(`${c.bold(plugin.name)}${version} ${c.gray(`(${plugin.source})`)}`);
+                if (plugin.description)
+                    console.log(`  ${plugin.description}`);
+            }
+            return undefined;
+        }
+        case "fork": {
+            // Persist first: an unsaved turn would not be carried into the branch.
+            await session.persist();
+            const at = arg ? Number(arg) : undefined;
+            if (arg && !Number.isInteger(at)) {
+                console.log(c.red("Usage: /fork [message-count]"));
+                return undefined;
+            }
+            const forked = await harness.forkSession(session.id, {
+                ...(at !== undefined ? { keepMessages: at } : {}),
+            });
+            if (!forked) {
+                console.log(c.red("could not fork this session"));
+                return undefined;
+            }
+            console.log(c.green(`⑂ forked to ${forked.id}`) +
+                c.gray(` — ${forked.messages.length} messages, now working on the branch`));
+            console.log(c.gray(`  the original is intact: oharness --resume ${session.id}`));
+            return { session: forked, agent: harness.agent(forked) };
+        }
+        case "rename": {
+            if (!arg) {
+                console.log("Usage: /rename <title>");
+                return undefined;
+            }
+            session.title = arg;
+            await session.persist();
+            console.log(c.green(`✓ renamed to "${arg}"`));
+            return undefined;
+        }
+        case "schedules": {
+            const status = await harness.scheduler.status();
+            if (status.length === 0) {
+                console.log(c.gray("No schedules configured."));
+                return undefined;
+            }
+            for (const entry of status) {
+                const next = entry.nextRunAt
+                    ? new Date(entry.nextRunAt).toISOString().slice(0, 16).replace("T", " ")
+                    : "disabled";
+                console.log(`${entry.enabled ? c.green("●") : c.gray("○")} ${entry.name.padEnd(18)} ${c.gray(entry.cron.padEnd(16))} ${c.gray(next)}`);
+            }
+            return undefined;
+        }
+        case "auth": {
+            await printAuthStatus(harness.auth);
+            return undefined;
+        }
+        case "models": {
+            if (arg === "refresh") {
+                const added = await harness.refreshModels();
+                if (added.length === 0) {
+                    console.log(c.gray("No provider reported a model list."));
+                }
+                else {
+                    const byProvider = new Map();
+                    for (const model of added) {
+                        byProvider.set(model.provider, (byProvider.get(model.provider) ?? 0) + 1);
+                    }
+                    const summary = [...byProvider].map(([id, n]) => `${id} ${n}`).join(", ");
+                    console.log(c.green(`Discovered ${added.length} models (${summary}).`));
+                    console.log(c.gray("Saved to the user catalog for next time."));
+                }
+            }
+            const authenticated = await harness.configuredProviders();
+            // Hundreds of entries now that the catalog is seeded from pi-ai's own,
+            // and a terminal has no folding. The ones that can answer are printed;
+            // the rest are counted, which is the part that was actually in question.
+            const idle = new Map();
+            for (const model of harness.listModels()) {
+                if (!authenticated.has(model.provider)) {
+                    idle.set(model.provider, (idle.get(model.provider) ?? 0) + 1);
+                    continue;
+                }
+                const mark = model.id === session.model.id ? c.green("●") : " ";
+                const context = `${Math.round(model.contextWindow / 1000)}k ctx`;
+                console.log(`${mark} ${model.id.padEnd(12)} ${c.gray(`${model.provider}/${model.model}  ${context}`)}`);
+            }
+            for (const [provider, count] of idle) {
+                console.log(`${c.gray("○")} ${c.gray(`${provider.padEnd(12)} ${count} model${count === 1 ? "" : "s"}, no credentials`)}`);
+            }
+            console.log(c.gray("\n○ = not usable yet; run `oharness auth login <provider>`"));
+            return undefined;
+        }
+        case "tools": {
+            const grouped = new Map();
+            for (const tool of harness.tools.visible(harness.config.tools)) {
+                const key = tool.source === "mcp" ? `mcp:${tool.server}` : "builtin";
+                grouped.set(key, [...(grouped.get(key) ?? []), tool.name]);
+            }
+            for (const [group, names] of grouped) {
+                console.log(`${c.bold(group)}: ${names.join(", ")}`);
+            }
+            return undefined;
+        }
+        case "mcp": {
+            const statuses = harness.mcpStatus();
+            if (statuses.length === 0) {
+                console.log(c.gray("No MCP servers configured. Add them under `mcpServers` in the config."));
+                return undefined;
+            }
+            for (const status of statuses) {
+                const mark = status.connected ? c.green("✓") : c.red("✗");
+                const detail = status.error
+                    ? c.red(status.error)
+                    : c.gray(`${status.transport}, ${status.toolCount} tools`);
+                console.log(`${mark} ${status.name.padEnd(16)} ${detail}`);
+            }
+            return undefined;
+        }
+        case "permissions": {
+            const [action, ...words] = arg ? arg.split(/\s+/) : [];
+            // `/permissions allow Bash(npm test) project` — the trailing scope is
+            // optional and defaults to the project, which is where a rule about
+            // this repo belongs.
+            if (action === "allow" || action === "deny" || action === "ask") {
+                const scopes = ["user", "project", "local"];
+                const last = words.at(-1);
+                const scope = scopes.includes(last)
+                    ? words.pop()
+                    : "project";
+                const pattern = words.join(" ");
+                if (!pattern) {
+                    console.log(`Usage: /permissions ${action} <pattern> [${scopes.join("|")}]`);
+                    return undefined;
+                }
+                await harness.settings.addRule(scope, action, pattern);
+                session.permissions.addRule(action, pattern);
+                console.log(c.magenta(`${action} ${pattern} → ${scope}`));
+                console.log(c.gray(harness.settings.pathFor(scope)));
+                return undefined;
+            }
+            if (action === "remove") {
+                const scopes = ["user", "project", "local"];
+                const kind = words.shift();
+                if (kind !== "allow" && kind !== "deny" && kind !== "ask") {
+                    console.log("Usage: /permissions remove <allow|deny|ask> <pattern> [scope]");
+                    return undefined;
+                }
+                const last = words.at(-1);
+                const scope = scopes.includes(last)
+                    ? words.pop()
+                    : "project";
+                const pattern = words.join(" ");
+                const removed = await harness.settings.removeRule(scope, kind, pattern);
+                console.log(removed
+                    ? c.magenta(`removed ${kind} ${pattern} from ${scope}`)
+                    : c.gray(`no such rule in ${scope}`));
+                return undefined;
+            }
+            if (action && action !== "show") {
+                console.log("Usage: /permissions [show|allow|deny|ask|remove] ...");
+                return undefined;
+            }
+            const rules = session.permissions.listRules();
+            console.log(`mode: ${c.bold(session.permissions.getMode())}`);
+            console.log(`writes: ${c.bold(harness.workspace.mode)} ${c.gray(harness.workspace.mode === "workspace-write"
+                ? `(${harness.workspace.writableRoots.join(", ")})`
+                : "")}`);
+            for (const kind of ["allow", "ask", "deny"]) {
+                if (rules[kind].length)
+                    console.log(`${kind}: ${rules[kind].join(", ")}`);
+            }
+            if (rules.sessionAllow.length) {
+                console.log(c.gray(`approved this session: ${rules.sessionAllow.join(", ")}`));
+            }
+            // Where a rule would land, so an edit does not have to be guessed at.
+            for (const scope of ["user", "project", "local"]) {
+                console.log(c.gray(`${scope.padEnd(8)} ${harness.settings.pathFor(scope)}`));
+            }
+            return undefined;
+        }
+        case "mode": {
+            // With no argument this opens the picker; naming a mode still works, so
+            // scripts and muscle memory keep going.
+            if (!arg) {
+                const rl = activeReadline;
+                if (!rl) {
+                    console.log(`Usage: /mode <${PERMISSION_MODES.join("|")}>`);
+                    return undefined;
+                }
+                const picked = await pickMode(rl, session.permissions.getMode());
+                if (picked) {
+                    session.permissions.setMode(picked);
+                    console.log(c.magenta(`mode → ${MODE_LABELS[picked]}`));
+                }
+                return undefined;
+            }
+            const named = PERMISSION_MODES.find((mode) => mode === arg || MODE_LABELS[mode].toLowerCase() === arg.toLowerCase());
+            if (!named) {
+                console.log(`Usage: /mode <${PERMISSION_MODES.join("|")}>`);
+                return undefined;
+            }
+            session.permissions.setMode(named);
+            console.log(c.magenta(`mode → ${MODE_LABELS[named]}`));
+            return undefined;
+        }
+        case "compact": {
+            const { compact } = await import("@oharness/engine/agent/compaction.ts");
+            const provider = harness.providers.getProvider(session.model.provider);
+            try {
+                const result = await compact(session.messages, provider, session.model, {
+                    // Manual compaction is a deliberate act; keep less of the tail.
+                    keepTailFraction: 0.15,
+                });
+                if (result.droppedMessages === 0) {
+                    console.log(c.yellow("Nothing safe to compact yet."));
+                    return undefined;
+                }
+                await session.replaceMessages(result.messages);
+                console.log(c.yellow(`⟳ Compacted ${result.droppedMessages} messages (~${result.tokensBefore} → ~${result.tokensAfter} tokens)`));
+            }
+            catch (err) {
+                console.log(c.red(`Compaction failed: ${errorMessage(err)}`));
+            }
+            return undefined;
+        }
+        case "todos": {
+            console.log(renderTodos(getTodos(session.state)));
+            return undefined;
+        }
+        case "cost": {
+            const u = session.usage;
+            console.log([
+                `input   ${u.inputTokens}`,
+                `output  ${u.outputTokens}`,
+                `cached  ${u.cacheReadTokens ?? 0} read / ${u.cacheWriteTokens ?? 0} written`,
+                `turns   ${session.turns}`,
+                `cost    ${session.costUsd > 0 ? `$${session.costUsd.toFixed(4)}` : "n/a (model has no pricing)"}`,
+            ].join("\n"));
+            return undefined;
+        }
+        case "sync": {
+            const wanted = arg.toLowerCase();
+            if (wanted && wanted !== "on" && wanted !== "off") {
+                console.log("Usage: /sync [on|off]");
+                return undefined;
+            }
+            if (wanted) {
+                await harness.setSyncEnabled(wanted === "on");
+            }
+            const status = harness.syncStatus();
+            if (status.on) {
+                console.log(`${c.green("sync on")} — mirroring to ${status.url}`);
+                console.log(c.gray("Transcripts for this project leave this machine. /sync off to stop."));
+                return undefined;
+            }
+            // Each reason needs different advice, which is why the status carries
+            // one rather than a bare boolean.
+            const why = {
+                disabled: "Switched off. /sync on to resume.",
+                "no-credential": "Not signed in, so there is nowhere to send. /login official",
+                excluded: "This project is excluded by config; other projects still sync.",
+            };
+            console.log(`${c.yellow("sync off")} — ${why[status.reason ?? ""] ?? status.reason}`);
+            return undefined;
+        }
+        case "sessions": {
+            const sessions = await harness.listSessions(10);
+            if (sessions.length === 0) {
+                console.log(c.gray("No saved sessions."));
+                return undefined;
+            }
+            for (const meta of sessions) {
+                const when = new Date(meta.updatedAt).toISOString().slice(0, 16).replace("T", " ");
+                console.log(`${meta.id}  ${c.gray(`${when}  ${meta.model}  ${meta.turns} turns  ${meta.cwd}`)}`);
+            }
+            console.log(c.gray("\nResume with: oharness --resume <id>"));
+            return undefined;
+        }
+        case "clear": {
+            const fresh = harness.createSession({ model: session.model.id });
+            console.log(c.gray(`New session ${fresh.id}`));
+            return { session: fresh, agent: harness.agent(fresh) };
+        }
+        default:
+            console.log(c.yellow(`Unknown command /${command}. Try /help.`));
+            return undefined;
+    }
+}
+async function runAuthCommand(argv) {
+    const [sub, provider] = argv;
+    const harness = await Harness.create({ ephemeral: true });
+    try {
+        switch (sub) {
+            case "login": {
+                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                    await runLogin(harness.auth, rl, provider);
+                }
+                finally {
+                    rl.close();
+                }
+                return;
+            }
+            case "logout": {
+                if (!provider) {
+                    console.error("Usage: oharness auth logout <provider>");
+                    process.exitCode = 1;
+                    return;
+                }
+                await runLogout(harness.auth, provider);
+                return;
+            }
+            case "list":
+            case undefined:
+                await printAuthStatus(harness.auth);
+                return;
+            default:
+                console.error(`Unknown auth command: ${sub}`);
+                process.exitCode = 1;
+        }
+    }
+    finally {
+        await harness.close();
+    }
+}
+const IMAGE_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+/**
+ * Turn `@path/to/shot.png` references in a prompt into image blocks.
+ *
+ * The whole data path — ImageBlock through all three protocols — already
+ * worked; there was simply no way to get an image in from the terminal.
+ */
+async function attachImages(prompt, cwd) {
+    const refs = [...prompt.matchAll(/@(\S+)/g)]
+        .map((match) => match[1])
+        .filter((ref) => IMAGE_TYPES[path.extname(ref).toLowerCase()]);
+    if (refs.length === 0)
+        return prompt;
+    const content = [];
+    let text = prompt;
+    for (const ref of refs) {
+        const file = path.resolve(cwd, ref);
+        try {
+            const data = await readFile(file);
+            content.push({
+                type: "image",
+                mimeType: IMAGE_TYPES[path.extname(ref).toLowerCase()],
+                data: data.toString("base64"),
+            });
+            // Leave a readable placeholder so the model knows which file is which.
+            text = text.replace(`@${ref}`, `[image: ${path.basename(ref)}]`);
+        }
+        catch {
+            // An unreadable path is more likely a literal @mention than an image.
+            console.log(c.yellow(`could not read ${ref}; leaving it as text`));
+        }
+    }
+    if (content.length === 0)
+        return prompt;
+    return [{ role: "user", content: [{ type: "text", text }, ...content] }];
+}
+async function runSessionCommand(argv) {
+    const [sub, id, ...rest] = argv;
+    const harness = await Harness.create({ ephemeral: true });
+    try {
+        switch (sub) {
+            case "list":
+            case undefined: {
+                const sessions = await harness.listSessions(30);
+                if (sessions.length === 0) {
+                    console.log(c.gray("No sessions yet."));
+                    return;
+                }
+                for (const meta of sessions) {
+                    const when = new Date(meta.updatedAt).toISOString().slice(0, 16).replace("T", " ");
+                    const cost = meta.costUsd > 0 ? ` $${meta.costUsd.toFixed(4)}` : "";
+                    const lineage = meta.forkedFrom ? c.gray(`  ← ${meta.forkedFrom}`) : "";
+                    console.log(`${c.bold(meta.id)}  ${c.gray(when)}  ${meta.model}  ${meta.turns} turns${c.gray(cost)}${lineage}`);
+                    if (meta.title)
+                        console.log(c.gray(`   ${meta.title}`));
+                }
+                return;
+            }
+            case "show": {
+                if (!id)
+                    return usage("session show <id>");
+                const record = await harness.store.load(id);
+                if (!record)
+                    return notFound(id);
+                console.log(c.bold(record.meta.id));
+                console.log(c.gray(`${record.meta.model} · ${record.meta.turns} turns · ${record.messages.length} messages`));
+                if (record.meta.forkedFrom) {
+                    console.log(c.gray(`forked from ${record.meta.forkedFrom} at message ${record.meta.forkedAt}`));
+                }
+                console.log("");
+                record.messages.forEach((message, index) => {
+                    const role = message.role === "user" ? c.cyan("user") : c.green("assistant");
+                    const calls = message.content.filter((b) => b.type === "tool_call").length;
+                    const results = message.content.filter((b) => b.type === "tool_result").length;
+                    const marks = [
+                        calls ? `${calls} tool call${calls === 1 ? "" : "s"}` : "",
+                        results ? `${results} result${results === 1 ? "" : "s"}` : "",
+                    ].filter(Boolean).join(", ");
+                    const text = previewJson(messageText(message).replace(/\s+/g, " "), 90);
+                    console.log(`${c.gray(String(index).padStart(3))} ${role}  ${text}${marks ? c.gray(`  [${marks}]`) : ""}`);
+                });
+                return;
+            }
+            case "fork": {
+                if (!id)
+                    return usage("session fork <id> [--at <n>] [--title <text>]");
+                const at = flagValue(rest, "--at");
+                const title = flagValue(rest, "--title");
+                const forked = await harness.forkSession(id, {
+                    ...(at !== undefined ? { keepMessages: Number(at) } : {}),
+                    ...(title !== undefined ? { title } : {}),
+                });
+                if (!forked)
+                    return notFound(id);
+                console.log(c.green(`✓ forked ${id} → ${forked.id}`));
+                console.log(c.gray(`  ${forked.messages.length} messages carried over`));
+                console.log(c.gray(`  resume it with: oharness --resume ${forked.id}`));
+                return;
+            }
+            case "rename": {
+                const title = rest.join(" ").trim();
+                if (!id || !title)
+                    return usage("session rename <id> <title>");
+                console.log((await harness.renameSession(id, title))
+                    ? c.green(`✓ renamed ${id}`)
+                    : c.yellow(`no session ${id}`));
+                return;
+            }
+            case "delete": {
+                if (!id)
+                    return usage("session delete <id>");
+                const children = await harness.store.children(id);
+                if (children.length > 0) {
+                    // Deleting a parent orphans its branches; say so rather than
+                    // silently breaking the lineage they record.
+                    console.log(c.yellow(`${id} has ${children.length} fork${children.length === 1 ? "" : "s"} (${children.map((m) => m.id).join(", ")}); they will lose their parent.`));
+                }
+                console.log((await harness.deleteSession(id))
+                    ? c.green(`✓ deleted ${id}`)
+                    : c.yellow(`no session ${id}`));
+                return;
+            }
+            default:
+                console.error(`Unknown session command: ${sub}`);
+                process.exitCode = 1;
+        }
+    }
+    finally {
+        await harness.close();
+    }
+    function usage(line) {
+        console.error(`Usage: oharness ${line}`);
+        process.exitCode = 1;
+    }
+    function notFound(target) {
+        console.error(`No session ${target}`);
+        process.exitCode = 1;
+    }
+}
+function flagValue(argv, flag) {
+    const index = argv.indexOf(flag);
+    return index >= 0 ? argv[index + 1] : undefined;
+}
+async function runScheduleCommand(argv) {
+    const [sub, name] = argv;
+    const harness = await Harness.create();
+    try {
+        switch (sub) {
+            case "list":
+            case undefined: {
+                const status = await harness.scheduler.status();
+                if (status.length === 0) {
+                    console.log(c.gray("No schedules configured."));
+                    console.log(c.gray('Add them under "schedules" in oharness.config.json.'));
+                    return;
+                }
+                for (const entry of status) {
+                    const mark = entry.enabled ? c.green("●") : c.gray("○");
+                    const next = entry.nextRunAt
+                        ? c.gray(`next ${new Date(entry.nextRunAt).toISOString().slice(0, 16).replace("T", " ")}`)
+                        : c.gray("disabled");
+                    console.log(`${mark} ${c.bold(entry.name.padEnd(18))} ${entry.cron.padEnd(16)} ${next}`);
+                    if (entry.lastRun) {
+                        const when = new Date(entry.lastRun.startedAt).toISOString().slice(0, 16).replace("T", " ");
+                        const outcome = entry.lastRun.ok ? c.green("ok") : c.red(entry.lastRun.error ?? "failed");
+                        console.log(c.gray(`    last ${when} · ${outcome}`));
+                    }
+                }
+                return;
+            }
+            case "run": {
+                if (!name) {
+                    console.error("Usage: oharness schedule run <name>");
+                    process.exitCode = 1;
+                    return;
+                }
+                console.log(c.gray(`running ${name}…`));
+                const run = await harness.scheduler.runNow(name);
+                console.log(run.ok
+                    ? c.green(`✓ ${name} finished in ${run.turns} turns ($${run.costUsd.toFixed(4)})`)
+                    : c.red(`✗ ${name}: ${run.error}`));
+                if (run.output)
+                    console.log(`\n${run.output}`);
+                return;
+            }
+            case "daemon": {
+                const status = await harness.scheduler.status();
+                const enabled = status.filter((entry) => entry.enabled);
+                if (enabled.length === 0) {
+                    console.error("No enabled schedules; nothing to run.");
+                    process.exitCode = 1;
+                    return;
+                }
+                console.log(c.bold(`Watching ${enabled.length} schedule${enabled.length === 1 ? "" : "s"}.`));
+                for (const entry of enabled)
+                    console.log(c.gray(`  ${entry.name}  ${entry.cron}`));
+                console.log(c.gray("Ctrl-C to stop.\n"));
+                harness.scheduler.start();
+                // Hold the process open: the scheduler's own timer is unref'd so it
+                // never keeps a short-lived CLI invocation alive by itself.
+                await new Promise((resolve) => {
+                    const stop = () => {
+                        console.log(c.yellow("\nstopping…"));
+                        harness.scheduler.stop();
+                        resolve();
+                    };
+                    process.on("SIGINT", stop);
+                    process.on("SIGTERM", stop);
+                });
+                await harness.scheduler.drain();
+                return;
+            }
+            default:
+                console.error(`Unknown schedule command: ${sub}`);
+                process.exitCode = 1;
+        }
+    }
+    finally {
+        await harness.close();
+    }
+}
+function makePermissionPrompt(rl) {
+    return async (request) => {
+        const detail = [previewJson(request.input, 200)];
+        if (request.reason)
+            detail.unshift(request.reason);
+        const choice = await select({
+            title: `${c.yellow("?")} ${request.title}`,
+            detail,
+            rl,
+            choices: [
+                { value: { allow: true }, label: "Yes", hint: "just this once" },
+                {
+                    value: { allow: true, remember: "session" },
+                    label: "Yes, and don't ask again this session",
+                },
+                {
+                    value: { allow: true, remember: "project" },
+                    label: "Yes, and remember for this project",
+                    hint: ".oharness/settings.json",
+                },
+                { value: { allow: false }, label: "No", hint: "tell the model what to do instead" },
+            ],
+        });
+        // Cancelling is a denial. Falling through to the highlighted option would
+        // approve something on a stray Ctrl-C.
+        return choice ?? { allow: false };
+    };
+}
+/** The mode picker behind `/mode` with no argument. */
+async function pickMode(rl, current) {
+    return select({
+        title: "Mode",
+        rl,
+        choices: PERMISSION_MODES.map((mode) => ({
+            value: mode,
+            label: MODE_LABELS[mode],
+            hint: MODE_DESCRIPTIONS[mode],
+            current: mode === current,
+        })),
+    });
+}
+/** Non-interactive runs cannot ask, so anything needing approval is denied. */
+async function denyAll() {
+    return false;
+}
+main().catch((err) => {
+    console.error(c.red(`fatal: ${errorMessage(err)}`));
+    process.exitCode = 1;
+});
+/**
+ * Read user lines, queueing anything that arrives before we ask for it.
+ *
+ * `rl.question()` only sees input delivered after the call, so lines piped in
+ * ahead of the first prompt were dropped and the process exited 0 as if the
+ * user had typed nothing. Listening from startup makes
+ * `printf '/tools\n/exit\n' | oharness` behave the same as typing it.
+ */
+function makeLineReader(rl) {
+    const queued = [];
+    let waiting;
+    let closed = false;
+    const deliver = (line) => {
+        if (!waiting)
+            return false;
+        const resolve = waiting;
+        waiting = undefined;
+        resolve(line);
+        return true;
+    };
+    rl.on("line", (line) => {
+        if (!deliver(line))
+            queued.push(line);
+    });
+    rl.on("close", () => {
+        closed = true;
+        deliver(undefined);
+    });
+    return async (prompt) => {
+        const buffered = queued.shift();
+        if (buffered !== undefined) {
+            // A pipe does not echo, so print what we are acting on; a terminal has
+            // already shown it and echoing again would double every line.
+            process.stdout.write(process.stdin.isTTY ? prompt : `${prompt}${buffered}\n`);
+            return buffered;
+        }
+        if (closed)
+            return undefined;
+        process.stdout.write(prompt);
+        return new Promise((resolve) => {
+            waiting = resolve;
+        });
+    };
+}
+/**
+ * Whether to take over the screen.
+ *
+ * Both streams must be a terminal: stdout alone is not enough, because raw
+ * mode needs a tty on stdin, and a piped stdin with a tty stdout would leave
+ * the app waiting for keys that arrive as whole lines.
+ */
+function useTui(args) {
+    if (process.env["OHARNESS_NO_TUI"])
+        return false;
+    if (args.print)
+        return false;
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function runTui(harness, session, agent, args, installPrompt, installLogSink) {
+    const { Tui } = await import("./tui/app.js");
+    const banner = [
+        `session ${session.id}  ·  ${session.cwd}`,
+        `model ${session.model.id} (${session.model.provider})  ·  ${harness.tools.list().length} tools`,
+        "/help for commands  ·  Ctrl-C interrupts  ·  Ctrl-D quits",
+    ];
+    const authenticated = await harness.configuredProviders();
+    if (!authenticated.has(session.model.provider)) {
+        banner.push(`No credentials for ${session.model.provider}. Run /login, or pick another model with /model.`);
+    }
+    const app = new Tui({
+        harness,
+        session,
+        agent,
+        banner,
+        onCommand: async (line, tui) => {
+            // The slash handlers were written for a scrolling terminal and print
+            // with console.log. In the alternate buffer those writes would land
+            // outside the frame and be erased by the next redraw, so they are
+            // redirected into the transcript for the duration of the command.
+            const realLog = console.log;
+            const realError = console.error;
+            const capture = (...parts) => {
+                for (const chunk of parts.join(" ").split("\n"))
+                    tui.write(chunk);
+            };
+            console.log = capture;
+            console.error = capture;
+            try {
+                const outcome = await handleSlashCommand(line, harness, tui.session, tui.agent);
+                if (outcome === "exit")
+                    return "exit";
+                if (outcome && typeof outcome === "object" && "session" in outcome)
+                    return outcome;
+                if (outcome && typeof outcome === "object" && "login" in outcome) {
+                    tui.write("run `oharness auth login` in a normal terminal to sign in");
+                }
+                return undefined;
+            }
+            finally {
+                console.log = realLog;
+                console.error = realError;
+            }
+        },
+    });
+    // Approval and mode selection become overlays, so they draw inside the
+    // frame instead of scribbling over it.
+    installPrompt(app.permissionPrompt);
+    installLogSink((line) => app.log(line));
+    const running = app.run();
+    if (args.prompt)
+        await app.submitExternal(args.prompt);
+    await running;
+    await agent.end();
+}
+//# sourceMappingURL=main.js.map