kronk-cli 0.6.1 → 0.8.0

package/src/index.js

@@ -4,7 +4,8 @@ import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
 import { config, DEFAULT_MODEL, applyLimits, warnIfInsecure } from './config.js';
 import { listModels, listModelDetails, listLoaded, modelLimits, tokenize } from './client.js';
-import { pickDefault, ensureLoaded } from './boot.js';
+import { pickDefault, chatModels, ensureLoaded } from './boot.js';
+import { resolveModel } from './resolve.js';
 import { runTurn, SYSTEM, SYSTEM_AUTO } from './agent.js';
 import { c, banner, fmtContext, statusLine } from './ui.js';
 import { resolveTheme, theme, useTheme } from './theme.js';
@@ -15,9 +16,12 @@ import { loadServers, McpHub, reportFailures } from './mcp.js';
 import { resolveSandbox, sandbox } from './tools.js';
 import { parseArgv } from './argv.js';
 import { deferredPrompt } from './prompt.js';
-import { AGENTS } from './subagent.js';
+import { AGENTS, setServedModels } from './subagent.js';
 import { runLines, transcriptLines, sweep, cleanup } from './tasklog.js';
-import { runSetup } from './setup.js';
+import { runSetup, runKronk } from './setup.js';
+import { runRescue } from './rescue.js';
+import { VERSION, parseKronkVersion } from './version.js';
+import { updateStatus } from './update.js';
 
 // ---- argv -------------------------------------------------------------
 const args = parseArgv(process.argv.slice(2));
