@tiens.nguyen/gu-cli 1.0.761 → 1.0.763

package/client-expert-setup.mjs

@@ -614,3 +614,41 @@ export function shouldAskMode({ chosenMode, isTty, expertAvailable }) {
   if (!isTty) return false; // a pipe or CI has nobody to answer
   return Boolean(expertAvailable);
 }
+
+/**
+ * `--license <pro token>` — the flag that unlocks the first-run MODE MENU.
+ *
+ * The menu ("how should this machine run?" — hosted client / MLX host / private) used to be
+ * shown to every first install. It is now a pro feature: a bare `gu` goes PRIVATE by default
+ * (Client Expert — the whole stack on this machine, nothing shared), and the only way to be
+ * offered the hosted modes is to start with a license token. The token itself is NOT validated
+ * here and NOT stored — it only gates which question gets asked, this run. Returns the trimmed
+ * token, or "" when absent.
+ */
+export function parseLicenseFlag(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  for (let i = 0; i < args.length; i += 1) {
+    const a = String(args[i] ?? "");
+    if (a === "--license") return String(args[i + 1] ?? "").trim();
+    if (a.startsWith("--license=")) return a.slice("--license=".length).trim();
+  }
+  return "";
+}
+
+/**
+ * What a first run DOES about the mode question.
+ *
+ *   · WITH a license token → ask: the three-mode menu, exactly as before.
+ *   · WITHOUT one          → a silent default: "client-expert" (private) when this machine can
+ *                            run it, otherwise "client" (cloud works everywhere).
+ *
+ * The default lands on the mode that KEEPS DATA ON THE MACHINE on purpose: choosing hosted
+ * storage for someone is a privacy decision they have to make themselves — which is exactly
+ * what the license-gated menu is for. Pure, so the rule is a test row rather than something to
+ * re-read in the REPL.
+ */
+export function resolveFirstRunMode({ licenseToken, expertAvailable } = {}) {
+  if (String(licenseToken ?? "").trim()) return { ask: true, mode: null };
+  if (expertAvailable) return { ask: false, mode: "client-expert" };
+  return { ask: false, mode: "client" };
+}

package/gu-repl.mjs

