@tiens.nguyen/gu-cli 1.0.721 → 1.0.722

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.721",
+  "version": "1.0.722",
   "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/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 };
-}