@tiens.nguyen/gu-cli 1.0.767 → 1.0.769

package/gu-repl.mjs

@@ -24,6 +24,7 @@
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
+import { readStepTokens } from "./step-tokens.mjs";
 import { existsSync, statSync, readFileSync, writeFileSync, readdirSync, openSync, readSync, closeSync } from "node:fs";
 import { spawn } from "node:child_process";
 // FIRST, before anything that could itself fail on an old runtime: npm only WARNS about
@@ -95,6 +96,7 @@ import {
   physicalRows,
   inputPhysicalRows,
   buildFooterRows,
+  pasteHint,
   footerDrawSeq,
   footerEraseSeq,
   clearBlockSeq,
@@ -631,6 +633,10 @@ function reloadWorkerEnv() {
 // first-run branch also runs one — without this the same walkthrough printed twice in a single
 // run, MongoDB instructions and all. Reported live on Windows 11.
 let clientExpertRanThisProcess = false;
+// #301: setup chose "Load a saved preset" — main() opens /load-presets before the first prompt.
+// Declared HERE, above the first-run block: that block runs at module top level, before any
+// declaration further down exists.
+let openPresetsAtStart = false;
 
 if (!workerKey || !apiBase) {
   if (process.stdin.isTTY && process.stdout.isTTY) {
@@ -727,7 +733,12 @@ if (!workerKey || !apiBase) {
         await saveState({ ...(await loadState()), chosenMode: mode0 ?? "client" });
         if (mode0 === "client-expert") {
           clientExpertRanThisProcess = true;
-          const setup = await runClientExpertSetup({ ask: ask0 });
+          // #301/#300: Esc-aware and masked readers on the same rl0 — the model questions offer
+          // Esc, and a key or a password must not echo.
+          const { setupPrompts } = await import("./setup-prompts.mjs");
+          const sp = setupPrompts(rl0, { style: accent });
+          const setup = await runClientExpertSetup({ ask: ask0, askStep: sp.askStep, askSecret: sp.askSecret });
+          if (setup.loadPreset) openPresetsAtStart = true;
           // STOP when setup cannot go further.
           //
           // This used to fall through to the hosted sign-in, on the theory that "this machine
@@ -1943,9 +1954,12 @@ let lastPromptBreakdown = null;
  * never leads it, so the screen never claims output that has not been produced.
  */
 let shownOutputTokens = 0;
-// The same for INPUT (#53): this turn's input so far — the bar's "sent" — shown as "↑ N" before
-// the "↓ N" output figure, so the thinking line reads both directions the way the bar does.
+// The same for INPUT (#53), shown as "↑ N" before the "↓ N" output figure.
 let shownInputTokens = 0;
+// Task #298: both figures are THIS STEP's, not the turn's (the bar has those). Which step the
+// shown values belong to, so a new step starts its count from zero instead of easing on from
+// the previous step's number.
+let shownStepNo = 0;
 // Seconds from Enter to the first full prompt reaching the coding model (prompt assembly +
 // retrieval). Shown by /tokens; 0 until a turn has run.
 let lastPromptAssemblySeconds = 0;
@@ -2372,6 +2386,9 @@ const footerRows = () =>
     identity: identityLineText(),
     token: tokenLineText(),
     mode: modeLineText(),
+    // How to paste here (issue #67): the platform's text key, plus gu's image key when the coder
+    // can take an image.
+    modeHint: pasteHint({ images: coderTakesImages() }),
     // Its own row (#54), sized to the window so the fix it names is never the part cut off.
     notice: imageNotice
       ? orange("⚠ " + fitImageNotice(imageNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
@@ -5227,15 +5244,35 @@ async function reconfigureOllamaServer() {
 
   /** Load a box's models THROUGH THE PROXY (#160) — a bare fetch is what fails on a restricted
    *  network, and it fails as "no models", which is the wrong story entirely. */
-  const load = async (n) => {
+  const load = async (n, key = "") => {
     const res = await withPendingStatus(`loading models from ${n.host}`, () =>
-      proxyFetch(os.tagsUrlFor(n), { signal: AbortSignal.timeout(8000) })
+      proxyFetch(os.tagsUrlFor(n), {
+        signal: AbortSignal.timeout(8000),
+        // #301: the key typed for this server; absent → the request is what it always was.
+        ...(key ? { headers: { Authorization: `Bearer ${key}` } } : {}),
+      })
     );
     // The status is kept: a 404 here means "answered, but not an Ollama" (#43), not "unreachable".
     if (!res.ok) throw Object.assign(new Error(`HTTP ${res.status}`), { httpStatus: res.status });
     return am.parseOllamaTags(await res.json().catch(() => null));
   };
 
+  // #301: the way out, said under every server question (full once, short after), and the keys
+  // typed for servers, by host — saved against their rows once the settings are written.
+  const ui = await import("./model-setup-ui.mjs");
+  const hint = ui.createHinter();
+  const typedKeys = new Map();
+  const askKeyFor = async (host) => {
+    if (typedKeys.has(host)) return typedKeys.get(host); // same server for both roles → asked once
+    console.log(dim(`    ${hint()}`));
+    // askSecret: masked, kept out of history; Esc throws PromptCancelled → /model is cancelled
+    // with nothing changed, which is what "skip all" means here.
+    const k = (await askSecret(`  API key for ${host} (Enter for none): `)).trim();
+    typedKeys.set(host, k);
+    console.log(GUTTER + dim(ui.keyConfirmation(host, k)));
+    return k;
+  };
+
   /** Ask for one server and load it. Returns {normalized, models} or null (declined/failed). */
   const askServer = async (label, dflt, { require = false, short = "server", role = "coder" } = {}) => {
     for (let attempt = 0; attempt < 3; attempt++) {
@@ -5247,13 +5284,15 @@ async function reconfigureOllamaServer() {
       // — normalizeOllamaUrl adds it — and displayUrl round-trips, so what is shown can be fed
       // straight back as the default.
       console.log(dim(`  ${label} — Enter keeps ${os.displayUrl(dflt)}`));
+      console.log(dim(`    ${hint()}`));
       // THE ROW MUST SAY WHICH SERVER IT IS ASKING FOR. It said a bare "server:" — chosen to
       // fit the frozen row, which traded away the one thing the label was for. Two questions
       // in a row, both reading "server:", and the reader cannot tell which one they are
       // answering (reported: "it should say 'Agent + Embedder server' then 'Coding Server',
       // it only says 'server:'"). `short` is the role in the fewest words that still name it.
       const typed = (await ask(`  ${short}: `)).trim();
-      if (/^(no|n|skip|-)$/i.test(typed)) return null;
+      // "s" is the advertised skip (#301); the older words still work.
+      if (ui.readStepAnswer(typed).kind === "skip") return null;
       // EVERY READING OF A BARE HOSTNAME, in order. Typing "ollama2.gomarsic.cc" means
       // https://…:443 behind a proxy, while "192.168.1.40" means http://…:11434 — one guess
       // is right for one of them and produces a timeout that looks like a dead server for the
@@ -5266,15 +5305,33 @@ async function reconfigureOllamaServer() {
       let n = null;
       let models = null;
       let lastErr = null;
-      for (const cand of candidates) {
-        try {
-          models = await load(cand);
-          n = cand;
-          if (candidates.length > 1) console.log(dim(`  using ${os.displayUrl(cand.url)}`));
-          break;
-        } catch (err) {
-          lastErr = err;
+      // #301: a TYPED public address may need a key — asked before listing, so a server that
+      // needs one can list its models. A LAN box is never asked.
+      let key = "";
+      if (ui.shouldAskKey({ typed, host: candidates[0].host })) key = await askKeyFor(candidates[0].host);
+      const tryAll = async () => {
+        for (const cand of candidates) {
+          try {
+            models = await load(cand, key);
+            n = cand;
+            if (candidates.length > 1) console.log(dim(`  using ${os.displayUrl(cand.url)}`));
+            return;
+          } catch (err) {
+            lastErr = err;
+          }
         }
+      };
+      await tryAll();
+      // Refused for want of credentials: ask now, whatever the address looked like, and list again.
+      if (!n && ui.needsKeyAfterStatus(lastErr?.httpStatus) && !key) {
+        console.log(yellow(`  ${candidates[0].host} needs an API key to list its models.`));
+        typedKeys.delete(candidates[0].host);
+        key = await askKeyFor(candidates[0].host);
+        if (key) await tryAll();
+      }
+      if (!n && ui.needsKeyAfterStatus(lastErr?.httpStatus)) {
+        console.log(red(`  ${candidates[0].host} refused the request (HTTP ${lastErr.httpStatus})${key ? " — that key was not accepted" : ""}.`));
+        continue;
       }
       if (!n) {
         if (lastErr?.httpStatus === 404) {
@@ -5301,7 +5358,7 @@ async function reconfigureOllamaServer() {
         const need = os.checkRequired(models);
         if (!need.ok) {
           for (const l of os.describeNotReady(n.host, need.missing)) console.log(yellow(`  ${l}`));
-          console.log(dim("  (or type 'no' to skip — you can set it later with /model)"));
+          console.log(dim("  (or type s to skip — you can set it later with /model)"));
           continue;
         }
         console.log(dim(`  ✓ ${n.host} has the ${os.REQUIRED_AGENT_PREFIX} family and the embedder`));
@@ -5324,10 +5381,10 @@ async function reconfigureOllamaServer() {
   if (agentOnProvider) {
     const host = hostOf(String(settings.agentModelUrl ?? ""));
     console.log(dim(`  The agent model is on ${host} (OpenAI-compatible) — kept as it is; change it with /agent-model.`));
-    console.log(dim("  Enter keeps the current address; type 'no' to skip."));
+    console.log(dim("  Enter keeps the current address."));
   } else {
     console.log(dim("  TWO servers may be used: the agent + embedder on one, the coder on another."));
-    console.log(dim("  Enter keeps the current address; type 'no' to skip a role."));
+    console.log(dim("  Enter keeps the current address."));
     agent = await askServer("Agent + embedding server", curAgent, {
       require: true,
       short: "agent + embed server",
@@ -5472,6 +5529,32 @@ async function reconfigureOllamaServer() {
     console.log(GUTTER + dim("if this machine's local API is old, restart it with `gu api restart`.\n"));
     return;
   }
+  // #301: THE KEYS TYPED FOR THE SERVERS, bound to their rows now that the rows exist (the API
+  // refuses a key for a row it does not have). Before the cloud check below, so a key typed for
+  // the Ollama cloud is not asked for a second time. Reported by host, never by value.
+  {
+    const used = [agent?.normalized?.url, coder?.normalized?.url].filter(Boolean);
+    // By HOSTNAME: the key was asked for urlCandidates' host, which carries no port, while a URL's
+    // .host does — box.example.com:8443 would otherwise never match its own key.
+    const hostnameOf = (u) => { try { return new URL(u).hostname; } catch { return ""; } };
+    const pending = [...typedKeys].filter(([host, k]) => k && used.some((u) => hostnameOf(u) === host));
+    if (pending.length) {
+      const fresh = await withPendingStatus("storing the key", fetchWorkerSettings);
+      const ps = await import("./coding-provider-setup.mjs");
+      for (const [host, k] of pending) {
+        const url = used.find((u) => hostnameOf(u) === host);
+        const found = ps.providerRowForUrl(ps.existingBackendRows(fresh ?? {}), url);
+        if (!found) {
+          console.log(yellow(`  no server row holds ${host} yet — add its key with ctrl+k in /model.`));
+          continue;
+        }
+        const ok = await withPendingStatus("saving the key", () => addCodingKey(host, k, found.id));
+        console.log(ok
+          ? GUTTER + dim(`✓ key stored for ${host} — the server's default key`)
+          : red(`  couldn't store the key for ${host} — add it with ctrl+k.`));
+      }
+    }
+  }
   // THE OLLAMA CLOUD NEEDS ITS OWN KEY. Reported: choosing https://ollama.com here listed its 20 models
   // (that list is public) and saved, without a key — and the next turn failed "REJECTED the coding API
   // key", having borrowed an unrelated sk-… key. Asked for now, bound to the row just saved.
@@ -9634,6 +9717,9 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
   // Task #104: this turn's OUTPUT-token total, read from the job doc each poll. Folded into
   // the lifetime per-workspace + global counters once the turn completes.
   let latestOutputTokens = 0;
+  // Task #298: the current model call's own ↑/↓, read from the polled breakdown. null until
+  // this turn reports a step — never the previous turn's, which the kept breakdown still holds.
+  let liveStepTokens = null;
   let outputTokensPosted = false; // guard: increment the lifetime counters once per turn
   // Task #142: when this turn was submitted, and when its first full prompt reached the coding
   // model. The gap between them is prompt assembly + RAG retrieval — the thing the user asked
@@ -9875,10 +9961,18 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
     // Advanced once per tick — this branch runs ~8x/second while the agent is thinking, which is
     // what makes the climb visible at all. Parked (streaming) the block is not rebuilt, so the
     // figure holds rather than jittering against flowing output.
-    shownOutputTokens = easeCount(shownOutputTokens, latestOutputTokens);
-    shownInputTokens = easeCount(shownInputTokens, latestCodeTokens);
-    // ↑ input (this turn's "sent", every request so far — cached input included: the model read
-    // it) then ↓ output (#53). Each absent until known, never a "0" that claims a measurement.
+    // THIS STEP, NOT THE TURN (task #298). The turn totals were exactly the bar's "sent" and
+    // "↓ out" one row below — the same two numbers twice. ↑ is the current model call's prompt,
+    // ↓ its output (known when the call returns); both start from zero at each new step.
+    const st = liveStepTokens;
+    if (!st || st.step !== shownStepNo) {
+      shownStepNo = st ? st.step : 0;
+      shownInputTokens = 0;
+      shownOutputTokens = 0;
+    }
+    shownOutputTokens = easeCount(shownOutputTokens, st ? st.stepOut : 0);
+    shownInputTokens = easeCount(shownInputTokens, st ? st.stepIn : 0);
+    // ↑ input then ↓ output (#53). Each absent until known, never a "0" that claims a measurement.
     const outLabel =
       (shownInputTokens > 0 ? dim(" · ↑ ") + accent(fmtTokens(shownInputTokens)) : "") +
       (shownOutputTokens > 0 ? dim(" · ↓ ") + accent(fmtTokens(shownOutputTokens)) : "");
@@ -10493,6 +10587,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
       // what is in the context right now, so it must be allowed to shrink when a trim lands.
       if (job.agentPromptBreakdown && typeof job.agentPromptBreakdown === "object") {
         lastPromptBreakdown = job.agentPromptBreakdown;
+        liveStepTokens = readStepTokens(job.agentPromptBreakdown);
         // Persisted per folder so the next `gu` here starts from the real picture instead
         // of a zero that looks like a failure. Fire-and-forget: a bar value is never worth
         // delaying a turn for, and losing one is harmless. Shown while attached (it is what
@@ -10853,8 +10948,18 @@ async function main() {
       // recorded, so once the choice was saved this block was skipped and the plan sat on disk
       // untouched. Picking it up here is what makes the sentence true.
       const { runClientExpertSetup } = await import("./client-expert-run.mjs");
-      const setup = await runClientExpertSetup({ ask });
+      const { SKIP_ALL } = await import("./model-setup-ui.mjs");
+      // #301: keys (and the MongoDB password) through the REPL's own masked prompt; a cancelled
+      // one means "skip the rest", not a crash of the setup.
+      const toSkipAll = (e) => (e instanceof PromptCancelled ? SKIP_ALL : Promise.reject(e));
+      const setup = await runClientExpertSetup({
+        ask,
+        // Esc at a model question throws PromptCancelled here; in setup it means "skip all".
+        askStep: (q) => ask(q).catch(toSkipAll),
+        askSecret: (q) => askSecret(q).catch(toSkipAll),
+      });
       if (setup?.complete) reloadWorkerEnv();
+      if (setup?.loadPreset) openPresetsAtStart = true;
     }
   } catch {
     /* never block the REPL on the mode question — the banner still shows what is configured */
@@ -11605,6 +11710,17 @@ async function main() {
   // rows it pushes up are real output rather than half-drawn setup.
   syncBarPinning();
 
+  // #301: setup's "Load a saved preset" — the picker opens now that the terminal exists. The whole
+  // /load-presets flow (the list, the plan, the confirmation, the key) is that command's own.
+  if (openPresetsAtStart) {
+    openPresetsAtStart = false;
+    try {
+      await runLoadPresetsCommand("/load-presets");
+    } catch (e) {
+      console.log(GUTTER + dim(`(could not open the presets: ${e?.message ?? e} — run /load-presets)`));
+    }
+  }
+
   for (;;) {
     stopPendingStatus(); // nothing from a previous turn may still be animating (task #140)
     // The bar and the input line live in the frozen rows at the bottom of the window (task

package/model-setup-ui.mjs

@@ -0,0 +1,114 @@
+/**
+ * THE WAY OUT OF THE MODEL QUESTIONS, and the key question that follows a typed server (#301).
+ *
+ * Reported: at "Agent + embedding server [https://ollama1.gomarsic.cc]:" there was no visible way
+ * to NOT choose. Enter takes the default server; a decline existed ("n", "no", "skip", "-") but no
+ * prompt said so, and one hint even claimed "press Enter with no address to skip", which was the
+ * opposite of what Enter does. Some people want no model setup at all and to load a saved preset.
+ *
+ * The decisions, agreed with the user (2026-09-29):
+ *   · ASK ONCE, UP FRONT — guided / load a preset / skip. Enter = guided, so today's flow is one
+ *     keypress away and unchanged.
+ *   · TWO WAYS OUT, NOT FIVE — "s" skips a step, Esc skips all model setup. The old words still
+ *     work, silently.
+ *   · FULL HINT ONCE, THEN SHORT — a hint under every prompt is noise by the fourth.
+ *   · A KEY ONLY WHEN ONE MAY BE NEEDED — a LAN Ollama box never needs one, a public https
+ *     address may, and a server that answers 401/403 certainly does.
+ *   · CONFIRM THE KEY WITHOUT SHOWING IT — a masked prompt gives no sign it took anything.
+ *
+ * PURE. Everything here is strings in, strings out, so the whole table is a test.
+ */
+import { hostLocality } from "./coding-provider-setup.mjs";
+
+/**
+ * What an Esc-aware prompt resolves to when Esc is pressed. A string no one can type (it starts
+ * with NUL), so it can travel through every `ask` that returns strings without a new type.
+ */
+export const SKIP_ALL = "\u0000skip-all";
+
+/** Esc, as readline reports it: name "escape" (meta:true on most terminals — accept either). */
+export function isEscapeKey(key) {
+  return Boolean(key) && (key.name === "escape" || (key.meta && key.sequence === "\x1b"));
+}
+
+/**
+ * One answer at a model prompt → what it means.
+ *   { kind: "all" }          Esc: skip all model setup
+ *   { kind: "skip" }         "s" (or the older n / no / skip / -): skip this step
+ *   { kind: "answer", text } anything else, including "" (= the default)
+ */
+export function readStepAnswer(raw) {
+  if (raw === SKIP_ALL) return { kind: "all" };
+  const text = String(raw ?? "").trim();
+  if (/^(s|n|no|skip|-)$/i.test(text)) return { kind: "skip" };
+  return { kind: "answer", text };
+}
+
+export const FULL_HINT = "Enter = use this · s = skip this step · Esc = skip all model setup";
+export const SHORT_HINT = "s skip · esc skip all";
+
+/** A hinter: the full hint the first time it is asked for, the short one after. */
+export function createHinter() {
+  let shown = false;
+  return () => {
+    if (shown) return SHORT_HINT;
+    shown = true;
+    return FULL_HINT;
+  };
+}
+
+/**
+ * Should typing THIS address be followed by "API key for <host>"?
+ *
+ * Only for an address that was TYPED (Enter on the default is today's path and stays one key),
+ * and only when the host is public: a LAN box (192.168.x, 10.x, *.local, a bare hostname,
+ * localhost) is an Ollama that takes no key, and asking there is a question with one answer.
+ * A server that answers 401/403 is asked regardless — see needsKeyAfterStatus.
+ */
+export function shouldAskKey({ typed, host }) {
+  if (!String(typed ?? "").trim()) return false;
+  return hostLocality(host) === "public";
+}
+
+/** The server refused to list its models without credentials. */
+export function needsKeyAfterStatus(status) {
+  return status === 401 || status === 403;
+}
+
+/** The last 4 characters, in the bar's own style — enough to tell keys apart, not to use one. */
+export function keyTail(key) {
+  const k = String(key ?? "").trim();
+  return k.length > 4 ? `····${k.slice(-4)}` : "····";
+}
+
+/** The line printed after the masked prompt, so the person knows whether it took anything. */
+export function keyConfirmation(host, key) {
+  return String(key ?? "").trim()
+    ? `✓ key saved for ${host} (${keyTail(key)})`
+    : `no key for ${host}`;
+}
+
+/**
+ * The up-front question. `presets` = how many saved presets there are: with none, option 2 still
+ * shows (so the feature is discoverable) but says how to make one instead of offering nothing.
+ */
+export function modelSetupMenu({ presets = 0 } = {}) {
+  return [
+    "How do you want to set up the models?",
+    "  1  Guided — pick the servers and models   (Enter)",
+    presets > 0
+      ? `  2  Load a saved preset   (${presets} saved)`
+      : "  2  Load a saved preset   (none saved yet — /save-preset makes one)",
+    "  3  Skip for now — set them later with /model",
+  ];
+}
+
+/** An answer to the up-front question → "guided" | "preset" | "skip", or null to ask again. */
+export function parseModelSetupChoice(raw) {
+  if (raw === SKIP_ALL) return "skip";
+  const t = String(raw ?? "").trim().toLowerCase();
+  if (t === "" || t === "1" || t === "guided" || t === "g") return "guided";
+  if (t === "2" || t === "preset" || t === "p") return "preset";
+  if (t === "3" || t === "s" || t === "skip" || t === "n" || t === "no" || t === "-") return "skip";
+  return null;
+}