@@ -569,13 +569,16 @@ if (cliVerdict.kind === "run") {
 } else if (argv.includes("--help") || argv.includes("-h")) {
   console.log(
     "gu — terminal agent REPL for the current folder\n\n" +
-      "Usage: gu [-v|--verbose]\n" +
+      "Usage: gu [-v|--verbose] [--license <pro token>]\n" +
       "       gu status                 # worker + a table of the running model servers\n" +
       "       gu start|stop|restart|logs # manage the background worker\n" +
       "       gu logs <port|pid> [-f]   # tail a running model server's log\n" +
       "       gu doctor|login|set        # models / account (same as `gu-cli …`)\n" +
       "       gu rag                    # is RAG working? tests the embedder end-to-end\n\n" +
       "  -v, --verbose   show RAG index-file activity in the bottom bar (each shard written)\n" +
+      "  --license <token>  pro license: a first install ASKS how this machine runs (hosted\n" +
+      "                     client / MLX host / private). Without it, a first install is\n" +
+      "                     private by default — the whole stack on this machine.\n" +
       "  -h, --help      this help\n\n" +
       "Auth comes from ~/.gonext/worker.env; models/budgets/RAG come from your web Settings.\n" +
       "Inside the REPL: /exit · /model · /new · /help — Ctrl-C stops following a turn.\n" +
@@ -664,13 +667,41 @@ if (!workerKey || !apiBase) {
         const {
           probeMachine, askMode, runClientExpertSetup, loadState, saveState,
         } = await import("./client-expert-run.mjs");
-        const { clientExpertAvailable } = await import("./client-expert-setup.mjs");
+        const { clientExpertAvailable, parseLicenseFlag, resolveFirstRunMode } =
+          await import("./client-expert-setup.mjs");
         const machine0 = await probeMachine();
         const gate0 = clientExpertAvailable({ workerEnvExists: false, ...machine0 });
-        const mode0 = await askMode(ask0, {
+        // THE MENU IS A PRO FEATURE. A bare first install no longer asks "how should this
+        // machine run?" — it goes PRIVATE (Client Expert: the whole stack on this machine,
+        // nothing shared) and walks the MongoDB/API/models setup straight away. The
+        // three-way menu (hosted client / MLX host / private) is shown only when the run
+        // carries a pro license token: `gu --license <token>`.
+        const plan0 = resolveFirstRunMode({
+          licenseToken: parseLicenseFlag(argv),
           expertAvailable: gate0.available,
-          expertWhy: gate0.message,
         });
+        let mode0;
+        if (plan0.ask) {
+          mode0 = await askMode(ask0, {
+            expertAvailable: gate0.available,
+            expertWhy: gate0.message,
+          });
+        } else {
+          mode0 = plan0.mode;
+          if (mode0 === "client-expert") {
+            console.log(
+              dim("\n  Private by default: the whole stack (API, database, models) is set up on") +
+              dim("\n  this machine; nothing it does is shared.")
+            );
+            console.log(
+              dim("  To pick a hosted mode instead, start with a pro license:  gu --license <token>\n")
+            );
+          } else {
+            // Private is the default, but this machine cannot run it — say why ONCE and land
+            // in cloud mode, which works everywhere, rather than installing a broken stack.
+            console.log(dim(`\n  Private mode is not available here — ${gate0.message}`));
+          }
+        }
         // RECORD IT HERE. This branch used to ask and not save, so the later mode question in
         // main() still saw no chosenMode and asked the SAME question a second time in one run —
         // and by then worker.env existed, so its answer list said Client Expert was unavailable.
@@ -813,6 +844,12 @@ const COMMANDS = [
   { name: "/context-window", usage: "/context-window [tokens|auto]", desc: "tell gu how big the coding model's context is — hosted models cannot be probed" },
   { name: "/save-settings", usage: "/save-settings [name|path]", desc: "write this account's providers, models and key NAMES to a file in your home folder (no secrets) — asks for a name, Enter keeps gu-settings.json" },
   { name: "/load-settings", usage: "/load-settings [name|path]", desc: "read that file back on another machine — picks from the settings files in your home folder, asks before it replaces anything" },
+  // PRESETS (#6) are the user's OWN JSON, not a snapshot: /save-preset takes a name AND the
+  // object {apiUrl, apiKey, agentModel, codingModel, embedModel} and validates every field
+  // before writing. A preset file HOLDS its API key (0600, home folder — the settings files'
+  // location), so it is marked "gu": "preset" and the two commands never offer each other's files.
+  { name: "/save-preset", usage: '/save-preset <name> {"apiUrl":"…","apiKey":"…","agentModel":"…","codingModel":"…","embedModel":"…"}', desc: "save a named preset: server, API key and the agent/coding/embedding models, all validated — same home folder as settings files" },
+  { name: "/load-presets", usage: "/load-presets [name]", desc: "pick a saved preset (arrow keys) and put it back — server, both models, embedder and its key; asks before it replaces anything" },
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
   // ONE name, /new (user, #278). /reset and /clear still work (HIDDEN_COMMANDS) for habit and
@@ -6429,6 +6466,142 @@ function settingsArg(line, word) {
   return line.slice(word.length).trim();
 }
 
+/**
+ * /save-preset <name> <json> — the user TYPES the preset (#6): a name and a JSON object with
+ * apiUrl, apiKey, agentModel, codingModel and embedModel, all validated before anything is
+ * written. Unlike /save-settings (which snapshots the account and refuses secrets), a preset
+ * SAVES the API key by design — it is the "this exact setup, one command" file, stored 0600 in
+ * the same home-folder location as settings files, marked "gu": "preset" so the two commands
+ * never offer each other's files.
+ */
+async function runSavePresetCommand(line) {
+  const pr = await import("./presets-transfer.mjs");
+  const home = homedir();
+  console.log("");
+  const usage =
+    'usage: /save-preset <name> {"apiUrl":"https://…","apiKey":"…","agentModel":"…","codingModel":"…","embedModel":"…"}  (embedUrl optional)';
+  const rest = line.trim().slice("/save-preset".length).trim();
+  if (!rest) {
+    console.log(GUTTER + usage);
+    console.log("");
+    return;
+  }
+  const space = rest.search(/\s/);
+  const name = space === -1 ? rest : rest.slice(0, space);
+  const json = space === -1 ? "" : rest.slice(space + 1).trim();
+  if (!pr.isPresetName(name)) {
+    console.log(GUTTER + `"${name}" is not a preset name — one word, no slashes. ` + usage);
+    console.log("");
+    return;
+  }
+  if (!json) {
+    console.log(GUTTER + "the JSON is missing — " + usage);
+    console.log("");
+    return;
+  }
+  const checked = pr.validatePreset(json);
+  if (!checked.ok) {
+    console.log(GUTTER + `Preset not saved — ${checked.problem}`);
+    console.log("");
+    return;
+  }
+  const file = pr.presetFilePath(name, home);
+  writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: checked.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
+  console.log(GUTTER + `Preset "${name}" saved to ${file}`);
+  console.log(GUTTER + dim("server + api key + agent, coding and embedding models — the key is IN this file, keep it private."));
+  console.log("");
+}
+
+/**
+ * /load-presets — list the preset files /save-preset wrote (newest first, the arrow-key picker)
+ * and apply the chosen one: the server + both models land as one coding-backend row, the preset's
+ * key is saved under the preset's name and made that row's default, and the embedder is set. The
+ * user reconfirms before anything changes, like /load-settings.
+ */
+async function runLoadPresetsCommand(line) {
+  const pr = await import("./presets-transfer.mjs");
+  const home = homedir();
+  console.log("");
+  let file = "";
+  const typed = line.trim().slice("/load-presets".length).trim();
+  if (typed) {
+    file = pr.presetFilePath(typed, home);
+    if (!file) return; // a cancel word
+    if (!existsSync(file)) {
+      console.log(GUTTER + `no preset file at ${file}`);
+      console.log("");
+      return;
+    }
+  } else {
+    const found = pr.presetFilesIn(listJsonFiles(home));
+    if (found.length === 0) {
+      console.log(GUTTER + `no presets in ${home} — save one with /save-preset <name> {…}`);
+      console.log("");
+      return;
+    }
+    let pick;
+    if (found.length === 1) {
+      pick = 0;
+      console.log(GUTTER + `one preset here: ${found[0]}`);
+    } else {
+      console.log(dim(`  Presets in ${home}  (${PICK_HINT}):`));
+      pick = await pickFromList(found.map((n) => ({ label: n })));
+    }
+    if (pick < 0) {
+      console.log(GUTTER + "load cancelled.");
+      console.log("");
+      return;
+    }
+    file = pr.presetFilePath(found[pick], home);
+  }
+  const checked = pr.validatePresetFile(readFileSync(file, "utf8"));
+  if (!checked.ok) {
+    console.log(GUTTER + `Not loaded — ${checked.problem}`);
+    console.log("");
+    return;
+  }
+  const name = checked.name || basename(file).replace(/\.json$/i, "");
+  const preset = checked.preset;
+  const settings = await fetchWorkerSettings();
+  for (const l of pr.presetPlanLines(name, preset, settings ?? {})) console.log(GUTTER + l);
+  if ((await ask("Apply this preset? [y/N] ")) !== "y") {
+    console.log(GUTTER + "load cancelled — nothing changed.");
+    console.log("");
+    return;
+  }
+  const { patch, existingRowId } = pr.presetToSettingsPatch(preset, settings ?? {});
+  const md = await import("./model-doctor.mjs");
+  const saved = await md.saveWorkerSettings(apiBase, workerKey, patch);
+  if (!saved) {
+    console.log(GUTTER + "the worker could not apply it — is the local API running? (`gu api status`)");
+    console.log("");
+    return;
+  }
+  let defaultNote = "";
+  const keyId = await addCodingKey(name, preset.apiKey, existingRowId);
+  if (keyId) {
+    // A new row's id arrives on the key's backendId once the settings write re-read; re-fetch
+    // the settings to find the row for this server when it was not one the account already had.
+    let rowId = existingRowId;
+    if (!rowId) {
+      const after = await fetchWorkerSettings();
+      const rows = Array.isArray(after?.agentCodingBackends) ? after.agentCodingBackends : [];
+      rowId = rows.find((r) => r?.id && typeof r.url === "string" && r.url.replace(/\/+$/, "").toLowerCase() === preset.apiUrl.replace(/\/+$/, "").toLowerCase())?.id ?? "";
+    }
+    if (rowId) {
+      const set = await setServerDefaultKey(rowId, keyId);
+      defaultNote = set.ok ? " — the preset's key is saved and made the server's default." : ` — the key saved but making it the default failed: ${set.error ?? "unknown"}`;
+    } else {
+      defaultNote = " — the key saved (the row's id was not readable to make it the default; set it in /agent-coding if needed).";
+    }
+  } else {
+    defaultNote = " — but the API key could not be saved (the add-key call failed; add it in /agent-coding).";
+  }
+  console.log(GUTTER + `preset "${name}" applied from ${file}${defaultNote}`);
+  console.log(GUTTER + "the new setup answers from the next prompt on.");
+  console.log("");
+}
+
 async function runSaveSettingsCommand(line) {
   const st = await import("./settings-transfer.mjs");
   const home = homedir();
@@ -10576,7 +10749,7 @@ async function main() {
   // machine that had been working for months.
   try {
     const { loadState, saveState, askMode } = await import("./client-expert-run.mjs");
-    const { clientExpertAvailable, expertPlanPending, shouldAskMode } =
+    const { clientExpertAvailable, expertPlanPending, shouldAskMode, parseLicenseFlag, resolveFirstRunMode } =
       await import("./client-expert-setup.mjs");
     const st = await loadState();
     const { probeMachine } = await import("./client-expert-run.mjs");
@@ -10590,10 +10763,19 @@ async function main() {
       ...machine,
     });
     if (shouldAskMode({ chosenMode: st.chosenMode, isTty: IS_TTY, expertAvailable: gate.available })) {
-      const chosen = await askMode(ask, {
+      // Same rule as the first run: the mode menu is a pro-license feature — without
+      // `--license <token>` this machine defaults to private (Client Expert) when it can
+      // run it, instead of being asked.
+      const plan = resolveFirstRunMode({
+        licenseToken: parseLicenseFlag(argv),
         expertAvailable: gate.available,
-        expertWhy: gate.message,
       });
+      const chosen = plan.ask
+        ? await askMode(ask, {
+            expertAvailable: gate.available,
+            expertWhy: gate.message,
+          })
+        : plan.mode;
       await saveState({ ...st, chosenMode: chosen ?? "client" });
       if (chosen === "client-expert") {
         const { runClientExpertSetup } = await import("./client-expert-run.mjs");
@@ -11535,6 +11717,14 @@ async function main() {
       await runS3Command(line);
       continue;
     }
+    if (line === "/save-preset" || line.startsWith("/save-preset ")) {
+      await runSavePresetCommand(line);
+      continue;
+    }
+    if (line === "/load-presets" || line.startsWith("/load-presets ")) {
+      await runLoadPresetsCommand(line);
+      continue;
+    }
     if (line === "/save-settings" || line.startsWith("/save-settings ")) {
       await runSaveSettingsCommand(line);
       continue;

package/package.json

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