@@ -41,6 +45,22 @@ if (args.help) {
                                     pull the model, write its /AGENT profile to
                                     ~/.kronk/models/model_config.yaml, restart Kronk
 
+    kronk-cli rescue "<prompt>" [--role explore|code] [--model <id>] [-y|-a] [--steps <n>] [--json]
+                                    submit a self-contained task; runs detached,
+                                    prints a job id and exits immediately
+    kronk-cli rescue status <id> [--json]
+                                    queued | running (step n) | done | stopped
+                                    | interrupted | failed
+    kronk-cli rescue wait <id> [--json]
+                                    block until the job lands, then print its
+                                    report; exit code is done 0, stopped 1,
+                                    interrupted 2, failed 3
+    kronk-cli rescue result <id> [--json]
+                                    print the report; refuses (exit 4) if the
+                                    job has not reached one of those four states yet
+                                    without -y/-a, a rescue job refuses any tool
+                                    that needs approval rather than asking nobody
+
   OPTIONS
     -l, --models        list the models Kronk is serving, then exit
         --no-context    skip the startup scan of the working directory
@@ -56,6 +76,8 @@ if (args.help) {
         --no-subagents  remove the task tool; no delegation
         --steps <n>     cap tool calls per task (default: unlimited)
     -h, --help          this message
+    -v, --version       print the kronk-cli version, and Kronk's if it can be
+                        had without a network call, then exit
         --              end option parsing; everything after is the prompt
 
   ENVIRONMENT
@@ -77,15 +99,37 @@ if (args.help) {
     KRONK_COMPACT_AT    fraction of the window that triggers it (default 0.85)
     KRONK_SUBAGENTS     false to remove the task tool
     KRONK_SUBAGENT_MODEL
-                        model sub-agents run on (default: the main model)
+                        default model for a task that names none itself
+                        (default: the main model) — a task can pick its own
+                        from what Kronk is serving, see /agents
     KRONK_SUBAGENT_STEPS
                         tool-call cap for one delegated task (default 40)
+    KRONK_UPDATE_CHECK  false to never ask the package manager whether a
+                        newer kronk-cli exists (default true)
 
   Config file: ~/.kronk-cli.json
 `);
   process.exit(0);
 }
 
+if (args.version) {
+  // package.json's version, not a network call, not the server — this must
+  // print with no Kronk running, which is the common case for `--version`.
+  console.log(`kronk-cli ${VERSION}`);
+  // A cheap, short-timeout, local-only ask: no server round trip, and never
+  // held open past the timeout if `kronk` itself hangs. Kronk's own API
+  // exposes no version field anywhere client.js already reads (checked
+  // before writing this), so the binary on disk is the only source there is.
+  try {
+    const { code, output } = await runKronk(['--version'], { timeoutMs: 3000 });
+    const v = code === 0 ? parseKronkVersion(output) : null;
+    if (v) console.log(`kronk    ${v}`);
+  } catch {
+    // No `kronk` on PATH, or it did not behave — say nothing rather than guess.
+  }
+  process.exit(0);
+}
+
 // --auto: run the whole task unattended (implies --yes)
 const AUTO = args.auto;
 const AUTO_YES = args.yes || AUTO;
@@ -124,15 +168,12 @@ async function boot() {
   // Fall back to the configured default before guessing.
   if (!config.model && ids.includes(DEFAULT_MODEL)) config.model = DEFAULT_MODEL;
 
+  // Exact id wins. Otherwise take a substring match, preferring an /AGENT
+  // profile — each profile is a SEPARATE resident copy in the pool, so
+  // picking the wrong one silently loads a second 20 GB instance. One
+  // resolver (src/resolve.js) for this and for the identical problem below.
   if (config.model) {
-    // exact id wins; otherwise accept a unique-enough substring
-    // Exact id wins. Otherwise take a substring match, preferring an /AGENT
-    // profile — each profile is a SEPARATE resident copy in the pool, so
-    // picking the wrong one silently loads a second 20 GB instance.
-    const subs = ids.filter((id) => id.includes(config.model));
-    const hit = ids.find((id) => id === config.model)
-             ?? subs.find((id) => id.endsWith('/AGENT'))
-             ?? subs[0];
+    const hit = resolveModel(config.model, ids);
     if (hit) config.model = hit;
     else {
       console.error(c.yellow(`  no model matching "${config.model}" — falling back`));
@@ -145,10 +186,7 @@ async function boot() {
   // model: a substring in the config file that matches nothing would otherwise
   // only surface as a 404 in the middle of somebody's first delegated task.
   if (config.subagentModel) {
-    const subs = ids.filter((id) => id.includes(config.subagentModel));
-    const hit = ids.find((id) => id === config.subagentModel)
-             ?? subs.find((id) => id.endsWith('/AGENT'))
-             ?? subs[0];
+    const hit = resolveModel(config.subagentModel, ids);
     if (hit) config.subagentModel = hit;
     else {
       console.error(c.yellow(`  no model matching "${config.subagentModel}" for sub-agents`
@@ -157,6 +195,14 @@ async function boot() {
     }
   }
 
+  // What a delegated task's own `model` argument may name — see the `task`
+  // tool in src/subagent.js. `chatModels` is a wider list than the one
+  // `pickDefault` above chose the session's model from, and deliberately so:
+  // picking one default prefers a tuned /AGENT profile outright, while
+  // offering a menu must keep the models that have no profile, because the
+  // small fast one a survey should be sent to is usually one of them.
+  setServedModels(chatModels(ids));
+
   if (config.warm) await ensureLoaded(ids);
 
   // After `ensureLoaded`, which may have fallen back to a different model
@@ -164,11 +210,10 @@ async function boot() {
   // describe a model this session is not using.
   applyLimits(await modelLimits(config.model));
 
-  // The sub-agent model's profile is its own. Resolved once here rather than
-  // on the first delegation, where the wait would land mid-task.
-  config.subagentLimits = config.subagentModel
-    ? await modelLimits(config.subagentModel)
-    : null;
+  // The sub-agent model's own profile is no longer resolved here: a task can
+  // run on any served model now, not only the one configured for delegation,
+  // so src/subagent.js resolves and caches each one's limits the first time a
+  // task actually runs on it — see `limitsFor` there.
   return ids;
 }
 
@@ -416,6 +461,13 @@ async function main() {
     return;
   }
 
+  // Same reasoning as `setup` just above: reserved before the one-shot path
+  // gets a chance to read the rest of the line as a prompt.
+  if (args.words[0] === 'rescue') {
+    process.exitCode = await runRescue(args);
+    return;
+  }
+
   if (SHOW_MODELS) { await showModels(); return; }
   if (SHOW_MCP) { await showMcp(); process.exit(0); }
 
@@ -456,9 +508,14 @@ async function main() {
     },
   });
 
+  // Synchronous and cheap — a cache-file read, never a subprocess on this
+  // path — so it costs nothing to call before `boot()`'s network round trips.
+  // See src/update.js for why this never waits on a package manager.
+  const update = updateStatus();
+
   await boot();
   const { content, ctx } = await systemMessage(AUTO);
-  console.log(banner(config.model, config.baseUrl));
+  console.log(banner(config.model, config.baseUrl, update));
 
   // Information, not a failure: the profile is doing exactly what it was
   // told to, it's just not what the model's own GGUF recommends. One-shot
@@ -580,8 +637,9 @@ async function main() {
         console.log(`  ${c.green('●')} ${c.bold(name)} ${c.grey(`· ${a.tools.join(', ')}`)}`);
         console.log(c.grey(`      for ${a.use}`));
       }
-      console.log(c.grey(`  model: ${config.subagentModel ?? config.model} · `
-        + `cap ${config.subagentSteps} steps per task\n`));
+      console.log(c.grey(`  default model: ${config.subagentModel ?? config.model} · `
+        + `cap ${config.subagentSteps} steps per task`));
+      console.log(c.grey('  a task can name a different served model itself, when the default is the wrong size for it\n'));
       continue;
     }
     if (input === '/theme' || input.startsWith('/theme ')) {
@@ -635,12 +693,13 @@ async function main() {
     if (input.startsWith('/model ')) {
       const want = input.slice(7).trim();
       const all = await listModels();
-      const subs = all.filter((m) => m.includes(want));
-      const hit = all.find((m) => m === want)
-               ?? subs.find((m) => m.endsWith('/AGENT'))
-               ?? subs[0];
+      const hit = resolveModel(want, all);
       if (!hit) { console.log(c.red(`  no model matching "${want}"`)); continue; }
       await switchModel(hit);
+      // Kronk may be serving something new since boot — a model pulled or
+      // unloaded mid-session — so a task's own `model` enum is refreshed from
+      // the same list this command just asked for, not left stale from boot.
+      setServedModels(chatModels(all));
       console.log(c.green(`  switched to ${hit}`));
       console.log(c.grey(`  window ${config.contextWindow?.toLocaleString() ?? 'unknown'}`
         + ` · output cap ${config.maxTokens.toLocaleString()}`

package/src/mcp.js

@@ -3,9 +3,12 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { c } from './ui.js';
+import { VERSION } from './version.js';
 
 const PROTOCOL = '2025-06-18';
-const CLIENT = { name: 'kronk-cli', version: '0.1.0' };
+// Six releases carried '0.1.0' here regardless of what package.json actually
+// said, because nothing read the real number. VERSION is that number.
+const CLIENT = { name: 'kronk-cli', version: VERSION };
 const CALL_TIMEOUT = 120_000;
 const START_TIMEOUT = 20_000;
 

package/src/pane.js

@@ -0,0 +1,276 @@
+import readline from 'node:readline';
+import { c, elapsed } from './ui.js';
+
+/**
+ * The transient pane a delegated run draws in while it is running.
+ *
+ * A sub-agent's tool calls used to go straight into the conversation, nested
+ * under `   │`, and stayed there. That is the wrong trade in both directions.
+ * While the run is going a live view is the only sign the thing is alive, and
+ * it is where you notice a sub-agent thrashing; once it has finished, almost
+ * none of it is worth keeping, because the question you asked and the report
+ * you got are now forty lines apart. The window never paid for any of it —
+ * that is the point of delegating — but the screen paid for all of it.
+ *
+ * So: draw it in a box that redraws in place, and erase the box when the run
+ * ends. Nothing is lost by erasing it. Every line the pane shows was already
+ * written to the run's transcript as it happened (src/tasklog.js), so the pane
+ * is a view of a file that outlives it, and `/tasks <n>` is how you get it
+ * back. That is what makes discarding the pane safe.
+ *
+ * Scrollback, not the alternate screen. A full takeover would be easier to
+ * draw and worse to live with, because it hides the conversation you are in
+ * the middle of. A fixed block redrawn in place keeps the history above it.
+ */
+
+/** Rows of sub-agent activity kept on screen. The box is bounded; the file is not. */
+const BODY_ROWS = 6;
+
+const MIN_WIDTH = 40;
+const MAX_WIDTH = 100;
+
+// eslint-disable-next-line no-control-regex -- matching the escapes is the point
+const SGR = /\x1b\[[0-9;]*m/g;
+
+/** How wide a string prints, once its colour escapes are discounted. */
+export const visibleWidth = (s) => String(s).replace(SGR, '').length;
+
+/** The box's outer width for a terminal this wide, clamped both ways. */
+export const paneWidth = (columns) => Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, (columns || 80) - 2));
+
+/**
+ * Cut a coloured string to `width` printed characters.
+ *
+ * Escapes are copied through without being counted — cutting in the middle of
+ * one would leave the rest of the terminal painted in whatever colour the
+ * fragment happened to open. The trailing reset is only added when something
+ * was actually opened, so a no-colour terminal still gets no escapes at all.
+ */
+export function clip(line, width) {
+  const s = String(line);
+  if (visibleWidth(s) <= width) return s;
+  if (width <= 0) return '';
+  let out = '';
+  let seen = 0;
+  let i = 0;
+  while (i < s.length && seen < width - 1) {
+    if (s[i] === '\x1b') {
+      SGR.lastIndex = i;
+      const m = SGR.exec(s);
+      if (m && m.index === i) { out += m[0]; i += m[0].length; continue; }
+    }
+    out += s[i];
+    i += 1;
+    seen += 1;
+  }
+  return `${out}…${out.includes('\x1b') ? '\x1b[0m' : ''}`;
+}
+
+/** Right-pad to `width` printed characters, so every row ends on the same column. */
+export const pad = (line, width) => `${line}${' '.repeat(Math.max(0, width - visibleWidth(line)))}`;
+
+const rule = (n) => '─'.repeat(Math.max(1, n));
+
+/**
+ * One frame of the box, as lines — pure, so the geometry is testable without a
+ * terminal. Every line it returns is exactly `width` printed characters wide;
+ * `test/pane.test.js` asserts that, because an off-by-one in the arithmetic
+ * below is invisible in a diff and unmissable on screen.
+ */
+export function renderPane({ agent, rows = [], status = '', hint = '', width = 60 }) {
+  const inner = Math.max(4, width - 4);
+  // Printed width, not string length: the status and the hint arrive coloured,
+  // and counting their escapes would pull the right-hand corner off the edge.
+  const w = (s) => (s ? visibleWidth(s) + 1 : 0);
+
+  // `┌─ agent ──…── 6/40 · 48s ─┐`
+  const headFixed = 3 + w(agent) + 1 + w(status) + 2;
+  const top = c.grey('┌─ ') + c.bold(agent) + c.grey(` ${rule(width - headFixed)} ${status ? `${status} ` : ''}─┐`);
+
+  // `└─ esc to collapse · ctrl-c to stop ───┘`
+  const footFixed = 3 + w(hint) + 2;
+  const bottom = c.grey(`└─ ${hint ? `${hint} ` : ''}${rule(width - footFixed)}─┘`);
+
+  const body = rows.map((r) => `${c.grey('│')} ${pad(clip(r, inner), inner)} ${c.grey('│')}`);
+  return [top, ...body, bottom];
+}
+
+/**
+ * Watch for a bare `esc` while the pane is up.
+ *
+ * Deliberately not `setRawMode`. The REPL's readline already owns stdin and
+ * already holds it in raw mode, and it is still reading during a turn — that
+ * is how typing ahead survives (see src/prompt.js). Taking the mode away from
+ * it and handing back what we swallowed is the kind of thing that eats a
+ * user's typing when it goes wrong, and there is no need: readline has already
+ * made stdin emit `keypress`, so a listener is purely additive. Ctrl-C keeps
+ * working because we never intercepted it.
+ *
+ * Armed only when stdin is *already* raw, which is exactly "a readline is
+ * open and reading". In one-shot and `--auto` runs it is not, nobody is
+ * watching, and the footer does not offer a key that would do nothing.
+ */
+export function watchEsc({ input = process.stdin, onEsc } = {}) {
+  if (!onEsc || !input?.isTTY || !input.isRaw) return null;
+  // Idempotent in Node: it returns early if the stream already has a decoder.
+  readline.emitKeypressEvents(input);
+  // `meta` is true on a bare esc and false on `esc [ A`, because node cannot
+  // know which it has until the next byte arrives or `escapeCodeTimeout`
+  // (500 ms) expires — so this is the key, and an arrow key is not. That half
+  // second of lag is invisible next to a run that takes tens of seconds.
+  const onKey = (_s, key) => { if (key?.name === 'escape' && !key.ctrl) onEsc(); };
+  input.on('keypress', onKey);
+  return () => input.off('keypress', onKey);
+}
+
+/**
+ * Whether to draw at all.
+ *
+ * `node src/index.js "hello" | grep` and every CI run land here with a pipe,
+ * and a pipe must get exactly what it got before the pane existed: the nested
+ * lines, in order, with no cursor control in them. A dumb terminal cannot move
+ * a cursor either, so it takes the same path.
+ */
+export const paneUsable = (stream = process.stdout, env = process.env) =>
+  Boolean(stream?.isTTY) && env.TERM !== 'dumb';
+
+/** The inert pane: every call a no-op, so the caller needs no branch of its own. */
+const OFF = {
+  enabled: false,
+  open() {}, line() {}, step() {}, close() {}, collapse() {},
+  shield: (fn) => fn,
+};
+
+/**
+ * The live pane. `open` draws it, `line` feeds it, `close` erases it.
+ *
+ * `shield(fn)` is how the approval prompt stays readable: it wipes the box
+ * before `fn` runs and redraws it after. An approval prompt has to be exactly
+ * as visible and as blocking as it is without a pane, so it gets the terminal
+ * to itself rather than competing with a redraw every 250 ms.
+ */
+export function livePane({
+  agent = 'agent', model, maxSteps, rows: keep = BODY_ROWS, signal,
+  stream = process.stdout, input = process.stdin, env = process.env,
+  now = Date.now, tickMs = 250,
+} = {}) {
+  if (!paneUsable(stream, env)) return OFF;
+
+  // The label carries the model too, the same way the opening line above a
+  // pipe does (src/subagent.js's `openLine`) — a task on a model that had to
+  // be loaded cold is exactly the run a person watches the box wondering why
+  // it is slow, and the header is where that question gets answered. The last
+  // two path segments, not one: a served id's last segment alone (`AGENT`,
+  // `base`) is shared by every profile of every model and says nothing.
+  const label = model ? `${agent} · ${String(model).split('/').slice(-2).join('/')}` : agent;
+
+  const started = now();
+  const fed = [];
+  let steps = 0;
+  let height = 0;            // rows the box currently occupies on screen
+  let collapsed = false;
+  let timer = null;
+  let unwatch = null;
+  let unabort = null;
+
+  const status = () => {
+    const at = Number.isFinite(maxSteps) ? `${steps}/${maxSteps}` : String(steps);
+    return c.grey(`${at} · ${elapsed(now() - started)}`);
+  };
+
+  const paint = () => {
+    if (collapsed) return;
+    const width = paneWidth(stream.columns);
+    const hint = c.grey(unwatch ? 'esc to collapse · ctrl-c to stop' : 'ctrl-c to stop');
+    const frame = renderPane({ agent: label, rows: fed, status: status(), hint, width });
+    // Up to the top of the old box, then repaint row by row. `\x1b[K` on each
+    // row so a shorter line does not leave the tail of a longer one behind.
+    let buf = height ? `\r\x1b[${height}A` : '';
+    for (const l of frame) buf += `${l}\x1b[K\n`;
+    // The box only ever grows, but a narrower terminal can shorten it; clear
+    // whatever the previous frame left below this one.
+    if (height > frame.length) buf += '\x1b[J';
+    stream.write(buf);
+    height = frame.length;
+  };
+
+  const erase = () => {
+    if (!height) return;
+    stream.write(`\r\x1b[${height}A\x1b[J`);
+    height = 0;
+  };
+
+  const tick = () => {
+    if (timer) return;
+    timer = setInterval(paint, tickMs);
+    // Never a reason to keep the process alive: the run is what we are waiting on.
+    timer.unref?.();
+  };
+  const untick = () => { clearInterval(timer); timer = null; };
+
+  const stop = () => {
+    untick();
+    unwatch?.();
+    unwatch = null;
+    unabort?.();
+    unabort = null;
+  };
+
+  return {
+    enabled: true,
+
+    open() {
+      unwatch = watchEsc({ input, onEsc: () => this.collapse() });
+      // Ctrl-C aborts the run and then prints `interrupted` — which would land
+      // on top of the box, leaving the next repaint counting rows from the
+      // wrong place and erasing lines of the conversation above. Abort fires
+      // this listener synchronously, so the box is gone before that line
+      // prints. Nothing is lost: the transcript has everything it showed.
+      const onAbort = () => this.collapse();
+      signal?.addEventListener('abort', onAbort, { once: true });
+      // Released with everything else: one turn can delegate several times, and
+      // a listener left on that turn's signal each time is a leak node warns about.
+      unabort = () => signal?.removeEventListener('abort', onAbort);
+      paint();
+      tick();
+    },
+
+    /** One line of sub-agent activity. Only the last `keep` survive. */
+    line(text) {
+      if (collapsed) return;
+      for (const l of String(text).split('\n')) fed.push(l);
+      if (fed.length > keep) fed.splice(0, fed.length - keep);
+      paint();
+    },
+
+    step(n) { steps = n; },
+
+    /** `esc`: give the screen back now. The run carries on into the transcript. */
+    collapse() {
+      if (collapsed) return;
+      erase();
+      collapsed = true;
+      stop();
+    },
+
+    close() {
+      erase();
+      collapsed = true;
+      stop();
+    },
+
+    shield(fn) {
+      if (!fn) return fn;
+      return async (...args) => {
+        const wasUp = !collapsed && height > 0;
+        erase();
+        untick();
+        try {
+          return await fn(...args);
+        } finally {
+          if (wasUp && !collapsed) { paint(); tick(); }
+        }
+      };
+    },
+  };
+}