@tiens.nguyen/gu-cli 1.0.695 → 1.0.697

package/coding-choice-tags.mjs

@@ -67,3 +67,36 @@ export function codingChoiceTags(choices) {
   });
   return { tags, show: new Set(tags).size > 1 };
 }
+
+/**
+ * WHERE AN OLLAMA CODER RUNS — "ollama.com", "127.0.0.1", "ollama1.gomarsic.cc" — or "" for any
+ * other kind.
+ *
+ * Reported: "/model ✓ coding model → kimi-k3 (ollama)". The tag was the API's provider label, the
+ * first word of the host, so https://ollama.com read "ollama" — the same word as the KIND — and a
+ * paid cloud model looked exactly like one on this machine. Whether it is local or cloud decides
+ * whether it costs money and needs a key, so it is shown as a prefix wherever the coder is named.
+ *
+ * The Ollama default port (11434) is left off; any other port is kept, because two local servers on
+ * different ports are different servers.
+ */
+export function ollamaWhere(kind, url) {
+  if (kind !== "ollama") return "";
+  let u;
+  try {
+    u = new URL(String(url ?? ""));
+  } catch {
+    return "";
+  }
+  const host = u.hostname.toLowerCase().replace(/\.$/, "").replace(/^\[|\]$/g, "");
+  if (host === "ollama.com" || host.endsWith(".ollama.com")) return "ollama.com";
+  const local = host === "localhost" || host === "127.0.0.1" || host === "::1";
+  const port = u.port && u.port !== "11434" ? `:${u.port}` : "";
+  return (local ? "127.0.0.1" : host) + port;
+}
+
+/** The coder's name as shown: "ollama.com/kimi-k3" for an Ollama coder, the bare name otherwise. */
+export function coderDisplayName(name, where) {
+  const n = String(name ?? "").trim();
+  return where && n ? `${where}/${n}` : n;
+}

package/coding-key-prompt.mjs

@@ -52,6 +52,34 @@ export function isKeylessCodingHost(url) {
   return host === "gomarsic.cc" || host.endsWith(".gomarsic.cc");
 }
 
