@tiens.nguyen/gu-cli 1.0.721 → 1.0.723

package/ollama-setup.mjs

@@ -20,6 +20,7 @@
  */
 import { isLikelyEmbedder } from "./agent-model-command.mjs";
 import { EMBED_CHOICES } from "./embed-model-command.mjs";
+import { isCancelWord } from "./coding-provider-setup.mjs";
 
 /** Ollama's native port, used when someone types a bare host or an IP with no port. */
 export const OLLAMA_DEFAULT_PORT = 11434;
@@ -190,6 +191,8 @@ export function describeNotReady(host, missing) {
 export function normalizeOllamaUrl(raw) {
   const text = String(raw ?? "").trim();
   if (!text) return null;
+  // "exit", "quit", "cancel"… are commands, never hosts (they were once saved as http://exit).
+  if (isCancelWord(text)) return null;
   // A path, a query, or whitespace inside means this is not a host we can reason about.
   if (/\s/.test(text)) return null;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.721",
+  "version": "1.0.723",
   "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",
@@ -73,7 +73,6 @@
     "first-run-steps.mjs",
     "proxy-config.mjs",
     "agent-model-command.mjs",
-    "ollama-host-snippets.mjs",
     "ollama-setup.mjs",
     "s3-setup.mjs",
     "doctor-check.mjs",
@@ -84,6 +83,8 @@
     "proxy-dispatcher.mjs",
     "model-doctor.mjs",
     "coding-key-prompt.mjs",
+    "server-keys.mjs",
+    "add-server.mjs",
     "powershell-alias.mjs",
     "install-path.mjs",
     "gonext_probe_agent.py",

package/server-keys.mjs

@@ -0,0 +1,97 @@
+/**
+ * A KEY BELONGS TO A SERVER URL, NOT TO A MODEL (task #245) — the terminal's decisions, pure.
+ *
+ * The rules the user set:
+ *   · a server URL owns its keys (many, named) and its models (at most MAX_MODELS_PER_SERVER);
+ *   · the first key chosen for a server becomes its DEFAULT for every later terminal / project;
+ *   · picking another key in a folder applies to that folder only, PER ROLE (coding/agent/embed);
+ *   · the switch picker loads the current server's keys only;
+ *   · deleting the first key entered for a server warns — its model list was loaded with it.
+ *
+ * The API owns resolution (resolveKeyForRole in api/src/app.ts); this module only decides what
+ * the terminal shows and asks, so /model, /agent-model and /embed-model cannot drift apart.
+ */
+
+/** The three roles, the folder-choice field each one's pick lives in, and how to say it. */
+export const KEY_ROLES = {
+  coding: { field: "codingKeyId", label: "coding model" },
+  agent: { field: "agentKeyId", label: "agent model" },
+  embed: { field: "embedKeyId", label: "embedding model" },
+};
+
+export function roleOf(role) {
+  return KEY_ROLES[role] ?? KEY_ROLES.coding;
+}
+
+/**
+ * The key a folder is actually on, as the API will resolve it — for the "(in use)" mark and the
+ * bar's tail. Mirrors resolveCodingApiKey: the folder's pick (one of THIS server's keys) → the
+ * server's default → its first key → any of its keys → a key tied to no server.
+ * `keys` is GET /coding-keys?backendId=… (this server's keys, then unbound ones).
+ */
+export function keyInUse(keys, backendId, folderKeyId = "") {
+  const list = Array.isArray(keys) ? keys : [];
+  const own = list.filter((k) => k && k.backendId === backendId);
+  const loose = list.filter((k) => k && !k.backendId);
+  return (
+    (folderKeyId && own.find((k) => k.id === folderKeyId)) ||
+    own.find((k) => k.default) ||
+    own.find((k) => k.first) ||
+    own[0] ||
+    loose[0] ||
+    null
+  );
+}
+
+/** What a picker row says about a key besides its name and tail. Order: most specific first. */
+export function keyTags(k, { folderKeyId = "", inUseId = "" } = {}) {
+  const tags = [];
+  if (k.id === folderKeyId) tags.push("this folder");
+  else if (k.id === inUseId) tags.push("in use");
+  if (k.default) tags.push("default");
+  if (k.first) tags.push("first key");
+  if (!k.backendId) tags.push("not tied to a server yet");
+  return tags;
+}
+
+/**
+ * After a key is picked: WHERE does the choice apply? The first key chosen for a server already
+ * became its default (the API stamps it), so this is only asked when the pick differs from the
+ * server's default. Returns the rows to offer, in order; `scope` is what each one means.
+ */
+export function scopeChoices({ host = "the server", role = "coding" } = {}) {
+  return [
+    { scope: "folder", label: `just this folder's ${roleOf(role).label}` },
+    { scope: "default", label: `make it the default for ${host} — every folder that has not picked its own` },
+  ];
+}
+
+/**
+ * The warnings before a key is deleted, from DELETE /coding-keys/:id?dryRun=1. Irreversible, so
+ * everything that changes is said first. The FIRST key gets its own line, as asked: "if later
+ * user delete that key we need to warn the user that it was the first key that user input for
+ * that server url".
+ */
+export function deleteWarnings(preview, { host = "this server", isFolderPick = false, roleLabel = "", lastOfServer = false } = {}) {
+  const lines = [];
+  // No preview (an older API, or it could not be reached) still gets the warnings the terminal
+  // can work out itself — this folder's pick, the server's last key.
+  preview = preview && typeof preview === "object" ? preview : {};
+  if (preview.wasFirst) {
+    lines.push(`This was the FIRST key you entered for ${host} — its model list was loaded with it.`);
+  }
+  if (preview.wasDefault) {
+    lines.push(`It is ${host}'s default key — folders without their own pick fall back to another key of ${host}, or none.`);
+  }
+  if (isFolderPick) {
+    lines.push(`This folder uses it${roleLabel ? ` for the ${roleLabel}` : ""} — it will fall back to ${host}'s default.`);
+  }
+  if (lastOfServer) {
+    lines.push(`It is the only key stored for ${host} — every model there will have none until you add another.`);
+  }
+  const others = Number(preview.folders ?? 0) - (isFolderPick ? 1 : 0);
+  if (others > 0) {
+    lines.push(`${others} other folder${others === 1 ? "" : "s"} picked it${Array.isArray(preview.roles) && preview.roles.length ? ` (${preview.roles.join(", ")})` : ""}.`);
+  }
+  return lines;
+}

package/settings-transfer.mjs

@@ -29,13 +29,100 @@
  * your models should not also decide which one you are coding with.
  */
 
-/** Bumped only when an older gu could not read a newer file correctly. */
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import { ensureV1Root, isCancelWord, MAX_MODELS_PER_SERVER } from "./coding-provider-setup.mjs";
+
+/** The file name used when none is given — in the default folder (the home directory). */
+export const DEFAULT_SETTINGS_NAME = "gu-settings.json";
+
+/**
+ * What was typed → the file to use. The DEFAULT FOLDER is the home directory, so a bare NAME is
+ * all anyone has to type ("work" → ~/work.json); a real path still works as one.
+ *   ""                 → ~/gu-settings.json
+ *   "work"             → ~/work.json            (".json" added when there is no extension)
+ *   "work.json"        → ~/work.json
+ *   "~/dir/x.json"     → ~/dir/x.json
+ *   "./x.json", "/abs" → that path exactly (relative ones from the current folder, as a shell would)
+ * Quotes around the whole thing are stripped — people paste paths with them. Returns "" for a
+ * command word ("exit", "cancel", …), which the caller treats as a cancel.
+ */
+export function settingsFilePath(typed, home) {
+  const t = String(typed ?? "").trim().replace(/^['"]|['"]$/g, "").trim();
+  if (!t) return join(home, DEFAULT_SETTINGS_NAME);
+  if (isCancelWord(t)) return "";
+  if (t === "~") return join(home, DEFAULT_SETTINGS_NAME);
+  if (t.startsWith("~/")) return withJson(join(home, t.slice(2)));
+  // An explicit path is taken exactly as typed — no ".json" guessed onto a name someone spelled out.
+  if (isAbsolute(t) || t.startsWith("./") || t.startsWith("../") || /[\\/]/.test(t)) return resolve(t);
+  return withJson(join(home, t));
+}
+
+const withJson = (p) => (extname(basename(p)) ? p : `${p}.json`);
+
+/**
+ * The settings files in the default folder, newest first — what /load-settings offers when it is
+ * given no name. Only files that ARE gu settings files (the "gu": "settings" marker), so a
+ * package.json in the home directory is never offered. `entries` = [{ name, text, mtimeMs }].
+ */
+export function settingsFilesIn(entries) {
+  return (Array.isArray(entries) ? entries : [])
+    .filter((e) => e && /\.json$/i.test(e.name) && /"gu"\s*:\s*"settings"/.test(String(e.text ?? "")))
+    .sort((a, b) => (b.mtimeMs ?? 0) - (a.mtimeMs ?? 0))
+    .map((e) => e.name);
+}
+
+/**
+ * Bumped only when an older gu could not read a newer file correctly. Task #245 ADDED optional
+ * fields (embedModel, keys[].default) — an older gu ignores them and still loads the rest, so the
+ * version stays 1.
+ */
 export const FILE_VERSION = 1;
 
 /** The kinds the API's own type allows (CodingBackendKind). */
 const KINDS = ["", "ollama", "openai", "local"];
 
 const isHttpUrl = (v) => typeof v === "string" && /^https?:\/\/\S+$/i.test(v.trim());
+
+/** Two spellings of one server are one server — the rule the API and providerRowForUrl use. */
+const sameServerUrl = (a, b) =>
+  Boolean(clean(a) && clean(b)) && ensureV1Root(clean(a)).toLowerCase() === ensureV1Root(clean(b)).toLowerCase();
+
+/** A server's models, the default counted once: what "N models" means everywhere a person reads it. */
+export function modelsOf(b) {
+  return [...new Set([clean(b?.defaultModel), ...(Array.isArray(b?.models) ? b.models.map(clean) : [])].filter(Boolean))];
+}
+
+/**
+ * The line /save-settings prints. REPORTED: "4 providers, 0 models" for four providers that each
+ * had a model — the count read only the EXTRA models and never the default one.
+ */
+export function transferSummary(doc) {
+  const n = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+  const backends = Array.isArray(doc?.codingBackends) ? doc.codingBackends : [];
+  const models = backends.reduce((sum, b) => sum + modelsOf(b).length, 0);
+  const parts = [n(backends.length, "provider"), n(models, "model"), n(Array.isArray(doc?.keys) ? doc.keys.length : 0, "key name")];
+  if (doc?.agentModel?.name || doc?.agentModel?.url) parts.push("the agent model");
+  if (doc?.embedModel?.name || doc?.embedModel?.url) parts.push("the embedding model");
+  return `${parts.join(", ")} — no secrets.`;
+}
+
+/**
+ * A server's models within MAX_MODELS_PER_SERVER (task #245) — the API refuses a row that grows
+ * past it, and a file saved before the cap may hold more. The default stays; extras are kept in
+ * order up to the cap, or up to what this account's row ALREADY holds (a row stored before the cap
+ * keeps what it has). Returns { defaultModel, models, dropped }.
+ */
+export function capServerModels(b, keepAtLeast = 0) {
+  const all = modelsOf(b);
+  const defaultModel = clean(b?.defaultModel) || "";
+  const limit = Math.max(MAX_MODELS_PER_SERVER, keepAtLeast);
+  const kept = all.slice(0, limit);
+  return {
+    defaultModel,
+    models: kept.filter((m) => m !== defaultModel),
+    dropped: all.slice(limit),
+  };
+}
 const isStr = (v) => typeof v === "string";
 const clean = (v) => (typeof v === "string" ? v.trim() : "");
 
@@ -64,6 +151,9 @@ export function buildTransfer({ settings = {}, keys = [], now = new Date(), host
       name: clean(k.name),
       tail: clean(k.tail),
       ...(urlForRowId.get(k.backendId) ? { backendUrl: urlForRowId.get(k.backendId) } : {}),
+      // Task #245: which key is its server's DEFAULT, so loading makes the same one the default
+      // (otherwise it would be whichever key happened to be added first).
+      ...(k.default === true ? { default: true } : {}),
     }));
   return {
     gu: "settings",
@@ -74,6 +164,8 @@ export function buildTransfer({ settings = {}, keys = [], now = new Date(), host
     ...(host ? { savedOn: host } : {}),
     codingBackends: backends,
     agentModel: { url: clean(settings.agentModelUrl), name: clean(settings.agentModelName) },
+    // Task #245: the third role. Its KEY travels like the others — by name, bound to its server.
+    embedModel: { url: clean(settings.ragEmbedUrl), name: clean(settings.ragEmbedModel) },
     keys: keyList,
   };
 }
@@ -150,6 +242,16 @@ export function validateTransfer(text) {
   if (am?.name !== undefined && !isStr(am.name)) {
     return { ok: false, problem: "agentModel.name must be text." };
   }
+  const em = doc.embedModel;
+  if (em !== undefined && (!em || typeof em !== "object" || Array.isArray(em))) {
+    return { ok: false, problem: "embedModel must be an object with a url and a name." };
+  }
+  if (em?.url !== undefined && em.url !== "" && !isHttpUrl(em.url)) {
+    return { ok: false, problem: `embedModel.url is not http(s): ${JSON.stringify(em.url)}.` };
+  }
+  if (em?.name !== undefined && !isStr(em.name)) {
+    return { ok: false, problem: "embedModel.name must be text." };
+  }
   if (doc.keys !== undefined && !Array.isArray(doc.keys)) {
     return { ok: false, problem: "keys must be a list." };
   }
@@ -159,6 +261,9 @@ export function validateTransfer(text) {
     if (!k || typeof k !== "object" || Array.isArray(k)) return { ok: false, problem: `${at} is not an object.` };
     if (!clean(k.name)) return { ok: false, problem: `${at} has no name — a key is identified by its name.` };
     if (k.key !== undefined && !isStr(k.key)) return { ok: false, problem: `${at}.key must be text.` };
+    if (k.default !== undefined && typeof k.default !== "boolean") {
+      return { ok: false, problem: `${at}.default must be true or false.` };
+    }
     if (k.backendUrl !== undefined && k.backendUrl !== "" && !isHttpUrl(k.backendUrl)) {
       return { ok: false, problem: `${at}.backendUrl is not http(s): ${JSON.stringify(k.backendUrl)}.` };
     }
@@ -166,13 +271,21 @@ export function validateTransfer(text) {
       name: clean(k.name),
       tail: clean(k.tail),
       ...(clean(k.backendUrl) ? { backendUrl: clean(k.backendUrl) } : {}),
+      ...(k.default === true ? { default: true } : {}),
       // Present only when a person put it there by hand; gu never writes one.
       ...(clean(k.key) ? { key: clean(k.key) } : {}),
     });
   }
   return {
     ok: true,
-    value: { backends, agentModel: { url: clean(am?.url), name: clean(am?.name) }, keys, savedAt: clean(doc.savedAt), savedOn: clean(doc.savedOn) },
+    value: {
+      backends,
+      agentModel: { url: clean(am?.url), name: clean(am?.name) },
+      embedModel: { url: clean(em?.url), name: clean(em?.name) },
+      keys,
+      savedAt: clean(doc.savedAt),
+      savedOn: clean(doc.savedOn),
+    },
     // Loading a file someone hand-edited to carry live credentials is allowed, but it is not
     // allowed to be quiet: that file is now a secret on disk.
     carriesSecrets: keys.some((k) => k.key),
@@ -190,8 +303,19 @@ export function validateTransfer(text) {
 export function planLoad(file, current = {}) {
   const currentRows = Array.isArray(current.agentCodingBackends) ? current.agentCodingBackends : [];
   const currentKeys = Array.isArray(current.keys) ? current.keys : [];
-  const have = new Set(currentKeys.map((k) => clean(k.name).toLowerCase()).filter(Boolean));
-  const missingKeys = file.keys.filter((k) => !have.has(k.name.toLowerCase()) && !k.key);
+  // A KEY BELONGS TO ITS SERVER (task #245): "work" on api.openai.com says nothing about a "work"
+  // key for ollama.com. So a same-named key counts as present when it is ON THE SAME SERVER, or
+  // tied to NO server (a pre-#245 key — the resolver still falls back to it, so asking for it
+  // again would be asking for a key the account already uses). The same name on ANOTHER server
+  // is a different key.
+  const urlOfRow = (id) => clean(currentRows.find((r) => r?.id === id)?.url);
+  const present = (k) =>
+    currentKeys.some((c) => {
+      if (clean(c.name).toLowerCase() !== k.name.toLowerCase()) return false;
+      if (!c.backendId) return true;
+      return Boolean(k.backendUrl) && sameServerUrl(urlOfRow(c.backendId), k.backendUrl);
+    });
+  const missingKeys = file.keys.filter((k) => !k.key && !present(k));
   const lines = [];
   lines.push(
     file.backends.length
@@ -199,12 +323,25 @@ export function planLoad(file, current = {}) {
       : "no coding providers in the file — the ones on this account stay as they are.",
   );
   for (const b of file.backends) {
-    const models = b.models.length ? `${b.models.length} model${b.models.length === 1 ? "" : "s"}` : "no models";
+    const n = modelsOf(b).length;
+    const models = n ? `${n} model${n === 1 ? "" : "s"}` : "no models";
     lines.push(`  ${b.kind || "?"}  ${b.url || "(no url)"}  ${models}${b.defaultModel ? `, default ${b.defaultModel}` : ""}${b.enabled ? "" : "  (disabled)"}`);
+    const mine = currentRows.find((r) => sameServerUrl(r?.url, b.url));
+    const capped = capServerModels(b, mine ? modelsOf(mine).length : 0);
+    if (capped.dropped.length) {
+      lines.push(`    a server offers at most ${MAX_MODELS_PER_SERVER} models — not loading ${capped.dropped.join(", ")}`);
+    }
   }
   if (file.agentModel.url || file.agentModel.name) {
     lines.push(`agent model: ${file.agentModel.name || "(server default)"}${file.agentModel.url ? ` at ${file.agentModel.url}` : ""}`);
   }
+  if (file.embedModel?.url || file.embedModel?.name) {
+    const same = sameServerUrl(file.embedModel.url, current.ragEmbedUrl) && file.embedModel.name === clean(current.ragEmbedModel);
+    lines.push(`embedding model: ${file.embedModel.name || "(unchanged)"}${file.embedModel.url ? ` at ${file.embedModel.url}` : ""}${same ? "  (already set)" : ""}`);
+    if (!same && file.embedModel.name && file.embedModel.name !== clean(current.ragEmbedModel)) {
+      lines.push("  a different embedder: every knowledge base rebuilds on its next search.");
+    }
+  }
   if (missingKeys.length) {
     lines.push(`${missingKeys.length} API key${missingKeys.length === 1 ? "" : "s"} this account does not have — gu will ask for ${missingKeys.length === 1 ? "it" : "them"} after:`);
     for (const k of missingKeys) lines.push(`  ${k.name}${k.tail ? ` (…${k.tail})` : ""}${k.backendUrl ? ` for ${k.backendUrl}` : ""}`);
@@ -230,24 +367,30 @@ export function planLoad(file, current = {}) {
 export function toSettingsPatch(file, current = {}) {
   const patch = {};
   const existing = Array.isArray(current.agentCodingBackends) ? current.agentCodingBackends : [];
-  const idFor = (kind, url) =>
-    existing.find(
-      (r) => r?.id && r.kind === kind && clean(r.url).toLowerCase() === clean(url).toLowerCase(),
-    )?.id ?? "";
+  // Matched as ONE SERVER however it is spelled (task #245) — "https://ollama.com" and
+  // "https://ollama.com/v1" are the same row, and a raw compare would mint a twin and strand the
+  // keys bound to the original.
+  const mineFor = (kind, url) => existing.find((r) => r?.id && r.kind === kind && sameServerUrl(r.url, url));
   if (file.backends.length) {
     patch.agentCodingBackends = file.backends.map((b) => {
-      const id = idFor(b.kind, b.url);
+      const mine = mineFor(b.kind, b.url);
+      const capped = capServerModels(b, mine ? modelsOf(mine).length : 0);
       return {
-        ...(id ? { id } : {}),
+        ...(mine?.id ? { id: mine.id } : {}),
         kind: b.kind,
         url: b.url,
-        defaultModel: b.defaultModel,
-        models: b.models,
+        defaultModel: capped.defaultModel,
+        models: capped.models,
         enabled: b.enabled,
       };
     });
   }
   if (file.agentModel.url) patch.agentModelUrl = file.agentModel.url;
   if (file.agentModel.name) patch.agentModelName = file.agentModel.name;
+  if (file.embedModel?.url) patch.ragEmbedUrl = file.embedModel.url;
+  if (file.embedModel?.name) patch.ragEmbedModel = file.embedModel.name;
+  // The embedder's key is resolved through its server's keys (task #245); the pre-#245
+  // account-wide pick would only shadow them.
+  if (file.embedModel?.url || file.embedModel?.name) patch.ragEmbedKeyId = "";
   return patch;
 }

package/terminal-layout.mjs

@@ -1715,6 +1715,46 @@ export function describeInstallFailure({ status = 0, stderr = "", error = null }
   return `npm exited ${status}${why ? ` — ${_clipReason(why)}` : ""}`;
 }
 
+/**
+ * The command the in-app update RUNS — one string, run through a shell.
+ *
+ * ONE STRING, NOT AN ARGS ARRAY. A shell is needed (Windows finds npm as npm.cmd only through
+ * one), and Node 24 warns DEP0190 whenever args are passed WITH `shell: true` — they are joined,
+ * not escaped — and that warning landed in the middle of the transcript on every update.
+ *
+ * --prefer-online: npm REVALIDATES its cached package document instead of trusting it. The update
+ * check reads registry.npmjs.org/<pkg>/latest, which knows a new version the moment it is
+ * published; `npm install` reads the full document from npm's own cache and CDN, which catch up
+ * minutes later. Without this, a version announced seconds after publishing failed with ETARGET.
+ */
+export const CLI_UPDATE_SHELL_COMMAND = `${CLI_INSTALL_COMMAND} --prefer-online`;
+
+/**
+ * Did the install fail only because npm has not caught up with a JUST-published version?
+ * (ETARGET / notarget — "No matching version found".) Worth one retry after a short wait, and
+ * worth saying plainly rather than as a raw npm error: nothing is wrong with the release.
+ */
+export function isFreshPublishMiss({ status = 0, stderr = "" } = {}) {
+  if (status === 0) return false;
+  return /\b(ETARGET|notarget)\b|No matching version found/i.test(String(stderr ?? ""));
+}
+
+/** What to say when npm still has not caught up after the retry. */
+export function freshPublishNote(version = "") {
+  return `gu ${version || "the new version"} was published moments ago and npm's mirrors are still catching up — ` +
+    "try the update again in a few minutes.";
+}
+
+/**
+ * The local modules a source text imports LAZILY (a dynamic import of "./name.mjs"), minus the CLI entry
+ * (importing gu-cli.mjs RUNS the CLI). gu-repl preloads these at startup so an in-app update that
+ * replaces the package on disk can never be read into the still-running old process.
+ */
+export function lazyModuleNames(text) {
+  return [...new Set([...String(text ?? "").matchAll(/import\("\.\/([\w.-]+\.mjs)"\)/g)].map((m) => m[1]))]
+    .filter((m) => m !== "gu-cli.mjs");
+}
+
 /** One line, bounded — a reason is for reading, and npm's can carry a whole stack frame. */
 function _clipReason(s, max = 160) {
   const one = String(s).replace(/\s+/g, " ").trim();

package/ollama-host-snippets.mjs

@@ -1,36 +0,0 @@
-/**
- * "Is that an Ollama SERVER?" — the input check behind /embed-model's server prompt (task #169).
- *
- * WHY A SEPARATE FILE OF ONE FUNCTION. The embed picker asks for a URL and its retry line is
- * `"<typed>" is <why> — try host:port, e.g. 127.0.0.1:11434`, so the reason HAS to be a phrase
- * that finishes that sentence. Keeping the check next to its words is what stops a future edit
- * from returning a full sentence and printing "is The URL must not...".
- *
- * WHAT "OLLAMA-SHAPED" MEANS HERE. The python worker takes the saved root and appends
- * /v1/embeddings, then /api/embed, then /api/embeddings itself (gonext_agent_chat._embed).
- * Anything already carrying a path (/v1, /api/tags, someone pasting a dashboard link) would be
- * saved as-is and every suffix would 404 — so a path is a reason to ask AGAIN, not to strip
- * silently. Stripping hides the mistake; the retry teaches the shape.
- *
- * The vocabulary mirrors agent-model-command.ollamaAgentUrl ("not a URL", "not http(s)",
- * "no host") so the agent and embed prompts read the same when they fail the same way.
- *
- * Returns { ok: true } or { ok: false, why }.
- */
-export function checkOllamaHostInput(url) {
-  const v = String(url ?? "").trim();
-  if (!v) return { ok: false, why: "empty" };
-  let u;
-  try {
-    u = new URL(v);
-  } catch {
-    return { ok: false, why: "not a URL" };
-  }
-  if (u.protocol !== "http:" && u.protocol !== "https:") return { ok: false, why: "not http(s)" };
-  if (!u.hostname) return { ok: false, why: "no host" };
-  if (u.username || u.password) return { ok: false, why: "carrying credentials — keys go in the key prompt" };
-  const path = u.pathname.replace(/\/+$/, "");
-  if (path) return { ok: false, why: `carrying "${path}" — I need just the server root` };
-  if (u.search || u.hash) return { ok: false, why: "carrying a query — I need just the server root" };
-  return { ok: true };
-}