@tiens.nguyen/gu-cli 1.0.768 → 1.0.770

package/agent-stop.mjs

@@ -41,11 +41,28 @@ export const STOP_GRACE_MS = 3000;
  * Stop a child process: SIGTERM now, SIGKILL after `graceMs` unless it has exited.
  * → a function that cancels the pending SIGKILL (call it from the child's `close`).
  */
-export function stopGracefully(child, { graceMs = STOP_GRACE_MS, setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
-  try {
-    child.kill("SIGTERM");
-  } catch {
-    /* already gone */
+export function stopGracefully(child, {
+  graceMs = STOP_GRACE_MS,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  platform = process.platform,
+  // WINDOWS HAS NO SIGTERM (task #302): child.kill("SIGTERM") there IS TerminateProcess, which no
+  // handler sees — so a stop could land in the middle of the agent writing a file. There, ask
+  // first (the agent watches GONEXT_STOP_FILE and stops at a safe point) and kill after the grace.
+  requestStop = null,
+} = {}) {
+  if (platform === "win32" && typeof requestStop === "function") {
+    try {
+      requestStop();
+    } catch {
+      /* could not ask — the kill after the grace still stops it */
+    }
+  } else {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      /* already gone */
+    }
   }
   const t = setTimer(() => {
     if (child.exitCode === null && child.signalCode === null) {

package/client-expert-api.mjs

@@ -516,6 +516,23 @@ export const CLIENT_EXPERT_MODELS = {
  * is written — while Kimi is registered as "openai" so `/model` lists it and asks for the key
  * only if the user actually switches. One slot per kind, so these cannot collide.
  */
+/** The row setup writes for an agent server that differs from the coder's and has a key (#301). */
+export const AGENT_ROW_ID = "ollama-agent";
+/** The implicit id of the coder's row — setup writes it without one; the API names it by kind. */
+export const CODER_ROW_ID = "ollama";
+
+/**
+ * Which row a key typed at setup binds to (#301): the coder's row for the coder's server (or for
+ * the agent's when they share one), the agent row otherwise. "" when neither server was used.
+ */
+export function rowIdForKey(models, url) {
+  const M = models ?? {};
+  const codeUrl = M.codeUrl || M.url;
+  if (url && url === codeUrl) return CODER_ROW_ID;
+  if (url && url === M.url) return AGENT_ROW_ID;
+  return "";
+}
+
 export function codingBackendsForClientExpert(models = CLIENT_EXPERT_MODELS) {
   const M = models ?? CLIENT_EXPERT_MODELS;
   // The chat model is offered too, so `/model` can drop to the fast one for simple work, plus
@@ -525,17 +542,33 @@ export function codingBackendsForClientExpert(models = CLIENT_EXPERT_MODELS) {
   // SHARED_ALT_CODE_MODEL is the seeded default for the shared box. Deduped and stripped of the
   // primary coder, because a `/model` list that offers the model you are already on — twice —
   // is a list nobody trusts.
-  const offered = [M.chat, ...(M.altCoders ?? [SHARED_ALT_CODE_MODEL])].filter(
+  //
+  // THE CODER'S OWN SERVER (#301). Setup has asked "Coding-model server" separately since #220 and
+  // returned it as codeUrl, but this row was always built on M.url — the AGENT's server — so a
+  // coder chosen on a second box was silently configured on the first. The agent model is offered
+  // on the coder's row only when it lives on that same server; elsewhere it is not there to offer.
+  const codeUrl = M.codeUrl || M.url;
+  const sameServer = codeUrl === M.url;
+  const offered = [...(sameServer ? [M.chat] : []), ...(M.altCoders ?? [SHARED_ALT_CODE_MODEL])].filter(
     (name, i, all) => name && name !== M.code && all.indexOf(name) === i,
   );
+  // AN AGENT SERVER WITH A KEY NEEDS A ROW OF ITS OWN (#301). The API finds the agent's (and the
+  // embedder's) key by matching agentModelUrl to a row's URL — no row, no key. Only when the key
+  // exists: a keyless agent box needs no row, and one would add a server to /model for nothing.
+  // Explicit id, because two id-less ollama rows would both claim the implicit id "ollama".
+  const agentKeyed =
+    !sameServer && Array.isArray(M.keys) && M.keys.some((k) => k?.url === M.url && k?.key);
   return [
     {
       kind: "ollama",
       enabled: true,
-      url: M.url,
+      url: codeUrl,
       defaultModel: M.code,
       models: offered,
     },
+    ...(agentKeyed
+      ? [{ id: AGENT_ROW_ID, kind: "ollama", enabled: true, url: M.url, defaultModel: M.chat, models: [] }]
+      : []),
     {
       kind: "openai",
       enabled: true,
@@ -627,8 +660,14 @@ export function backfillCodingModels(existing = {}) {
  * model names to a list that already exists; see its docstring for why that is not "overwriting
  * a model the user has since chosen".
  */
-export function settingsPatch({ existing = {}, models = CLIENT_EXPERT_MODELS } = {}) {
+export function settingsPatch({ existing = {}, models = CLIENT_EXPERT_MODELS, skipModels = false } = {}) {
   const patch = {};
+  // #301: "Skip for now" (or Esc) at setup — NO model field is written: not the shared box, not a
+  // half. The bar then says what is unset and /model sets it. Only the non-model defaults below.
+  if (skipModels) {
+    if (typeof existing.agentSaveFullResponse !== "boolean") patch.agentSaveFullResponse = true;
+    return patch;
+  }
   // `models` is either the seeded shared-Ollama defaults (nobody was asked) or the box the user
   // chose at setup (task #220). Everything below is written in terms of M, so the two paths
   // cannot drift into configuring different fields.
@@ -638,7 +677,10 @@ export function settingsPatch({ existing = {}, models = CLIENT_EXPERT_MODELS } =
     Boolean(existing.agentModelUrl?.trim()) ||
     Boolean(existing.agentModel?.trim()) ||
     Boolean(existing.agentModelName?.trim());
-  if (!hasAgent) {
+  // A ROLE SKIPPED AT SETUP IS LEFT UNSET, not half-written (#301): an agent URL with no model
+  // name is the "default_model" sentinel on the wire, and a coder row with an empty model is a coder
+  // that answers nothing. Only the roles that were actually chosen are written.
+  if (!hasAgent && M.chat) {
     patch.agentModelUrl = M.url;
     const name = M.chat;
     // agentModelNAME is the field that matters. With a direct agent URL the API reads
@@ -664,17 +706,17 @@ export function settingsPatch({ existing = {}, models = CLIENT_EXPERT_MODELS } =
     (Array.isArray(existing.agentCodingBackends) && existing.agentCodingBackends.length > 0) ||
     Boolean(existing.agentCodingModelUrl?.trim()) ||
     Boolean(existing.agentCodingModelName?.trim());
-  if (!hasCoder) {
+  if (!hasCoder && M.code) {
     patch.agentCodingBackends = codingBackendsForClientExpert(M);
     patch.agentCodingDefaultKind = "ollama";
     // Legacy mirror, so an older worker resolves the same coder.
     patch.agentCodingModelKind = "ollama";
-    patch.agentCodingModelUrl = M.url;
+    patch.agentCodingModelUrl = M.codeUrl || M.url;
     patch.agentCodingModelName = M.code;
     // NO api key is stored. The default coder is kind "ollama", which the API does not require
     // one for — and a placeholder here would be SENT to Kimi the moment someone switched with
     // `/model`, failing at the provider with an auth error nobody expected.
-  } else {
+  } else if (hasCoder) {
     // Already configured — so the seed above will never run again on this machine. Add any
     // newly-offered shared-Ollama models to the list it was seeded with, without changing which
     // coder it uses. See backfillCodingModels.
@@ -752,6 +794,8 @@ export async function seedSettings({
   // question was skipped or declined. Passed straight to settingsPatch so there is exactly one
   // place that decides what a Client Expert machine is configured with.
   models = CLIENT_EXPERT_MODELS,
+  // #301: the model questions were skipped — write no model field at all.
+  skipModels = false,
 } = {}) {
   const { MongoClient } = loadMongoDriver(apiDir);
   const client = new MongoClient(mongoUri, { serverSelectionTimeoutMS: 8000 });
@@ -759,7 +803,7 @@ export async function seedSettings({
   try {
     const col = client.db(dbName).collection("settings");
     const existing = (await col.findOne({ userId })) ?? {};
-    const patch = settingsPatch({ existing, models });
+    const patch = settingsPatch({ existing, models, skipModels });
     if (Object.keys(patch).length > 0) {
       await col.updateOne(
         { userId },
@@ -773,6 +817,43 @@ export async function seedSettings({
   }
 }
 
+/**
+ * Save the API keys typed at setup (#301), each bound to its server's row, through the local API
+ * — the same POST /coding-keys the terminal uses, so the first key for a server becomes its
+ * default by the API's own rule (#245) rather than by anything written here. Runs AFTER
+ * seedSettings: the API refuses a key for a row that does not exist yet.
+ *
+ * Returns [{ host, ok }]. Never throws and never prints the key: a key that failed to save is
+ * reported by host, and can be added again with ctrl+k in /model.
+ */
+export async function saveSetupKeys({ apiBase = LOCAL_API_BASE, workerKey, models, fetchImpl = fetch } = {}) {
+  const out = [];
+  for (const { url, key } of Array.isArray(models?.keys) ? models.keys : []) {
+    let host = url;
+    try {
+      host = new URL(url).host;
+    } catch {
+      /* keep the url */
+    }
+    const backendId = rowIdForKey(models, url);
+    if (!key || !backendId) continue;
+    let ok = false;
+    try {
+      const r = await fetchImpl(`${apiBase}/api/worker/coding-keys`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+        body: JSON.stringify({ name: host, apiKey: key, backendId }),
+        signal: AbortSignal.timeout(10000),
+      });
+      ok = r.ok;
+    } catch {
+      ok = false;
+    }
+    out.push({ host, ok });
+  }
+  return out;
+}
+
 /**
  * THE NEW OLLAMA SERVER'S ROWS, MERGED INTO WHAT IS ALREADY THERE — never replacing it (#43).
  *

package/client-expert-run.mjs

@@ -29,6 +29,7 @@ import {
   probeLocalApi,
   writeWorkerEnv,
   seedSettings,
+  saveSetupKeys,
   modelsAlreadyConfigured,
   CLIENT_EXPERT_MODELS,
   LOCAL_API_PORT,
@@ -37,6 +38,9 @@ import {
   LOCAL_MONGO_URI,
 } from "./client-expert-api.mjs";
 import { askOllamaSetup, localOllamaDefault } from "./ollama-setup.mjs";
+import { SKIP_ALL, createHinter, modelSetupMenu, parseModelSetupChoice } from "./model-setup-ui.mjs";
+import { presetFilesIn } from "./presets-transfer.mjs";
+import { readdirSync, statSync, readFileSync } from "node:fs";
 import { parseOllamaTags, formatSize } from "./agent-model-command.mjs";
 import {
   planSetup,
@@ -66,15 +70,46 @@ class SkipModelQuestion extends Error {}
  * (this returns []), and those two get different messages because they need different fixes.
  * A short timeout, because a box that has not answered in eight seconds is not going to.
  */
-async function fetchOllamaTags(url) {
-  const res = await fetch(url, { signal: AbortSignal.timeout(8000) });
-  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+async function fetchOllamaTags(url, { apiKey = "" } = {}) {
+  const res = await fetch(url, {
+    signal: AbortSignal.timeout(8000),
+    // #301: a key typed for this server. Absent → the request is exactly what it always was.
+    ...(apiKey ? { headers: { Authorization: `Bearer ${apiKey}` } } : {}),
+  });
+  if (!res.ok) {
+    // The status travels with the error: 401/403 is "needs a key", which the caller asks for.
+    const err = new Error(`HTTP ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
   // parseOllamaTags is tolerant by design — HTML from a proxy, an empty body and a shape from a
   // future Ollama all become []. That is "reachable but not usable", which the caller reports as
   // such rather than as a network failure.
   return parseOllamaTags(await res.json().catch(() => null));
 }
 
+/** How many /save-preset files are in the home folder — the up-front question names the count. */
+function countSavedPresets() {
+  try {
+    const home = homedir();
+    const entries = [];
+    for (const name of readdirSync(home)) {
+      if (!name.toLowerCase().endsWith(".json")) continue;
+      const file = join(home, name);
+      try {
+        const st = statSync(file);
+        if (!st.isFile() || st.size > 64 * 1024) continue; // a preset is tiny; never slurp a big file
+        entries.push({ name, text: readFileSync(file, "utf8"), mtimeMs: st.mtimeMs });
+      } catch {
+        /* unreadable — not a preset we can offer */
+      }
+    }
+    return presetFilesIn(entries).length;
+  } catch {
+    return 0;
+  }
+}
+
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 // The brand accent, shared with the REPL — see accent.mjs.
@@ -339,7 +374,7 @@ export async function checkMongoConnection(uri) {
  * Returns { uri, custom } to continue with, or { exit: true } when the user declines — the
  * caller ends setup with the `gu clear` → `gu` hint.
  */
-export async function askMongoCredentials(ask) {
+export async function askMongoCredentials(ask, askSecret = null) {
   const { host, port } = mongoHostPort(LOCAL_MONGO_URI);
   console.log(dim(`  MongoDB is answering at ${host}:${port}.`));
   console.log(dim("  If that is a MongoDB this machine already had, it may have its OWN"));
@@ -352,7 +387,12 @@ export async function askMongoCredentials(ask) {
   // continues: a typo found here costs ten seconds; found at the seed step it costs the run.
   for (let attempt = 0; attempt < 3; attempt += 1) {
     const username = String(await ask("  MongoDB username: ") ?? "").trim();
-    const password = String(await ask("  MongoDB password: ") ?? "");
+    // MASKED when a masked reader is available (#300): a password typed in the clear stays in the
+    // scrollback, and in anything copied from it.
+    const rawPw = typeof askSecret === "function"
+      ? await askSecret("  MongoDB password: ")
+      : await ask("  MongoDB password: ");
+    const password = rawPw === SKIP_ALL ? "" : String(rawPw ?? "");
     const uri = buildMongoUri({ username, password, host, port });
     process.stdout.write(dim("  checking the connection…"));
     const verdict = await checkMongoConnection(uri);
@@ -589,7 +629,14 @@ export function markInterruptedOnExit(getState, stepId) {
   };
 }
 
-export async function runClientExpertSetup({ ask }) {
+export async function runClientExpertSetup({
+  ask,
+  // #301/#300: a MASKED line reader (API keys, the MongoDB password). Absent → no key is asked.
+  askSecret = null,
+  // #301: an Esc-aware reader for the model questions — Esc resolves it with SKIP_ALL. Only the
+  // model questions use it: Esc elsewhere (the MongoDB questions) must not mean "skip models".
+  askStep = ask,
+}) {
   const machine = await probeMachine();
   const gate = clientExpertAvailable({ workerEnvExists: false, ...machine });
   if (!gate.available) {
@@ -707,7 +754,7 @@ export async function runClientExpertSetup({ ask }) {
       console.log(dim("  using the MongoDB credentials from the previous run"));
     }
   } else if (!process.env.GONEXT_LOCAL_MONGO_URI) {
-    const credsChoice = await askMongoCredentials(ask);
+    const credsChoice = await askMongoCredentials(ask, askSecret);
     if (credsChoice.exit) {
       console.log("\n  " + dim("No working MongoDB credentials — setup stops here."));
       console.log(dim("  To start over: `gu clear`, then `gu` again.\n"));
@@ -902,6 +949,27 @@ export async function runClientExpertSetup({ ask }) {
       console.log(dim("  server this machine uses."));
       throw new SkipModelQuestion();
     }
+    // ASK ONCE, UP FRONT (#301): guided / load a preset / skip. Enter = guided, so today's flow is
+    // unchanged for anyone who just presses Enter; the other two are one digit away instead of an
+    // escape hunt through four questions.
+    const presets = countSavedPresets();
+    console.log("");
+    const [title, ...rows] = modelSetupMenu({ presets });
+    console.log("  " + bold(title));
+    for (const r of rows) console.log(dim("  " + r));
+    let path = null;
+    for (let t = 0; t < 3 && !path; t++) {
+      path = parseModelSetupChoice(await askStep("  choose [1]: "));
+      if (path === "preset" && presets === 0) {
+        console.log(dim("  No presets saved yet. Save one later with /save-preset — pick 1 or 3 for now."));
+        path = null;
+      }
+    }
+    path = path ?? "guided";
+    if (path !== "guided") {
+      chosenModels = { skipped: true, keys: [], loadPreset: path === "preset" };
+      throw new SkipModelQuestion();
+    }
     console.log("");
     console.log("  " + bold("Which Ollama server should this machine use?"));
     // THIS MACHINE FIRST, when it has one. Client Expert is the mode whose whole promise is
@@ -923,10 +991,12 @@ export async function runClientExpertSetup({ ask }) {
       ),
     );
     console.log(dim("    ollama.local, http://box:11434 — and pick from what it actually has."));
-    chosenModels = await askOllamaSetup(ask, {
+    chosenModels = await askOllamaSetup(askStep, {
       defaultUrl,
       fetchTags: fetchOllamaTags,
       formatSize,
+      askSecret,
+      hint: createHinter(),
       // THE SHIPPED DEFAULT WINS WHEN THE BOX HAS IT. Without this a fresh machine falls back to
       // a size heuristic, and on a box with several similar builds that picks by size alone —
       // observed on ollama2, where gemma4-quadro:latest and gemma4-quadro-49k:latest are
@@ -939,18 +1009,38 @@ export async function runClientExpertSetup({ ask }) {
     // The skip is not a failure and says nothing extra; it has already printed its own line.
     if (!(e instanceof SkipModelQuestion)) {
       console.log(dim(`  (could not ask: ${e.message} — using the shared Ollama)`));
+      chosenModels = null;
     }
-    chosenModels = null;
+    // A SkipModelQuestion keeps whatever it set: undefined (already configured) or the skip.
+    chosenModels = chosenModels ?? null;
   }
+  // #301: skipped on purpose (up front, "s" at both servers, or Esc) → no model field is written.
+  const skipModels = Boolean(chosenModels?.skipped);
+  const loadPreset = Boolean(chosenModels?.loadPreset);
 
   try {
     const written = await seedSettings({
       apiDir,
       mongoUri,
       userId: creds.userId,
-      ...(chosenModels ? { models: chosenModels } : {}),
+      ...(chosenModels && !skipModels ? { models: chosenModels } : {}),
+      skipModels,
     });
-    if (Object.keys(written).length === 0) {
+    // #301: the keys typed for the servers, saved through the API now that their rows exist.
+    // Reported by host, never by value.
+    if (!skipModels && chosenModels?.keys?.length) {
+      for (const r of await saveSetupKeys({ workerKey: creds.workerKey, models: chosenModels })) {
+        console.log(r.ok
+          ? "  " + cyan("✓ API key stored") + dim(` for ${r.host} — the server's default key`)
+          : "  " + yellow("⚠ could not store the key") + dim(` for ${r.host} — add it in /model with ctrl+k`));
+      }
+    }
+    if (skipModels) {
+      console.log("");
+      console.log("  " + cyan("✓ Model setup skipped") + dim(loadPreset
+        ? " — the preset picker opens as soon as gu starts"
+        : " — set them any time with /model (or /load-presets)"));
+    } else if (Object.keys(written).length === 0) {
       console.log("  " + cyan("✓ Models and RAG") + dim(" — already configured, left alone"));
     } else {
       console.log(
@@ -997,5 +1087,7 @@ export async function runClientExpertSetup({ ask }) {
     dim("\n  machine. The API restarts with `gu-cli api start`; its log is") +
     dim(`\n  ${API_LOG_FILE}\n`)
   );
-  return { complete: true, stoppedAt: null };
+  // #301: the caller opens /load-presets once the terminal exists — the picker, the plan and the
+  // confirmation are that command's, not rebuilt here.
+  return { complete: true, stoppedAt: null, ...(loadPreset ? { loadPreset: true } : {}) };
 }