+/**
+ * TRUE only for the Ollama CLOUD (https://ollama.com, or a subdomain of it). Mirrors
+ * isOllamaCloudUrl in api/src/store/settingsTypes.ts, web/src/lib/coderChoices.mjs and
+ * _isOllamaCloudUrl in gu-cli.mjs — keep them in step.
+ */
+export function isOllamaCloudUrl(url) {
+  const v = String(url ?? "").trim();
+  if (!/^https:\/\//i.test(v)) return false;
+  let host;
+  try {
+    host = new URL(v).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return false;
+  }
+  return host === "ollama.com" || host.endsWith(".ollama.com");
+}
+
+/**
+ * DOES THIS CODER NEED AN API KEY? — an OpenAI-compatible provider, or Ollama's paid CLOUD.
+ *
+ * Reported: /model on kimi-k3 at https://ollama.com said "needs no API key — nothing to set", so
+ * there was no way to give it one. Every "needs a key" check had been `kind === "openai"`, on the
+ * belief that Ollama never authenticates — true of a local or LAN Ollama, false of ollama.com.
+ */
+export function codingNeedsKey(kind, url) {
+  return kind === "openai" || (kind === "ollama" && isOllamaCloudUrl(url));
+}
+
 /**
  * @param payload  the /agent-payload `payload` object (reads codingKeyMissing/codingKeyModel).
  * @param deps.askSecret  async (prompt) => string  — masked input; "" means the user skipped.
@@ -113,8 +141,10 @@ export async function promptCodingKeyIfMissing(payload, { askSecret, saveCodingK
  *
  * There is a coder either way; what differs is whether it can be USED yet. Name it, and say so.
  */
-export function codingBannerLabel(payload, { dim = identity, override = "" } = {}) {
+export function codingBannerLabel(payload, { dim = identity, override = "", where = "" } = {}) {
   const p = payload ?? {};
+  // "ollama.com/kimi-k3" rather than "kimi-k3": local or cloud, visible in the header too.
+  const named = (n) => (where && n ? `${where}/${n}` : n);
   // A `/model` PICK WINS OVER THE ACCOUNT DEFAULT, because it is what the next turn will
   // actually use. The payload carries the account's coder; the override is this folder's,
   // restored from its session file at startup. Reading only the payload put two different
@@ -124,15 +154,15 @@ export function codingBannerLabel(payload, { dim = identity, override = "" } = {
   // Only possible since the pick started surviving an exit; before that the override was always
   // empty at startup and the two could not disagree.
   const pick = String(override ?? "").trim();
-  if (pick) return pick;
-  if (p.codingModelId) return String(p.codingModelId);
+  if (pick) return named(pick);
+  if (p.codingModelId) return named(String(p.codingModelId));
   const name = String(p.codingKeyMissing ? p.codingKeyModel || "" : "").trim();
   if (!name) return dim("—");
   // A keyless host is never asked for anything — the prompt stores the placeholder itself and
   // the coder is live moments later, so "(needs a key)" would be a lie with a shelf life of
   // about one line.
-  if (isKeylessCodingHost(p.codingKeyUrl)) return name;
-  return name + dim(" (needs a key)");
+  if (isKeylessCodingHost(p.codingKeyUrl)) return named(name);
+  return named(name) + dim(" (needs a key)");
 }
 
 /**
@@ -187,9 +217,10 @@ export function codingKeyFallbackLine(kj, jobId = "") {
  * when a choice HAS been made, and when only one key exists — with one there is nothing to
  * choose, and a warning on a correct setup is how warnings stop being read.
  */
-export function unchosenKeyWarning({ codingKind = "", selectedKeyId = "", keys = null } = {}) {
+export function unchosenKeyWarning({ codingKind = "", codingUrl = "", selectedKeyId = "", keys = null } = {}) {
   const quiet = { warn: false, using: null, why: "" };
-  if (codingKind !== "openai") return quiet; // Ollama and local MLX need no credential
+  // Local Ollama and MLX need no credential; the Ollama cloud does.
+  if (!codingNeedsKey(codingKind, codingUrl)) return quiet;
   if (!Array.isArray(keys) || keys.length < 2) return quiet;
   if (String(selectedKeyId ?? "").trim()) return quiet;
   return { warn: true, using: keys[0], why: "none-chosen" };
@@ -200,7 +231,8 @@ export function unchosenKeyWarning({ codingKind = "", selectedKeyId = "", keys =
  *
  * REPORTED: the bar's "key not chosen" mark only appeared after running /model. The startup gate
  * read `payload.codingKind`, and a payload fetched with NO override describes the ACCOUNT DEFAULT
- * — on the reporting machine that was kimi-k3 at ollama.com, kind "ollama", which needs no key —
+ * — on the reporting machine kimi-k3 at ollama.com, kind "ollama" (which, it turned out later,
+ * DOES need a key: see codingNeedsKey) —
  * while the folder was pointed at gpt-5, kind "openai". So the check answered a question about a
  * coder the folder was not using, said "nothing to warn about", and stayed silent. /model looked
  * right because it re-probes WITH the override.
@@ -212,6 +244,17 @@ export function unchosenKeyWarning({ codingKind = "", selectedKeyId = "", keys =
  * Matched by id OR by bare model name, mirroring that validation: a session saved before ids were
  * qualified ("<kind>::<model>", task #123) stores the bare form and is still a valid pick.
  */
+/** The folder's coder — its kind AND its URL, which together decide whether it needs a key. */
+export function effectiveCoder({ sessionCodingModel = "", choices = null, defaultKind = "", defaultUrl = "" } = {}) {
+  const want = String(sessionCodingModel ?? "").trim();
+  const list = Array.isArray(choices) ? choices : [];
+  if (want) {
+    const hit = list.find((c) => c?.id === want || c?.model === want);
+    if (hit) return { kind: String(hit.kind ?? ""), url: String(hit.url ?? "") };
+  }
+  return { kind: String(defaultKind ?? ""), url: String(defaultUrl ?? "") };
+}
+
 export function effectiveCoderKind({
   sessionCodingModel = "",
   choices = null,

package/gu-cli.mjs

@@ -20,7 +20,7 @@ import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
 import { ragJobConfig } from "./rag-job-config.mjs";
-import { codingKeyFallbackLine } from "./coding-key-prompt.mjs";
+import { codingKeyFallbackLine, isOllamaCloudUrl } from "./coding-key-prompt.mjs";
 // Pure layout helpers — safe to import here (no side effects on load, unlike gu-repl.mjs).
 // Shared so the mid-run picker and the REPL's post-stop advice cannot word the same budget
 // differently.
@@ -3265,22 +3265,8 @@ function _isLocalCodingUrl(baseURL) {
   return !host.includes(".") && !host.includes(":");
 }
 
-/** TRUE only for the Ollama CLOUD endpoint (https://ollama.com[/...]) — the one Ollama
- *  backend that actually requires an API key. Any other Ollama URL (localhost, a LAN
- *  box, a self-hosted remote) has no auth and gets no key. Mirrors isOllamaCloudUrl in
- *  web/src/lib/coderChoices.mjs — keep the two in step. */
-function _isOllamaCloudUrl(baseURL) {
-  const v = String(baseURL || "").trim();
-  if (!/^https:\/\//i.test(v)) return false;
-  let host = "";
-  try {
-    host = new URL(v).hostname.toLowerCase().replace(/\.$/, "");
-  } catch {
-    return false;
-  }
-  return host === "ollama.com" || host.endsWith(".ollama.com");
-}
-
+/** The Ollama cloud check lives in coding-key-prompt.mjs, shared with the terminal. */
+const _isOllamaCloudUrl = isOllamaCloudUrl;
 
 /** Resolve to "ollama" | "openai" | "local". `kind` is the user's Settings choice
  *  ("ollama" | "openai" | "" = Auto). Only Auto costs a probe. */

package/gu-repl.mjs

@@ -113,7 +113,7 @@ import {
 } from "./terminal-layout.mjs";
 import { completedFlush } from "./completed-flush.mjs";
 import { codingBannerLabel, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
-import { codingChoiceTags } from "./coding-choice-tags.mjs";
+import { codingChoiceTags, coderDisplayName, ollamaWhere } from "./coding-choice-tags.mjs";
 import {
   isDoubleClick,
   clickRun,
@@ -1973,11 +1973,14 @@ let keyChoicePending = false;
 const identityLineText = () =>
   identityRow(
     {
-      coder: activeCoderName({
-        sessionLabel: sessionCodingLabel,
-        sessionModel: sessionCodingModel,
-        accountDefault: defaultCodingModel,
-      }),
+      coder: coderDisplayName(
+        activeCoderName({
+          sessionLabel: sessionCodingLabel,
+          sessionModel: sessionCodingModel,
+          accountDefault: defaultCodingModel,
+        }),
+        activeCoderWhere,
+      ),
       folder: folderLabel(),
       keyUnchosen: keyChoicePending,
     },
@@ -3480,7 +3483,15 @@ if (process.stdin.isTTY) {
     // a running turn owns the screen, and a masked prompt drawn over either corrupts both.
     if (key && key.ctrl && key.name === "k" && !slashOverlayActive && !following
         && !listPickerActive && !approvalActive) {
-      void replaceCodingKey();
+      // NOT a bare `void`: this runs outside the command loop that turns Esc into "(cancelled)",
+      // so an Esc at the key's name or secret escaped as an unhandled rejection and ENDED THE
+      // PROCESS (reported: "PromptCancelled: cancelled … Node.js v22"). Cancel is caught here; any
+      // other failure is reported and the session goes on — a keypress must not kill the REPL.
+      replaceCodingKey().catch((e) => {
+        if (wasPromptCancelled(e)) console.log(dim("  (cancelled)\n"));
+        else console.log(red(`  ctrl+k failed: ${e?.message ?? e}\n`));
+        paintBar();
+      });
       return;
     }
     if (key && key.ctrl && key.name === "t" && !slashOverlayActive) {
@@ -5780,8 +5791,11 @@ async function chooseModel() {
   // OpenAI-compatible providers are both "OpenAI-compatible", so the kind names neither.
   const { tags, show: showTag } = codingChoiceTags(choices);
   const labels = choices.map((c, i) => {
-    const tag = showTag ? `  ${dim(`· ${tags[i]}`)}` : "";
-    return `${c.model}${tag}${c.id === def ? "  (default)" : ""}`;
+    // An Ollama row says WHERE it runs in front of the name ("ollama.com/kimi-k3"), so the kind tag
+    // beside it would only repeat "Ollama". Other rows keep the tag rule.
+    const where = ollamaWhere(c.kind, c.url);
+    const tag = showTag && !where ? `  ${dim(`· ${tags[i]}`)}` : "";
+    return `${coderDisplayName(c.model, where)}${tag}${c.id === def ? "  (default)" : ""}`;
   });
   const activeIdx = choices.findIndex((c) => c.id === active);
   labels.push("change the Ollama server this machine uses…");
@@ -5827,9 +5841,12 @@ async function chooseModel() {
   // WRITTEN NOW, not at the end of the next turn: `/model` then `/exit` is how the choice is
   // made and then tested, and that path never reaches saveSession.
   await saveSessionCoding(resolve(process.cwd()));
-  const where = showTag ? ` (${tags[idx]})` : "";
+  activeCoderWhere = ollamaWhere(chosen.kind, chosen.url);
+  const where = showTag && !activeCoderWhere ? ` (${tags[idx]})` : "";
   console.log(
-    accent(`  ✓ coding model → ${chosen.model}${where}${chosen.id === def ? " (default)" : ""}\n`)
+    accent(
+      `  ✓ coding model → ${coderDisplayName(chosen.model, activeCoderWhere)}${where}${chosen.id === def ? " (default)" : ""}\n`
+    )
   );
   // DOES THIS ONE NEED AN API KEY? (task #181) Reported live on Windows 11 / Client Expert:
   // picking kimi-k3 here and asking a question just span — the coder needs a key, none was
@@ -6779,7 +6796,9 @@ async function coderKeyState(override = "") {
     const active = override
       ? choices.find((c) => c.id === override)
       : choices.find((c) => c.isDefault);
-    const needsKey = active?.kind === "openai";
+    // Kind AND url: an Ollama coder at https://ollama.com needs a key; a local one does not.
+    const { codingNeedsKey } = await import("./coding-key-prompt.mjs");
+    const needsKey = codingNeedsKey(active?.kind, active?.url);
     return {
       needsKey,
       model: p.codingKeyModel || active?.model || "the coding model",
@@ -7667,6 +7686,8 @@ let defaultCodingModel = "";
 // another backend must not keep showing the previous backend's total). Empty = let the API
 // fall back to the account-default URL from settings (older behaviour).
 let sessionCodingUrl = "";
+/** "ollama.com" / "127.0.0.1" / a host — where the ACTIVE coder runs, when it is an Ollama one. */
+let activeCoderWhere = "";
 // The account-default backend's URL (from the startup probe's codingChoices), used when no
 // /model override is active. Set once at startup alongside defaultCodingModel.
 let defaultCodingUrl = "";
@@ -9327,6 +9348,17 @@ async function main() {
         sessionCodingUrl = "";
       }
     }
+    {
+      // WHERE THE CODER RUNS, for the banner and the bar: the folder's pick, else the default.
+      const choices = Array.isArray(probe?.codingChoices) ? probe.codingChoices : [];
+      const active =
+        (sessionCodingModel && choices.find((c) => c.id === sessionCodingModel || c.model === sessionCodingModel)) ||
+        choices.find((c) => c.isDefault) ||
+        null;
+      // No choice list (an older API): no prefix, rather than guess from the ACCOUNT default's raw
+      // payload fields, which key-choice-regression.test.mjs forbids for exactly that reason.
+      activeCoderWhere = active ? ollamaWhere(active.kind, active.url) : "";
+    }
     // Task #133: no RAG storage question any more — the terminal ALWAYS keeps the index on
     // this machine. `/rag-cloud` opts into additionally mirroring it to the user's S3 bucket.
     // Startup banner (task #131): the gu logo on the left, compact status facts on the
@@ -9375,6 +9407,7 @@ async function main() {
               sessionLabel: sessionCodingLabel,
               sessionModel: sessionCodingModel,
             }),
+            where: activeCoderWhere,
           }),
         lbl("RAG") +
           (p.ragEnabled
@@ -9561,7 +9594,7 @@ async function main() {
       // folder has not chosen, and more than one is stored.
       try {
         if (!keyRes?.saved) {
-          const { unchosenKeyWarning, effectiveCoderKind } = await import(
+          const { unchosenKeyWarning, effectiveCoder, codingNeedsKey } = await import(
             "./coding-key-prompt.mjs"
           );
           // THE RULE LIVES IN THE MODULE so it can be tested by calling it. Open-coded here it
@@ -9574,15 +9607,17 @@ async function main() {
           // machine an Ollama coder, which needs no key — while the folder was on gpt-5. Reading
           // it directly made this check answer about a coder nobody was using, and the mark only
           // appeared after /model, which re-probes WITH the override.
-          const kind = effectiveCoderKind({
+          const { kind, url } = effectiveCoder({
             sessionCodingModel,
             choices: probe?.codingChoices,
             defaultKind: p?.codingKind,
+            defaultUrl: probe?.codingChoices?.find?.((c) => c?.isDefault)?.url ?? "",
           });
           const allKeys =
-            kind === "openai" && !sessionCodingKeyId ? await fetchCodingKeys() : null;
+            codingNeedsKey(kind, url) && !sessionCodingKeyId ? await fetchCodingKeys() : null;
           const w = unchosenKeyWarning({
             codingKind: kind,
+            codingUrl: url,
             selectedKeyId: sessionCodingKeyId,
             keys: allKeys,
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.695",
+  "version": "1.0.697",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",