@tiens.nguyen/gu-cli 1.0.782 → 1.0.783

package/client-expert-run.mjs

@@ -1111,7 +1111,7 @@ export async function runClientExpertSetup({
       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 /open-presets)"));
+        : " — set them any time with /model (or /use-presets)"));
     } else if (Object.keys(written).length === 0) {
       console.log("  " + cyan("✓ Models and RAG") + dim(" — already configured, left alone"));
     } else {
@@ -1159,7 +1159,7 @@ export async function runClientExpertSetup({
     dim("\n  machine. The API restarts with `gu-cli api start`; its log is") +
     dim(`\n  ${API_LOG_FILE}\n`)
   );
-  // #301: the caller opens /load-presets once the terminal exists — the picker, the plan and the
+  // #301: the caller opens /use-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 } : {}) };
 }

package/gu-repl.mjs

@@ -636,7 +636,7 @@ function reloadWorkerEnv() {
 // first-run branch also runs one — without this the same walkthrough printed twice in a single
 // run, MongoDB instructions and all. Reported live on Windows 11.
 let clientExpertRanThisProcess = false;
-// #301: setup chose "Load a saved preset" — main() opens /load-presets before the first prompt.
+// #301: setup chose "Load a saved preset" — main() opens /use-presets before the first prompt.
 // Declared HERE, above the first-run block: that block runs at module top level, before any
 // declaration further down exists.
 let openPresetsAtStart = false;
@@ -881,8 +881,9 @@ const COMMANDS = [
   // 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> [{json}]", desc: "save a named preset — server, API key and the agent/coding/embedding models — in your editor ($EDITOR, nano…), or as one line of JSON; all validated" },
-  { name: "/open-presets", aliases: ["/load-presets"], usage: "/open-presets [name]", desc: "pick a saved preset: Enter applies it (asks first) · v view · c copy as a command · j copy JSON · e edit" },
+  { name: "/save-preset", usage: "/save-preset [name]", desc: "paste a preset (from another computer's /open-presets) into your editor and save it under a name — nothing is applied" },
+  { name: "/open-presets", usage: "/open-presets [name]", desc: "your whole setup now, keys included, read-only in your editor — to copy to another computer; with a name, edit that preset" },
+  { name: "/use-presets", usage: "/use-presets [name]", desc: "pick a saved preset and apply it — shows what changes, backs up your setup, asks first" },
   { 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
@@ -6823,17 +6824,6 @@ function withTerminalHandedOver(run) {
   }
 }
 
-/**
- * /save-preset <name> — THE PRESET IN AN EDITOR (#312). Opens $VISUAL / $EDITOR / nano / vi
- * (Notepad on Windows) on a temp file filled in with the preset being edited or the current
- * setup; save and quit stores it, quit without a change cancels. A wrong value is named and the
- * editor reopens with the person's OWN text, never the template again.
- *
- * /save-preset <name> <json> — the one-line form (#6), kept for scripts and for pasting the
- * command /load-presets copies. Both validate everything before a byte is written. A preset SAVES
- * the API key by design (unlike /save-settings) — stored 0600 in the home folder, marked
- * "gu": "preset" so the two commands never offer each other's files.
- */
 /**
  * THIS ACCOUNT'S WHOLE SETUP as a version-2 preset (#320): every coding server and its models, the
  * default coder, the agent, the embedder — and each server's API key, read through the local API the
@@ -6876,129 +6866,163 @@ async function fetchKeyForBackend(backendId) {
   }
 }
 
+/**
+ * /save-preset [name] (#322) — PASTE A PRESET AND NAME IT. Opens an empty editor (the // header says
+ * how to save in THAT editor); the person pastes the JSON another computer's /open-presets showed,
+ * saves and quits. Checked in full, then stored 0600 under the name — NOTHING is applied (that is
+ * /use-presets). `/save-preset <name> {json}` is the one-line form, for scripts.
+ */
 async function runSavePresetCommand(line) {
   const pr = await import("./presets-transfer.mjs");
-  const home = homedir();
+  const ed = await import("./preset-editor.mjs");
   console.log("");
-  const usage = "usage: /save-preset <name>  (saves your whole setup)  ·  /save-preset <name> --edit  (in your editor)  ·  /save-preset <name> {json}";
   const raw = line.trim().slice("/save-preset".length).trim();
-  const wantsEdit = /(^|\s)--edit(?=\s|$)/.test(raw);
-  let rest = raw.replace(/(^|\s)--edit(?=\s|$)/, " ").trim();
-  if (!rest) {
-    const typed = String((await ask("preset name: ")) ?? "").trim();
-    if (!typed) {
-      console.log(GUTTER + dim("cancelled — nothing saved.") + "\n");
+  const space = raw.search(/\s/);
+  const given = space === -1 ? raw : raw.slice(0, space);
+  const json = space === -1 ? "" : raw.slice(space + 1).trim();
+  if (given && !pr.isPresetName(given)) {
+    console.log(GUTTER + `"${given}" is not a preset name — one word, no slashes. usage: /save-preset [name]` + "\n");
+    return;
+  }
+  try {
+    let parsed = null;
+    if (json) {
+      parsed = ed.parsePastedPreset(json);
+      if (!parsed.ok) {
+        console.log(GUTTER + `Preset not saved — ${parsed.problem}` + "\n");
+        return;
+      }
+    } else {
+      parsed = await pastePresetInEditor(ed);
+      if (!parsed) {
+        console.log(GUTTER + dim("Not saved.") + "\n");
+        return;
+      }
+    }
+    const name = given || (await askPresetName(pr, parsed.name || ""));
+    if (!name) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
       return;
     }
-    rest = typed;
-  }
-  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;
+    const file = pr.presetFilePath(name, homedir());
+    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it?`, false))) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    writePresetFile(pr, file, name, parsed);
+    console.log(GUTTER + dim(`/use-presets → ${name} applies it.`) + "\n");
+  } catch (e) {
+    if (wasPromptCancelled(e)) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    throw e;
   }
-  const file = pr.presetFilePath(name, home);
-  const store = (preset) => {
-    writeFileSync(file, JSON.stringify(pr.buildPreset({ name, 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("");
-  };
-  // A WHOLE-SETUP preset (#320): written as given (dated, named), then summarised — keys masked.
-  const storeFull = (doc) => {
-    const out = { ...doc, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname(),
-      note: "The whole setup: every coding server and its models, the default coder, the agent and the embedder — and each server's API key. This file CONTAINS live API keys." };
+}
+
+/** Store a checked preset (`parsed` from parsePastedPreset/parseEdited) — 0600, named, dated. */
+function writePresetFile(pr, file, name, parsed) {
+  if (parsed.full) {
+    const { note: _n, savedAt: _a, savedOn: _o, ...body } = parsed.doc;
+    const out = { ...body, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname() };
     writeFileSync(file, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
     const v = pr.validatePresetFile(JSON.stringify(out));
-    console.log(GUTTER + `Preset "${name}" saved to ${file} — your whole setup:`);
+    console.log(GUTTER + `Preset "${name}" saved to ${file}:`);
     if (v.ok && v.full) for (const l of pr.fullPresetSummary(v.value, v.codingDefault)) console.log(GUTTER + dim(l));
-    console.log(GUTTER + dim("It CONTAINS your API keys — keep it private. /open-presets → v to view it, c to copy it for another machine."));
-    console.log("");
-  };
-  const ed = await import("./preset-editor.mjs");
-  if (json) {
-    const checked = ed.parseEdited(json);
-    if (!checked.ok) {
-      console.log(GUTTER + `Preset not saved — ${checked.problem}`);
-      console.log("");
-      return;
-    }
-    if (checked.full) storeFull(checked.doc);
-    else store(checked.preset);
-    return;
+  } else {
+    writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: parsed.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
+    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
   }
+  console.log(GUTTER + dim("It CONTAINS API keys — the file is readable only by you."));
+}
 
-  // THE WHOLE SETUP, NOW (#320): every server, its models and key, the defaults — saved without an
-  // editor, because "as it is now" is what a person saving their setup means. --edit opens it first.
-  if (!wantsEdit) {
-    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it with the setup you have now?`, false))) {
-      console.log(GUTTER + dim("Not saved.") + "\n");
-      return;
-    }
-    const doc = await withPendingStatus("reading your servers, models and keys", () => buildFullPresetNow(name));
+/**
+ * /open-presets [name] (#322).
+ *   · no name — YOUR SETUP NOW (every server, model, key, the default coder, agent, embedder),
+ *     READ-ONLY in the editor, to copy to another computer. Then it offers the clipboard too (OSC 52
+ *     reaches the person's own machine over SSH): a long setup scrolls past one screen of nano, and
+ *     selecting across a scroll with the mouse does not work.
+ *   · a name — that preset in the editor; a saved change is checked in full first and a broken one is
+ *     never stored ("Edit again?" reopens the person's own text).
+ */
+async function runOpenPresetsCommand(line) {
+  const pr = await import("./presets-transfer.mjs");
+  const ed = await import("./preset-editor.mjs");
+  console.log("");
+  const name = line.trim().slice("/open-presets".length).trim();
+  if (!name) {
+    const doc = await withPendingStatus("reading your servers, models and keys", () => buildFullPresetNow("my-setup"));
     if (!doc) {
-      console.log(GUTTER + red(`couldn't read your settings from ${apiBase} — nothing was saved.`) + "\n");
+      console.log(GUTTER + red(`couldn't read your settings from ${apiBase}.`) + "\n");
       return;
     }
-    storeFull(doc);
+    const text = ed.currentSetupText(doc);
+    const editor = ed.pickEditor({ readOnly: true });
+    if (editor && process.stdin.isTTY) {
+      console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} read-only (${editor.saveHint}).`));
+      const r = withTerminalHandedOver(() => ed.editText(text, { editor, fileName: "gu-setup.json" }));
+      if (!r.ok) console.log(GUTTER + yellow(`couldn't show it — ${r.why}.`));
+    } else {
+      console.log(GUTTER + yellow(editor ? "an editor needs a terminal." : ed.NO_EDITOR_HINT + "."));
+    }
+    const v = pr.validatePresetFile(JSON.stringify(doc));
+    if (v.ok && v.full) for (const l of pr.fullPresetSummary(v.value, v.codingDefault)) console.log(GUTTER + dim(l));
+    if (await askYesNo("Copy it to the clipboard (keys included)?", true)) {
+      const res = await writeClipboard(text.split("\n").filter((l) => !l.startsWith("//")).join("\n"));
+      console.log(GUTTER + (res.ok ? accent("✓ copied — on the other computer: /save-preset, paste, save and quit.") : yellow(`couldn't copy (${res.why}).`)));
+    }
+    console.log("");
+    return;
+  }
+  const file = pr.presetFilePath(name, homedir());
+  if (!file) return; // a cancel word
+  if (!existsSync(file)) {
+    console.log(GUTTER + `no preset called "${name}" — /use-presets lists them.` + "\n");
+    return;
+  }
+  let doc = null;
+  try {
+    doc = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    /* named below */
+  }
+  if (doc?.gu !== "preset") {
+    console.log(GUTTER + `${file} is not a gu preset.` + "\n");
     return;
   }
-
-  // THE EDITOR. Filled in from the preset being edited, else from the whole setup this account has now.
   const editor = ed.pickEditor();
   if (!editor || !process.stdin.isTTY) {
-    console.log(GUTTER + (editor ? "an editor needs a terminal — " : "no editor found (set $EDITOR, e.g. export EDITOR=nano) — ") + usage);
-    console.log("");
+    console.log(GUTTER + yellow(editor ? "an editor needs a terminal." : ed.NO_EDITOR_HINT + ".") + "\n");
     return;
   }
-  let start = null;
-  if (existsSync(file)) {
-    try {
-      const doc = JSON.parse(readFileSync(file, "utf8"));
-      if (doc?.gu === "preset") start = doc;
-    } catch {
-      /* unreadable — start from the current setup instead */
-    }
-  }
-  if (!start) start = (await buildFullPresetNow(name)) ?? ed.presetFromSettings((await fetchWorkerSettings()) ?? {});
-  const initial = ed.editorText(name, start);
-  console.log(GUTTER + dim(`${start.gu ? "editing" : "new"} preset "${name}" in ${basename(editor.cmd)} — save and quit to store it, quit without changes to cancel.`));
+  const initial = ed.editorText(name, doc);
+  console.log(GUTTER + dim(`Opening "${name}" in ${basename(editor.cmd)} — save a change, or just quit.`));
   let text = initial;
   for (;;) {
     const r = withTerminalHandedOver(() => ed.editText(text, { editor, fileName: `${name}.json` }));
     if (!r.ok) {
-      console.log(GUTTER + `Preset not saved — ${r.why}.`);
-      console.log("");
+      console.log(GUTTER + `Not changed — ${r.why}.` + "\n");
       return;
     }
     if (r.text === initial) {
-      console.log(GUTTER + dim("Not saved — nothing changed.") + "\n");
+      console.log(GUTTER + dim("Not changed.") + "\n");
       return;
     }
     const parsed = ed.parseEdited(r.text);
     if (parsed.ok) {
-      if (parsed.full) storeFull(parsed.doc);
-      else store(parsed.preset);
+      writePresetFile(pr, file, name, parsed);
+      console.log("");
       return;
     }
-    console.log(GUTTER + yellow(`Not saved yet — ${parsed.problem}`));
+    console.log(GUTTER + yellow(`Not saved — ${parsed.problem}`));
     if (!(await askYesNo("Edit again?", true))) {
-      console.log(GUTTER + dim("Not saved.") + "\n");
+      console.log(GUTTER + dim("Not changed.") + "\n");
       return;
     }
-    text = r.text; // their text, with the mistake in it — not the template again
+    text = r.text; // their text, with the mistake in it — not the saved preset again
   }
 }
 
-/**
- * /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.
- */
 /**
  * After Ctrl+C stopped THIS terminal's turn (task #302): say what it left behind, and give the
  * question back.
@@ -7109,55 +7133,27 @@ async function runUndoCommand(line) {
 }
 
 /**
- * #317: a preset the person ALREADY HAS, brought in by pasting — its JSON, a whole preset file, or
- * the `/save-preset <name> {…}` command copied from another computer (#312). A multi-line paste
- * arrives as "[Pasted text #N +M lines]" and is expanded before it is read, so the key is never
- * echoed. A mistake is named; Enter then opens it IN THE EDITOR with the pasted text (not a blank
- * template), and Enter on nothing opens the editor on the current setup. Esc cancels.
- * Saved 0600 like /save-preset. → the file, or "" when cancelled.
+ * The pasting half of /save-preset (#317, #322): an EMPTY editor with the // header (the person's
+ * terminal editor over SSH — nano on a fresh Ubuntu server), or, with no editor or no terminal, a
+ * one-line prompt. → the parsed preset, or null when cancelled.
  */
-async function presetFromPaste(pr, home) {
-  const ed = await import("./preset-editor.mjs");
+async function pastePresetInEditor(ed) {
   const editor = ed.pickEditor();
-  let parsed = null;
-  try {
-    // AN EDITOR FIRST (#322): a preset is many lines — on an Ubuntu server over SSH, nano is the
-    // natural place to paste it. The one-line prompt is only the fallback with no editor/terminal.
-    if (editor && process.stdin.isTTY) {
-      // One short line (#322): the save keys are in the file's own header, where they are needed.
-      console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} — paste your preset there, then save and quit.`));
-      parsed = await fixPresetInEditor(ed, ed.pasteTemplate(editor.saveHint), { editor });
-      if (!parsed) return "";
-    } else {
-      if (!editor) console.log(GUTTER + yellow(ed.NO_EDITOR_HINT) + dim(" — or paste it here, on one line."));
-      console.log(GUTTER + "Paste a preset you already have — its JSON, a preset file, or a /save-preset command.");
-      console.log(GUTTER + dim("Esc cancels."));
-      while (!parsed) {
-        const text = String((await ask("preset: ")) ?? "");
-        if (!text.trim()) return "";
-        const p = ed.parsePastedPreset(text);
-        if (p.ok) {
-          parsed = p;
-          break;
-        }
-        console.log(GUTTER + yellow(`Not a preset yet — ${p.problem}`));
-        console.log(GUTTER + dim("Paste it again, or Esc to cancel."));
-      }
-    }
-    const name = await askPresetName(pr, parsed.name || "preset");
-    if (!name) return "";
-    const file = pr.presetFilePath(name, home);
-    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it?`, false))) return "";
-    // A whole-setup preset (#320) is kept as it is — every server, key and default — named and dated.
-    const out = parsed.full
-      ? { ...parsed.doc, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname() }
-      : pr.buildPreset({ name, preset: parsed.preset, host: hostname() });
-    writeFileSync(file, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
-    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
-    return file;
-  } catch (e) {
-    if (wasPromptCancelled(e)) return "";
-    throw e;
+  if (editor && process.stdin.isTTY) {
+    // One short line: the save keys are in the file's own header, where they are needed.
+    console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} — paste your preset there, then save and quit.`));
+    return fixPresetInEditor(ed, ed.pasteTemplate(editor.saveHint), { editor });
+  }
+  if (!editor) console.log(GUTTER + yellow(ed.NO_EDITOR_HINT) + dim(" — or paste it here, on one line."));
+  console.log(GUTTER + "Paste the preset — its JSON, a preset file, or a /save-preset line.");
+  console.log(GUTTER + dim("Esc cancels."));
+  for (;;) {
+    const text = String((await ask("preset: ")) ?? "");
+    if (!text.trim()) return null;
+    const p = ed.parsePastedPreset(text);
+    if (p.ok) return p;
+    console.log(GUTTER + yellow(`Not a preset yet — ${p.problem}`));
+    console.log(GUTTER + dim("Paste it again, or Esc to cancel."));
   }
 }
 
@@ -7197,98 +7193,43 @@ async function askPresetName(pr, dflt) {
   }
 }
 
-async function runLoadPresetsCommand(line) {
+/**
+ * /use-presets [name] (#322) — the saved presets, newest first: Enter APPLIES the chosen one (the plan
+ * with keys masked, a backup of the current setup, then "apply? [y/N]" — preset-apply.mjs), o opens it
+ * in the editor (/open-presets <name>). Presets come in through /save-preset.
+ */
+async function runUsePresetsCommand(line) {
   const pr = await import("./presets-transfer.mjs");
   const home = homedir();
   console.log("");
   let file = "";
-  // /open-presets (#322), or its old name /load-presets — the printed undo lines of older backups use it.
-  const typed = line.trim().replace(/^\/(open|load)-presets\b/, "").trim();
+  const typed = line.trim().slice("/use-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("");
+      console.log(GUTTER + `no preset called "${typed}" — /use-presets lists them.` + "\n");
       return;
     }
   } else {
-    // THE PICKER DOES MORE THAN APPLY (#312): v shows the whole preset (key masked) with a
-    // clickable "⧉ copy", c / j copy it as the /save-preset command or as JSON (key included), e
-    // opens it in the editor. Only Enter applies. Each of the others ENDS the command: the mouse
-    // is gu's only at the ">> " prompt (never while a picker is up), so a "⧉ copy" printed under a
-    // picker that stayed open could not be clicked until it closed.
     const ed = await import("./preset-editor.mjs");
     const found = pr.presetFilesIn(listJsonFiles(home));
-    // NO DEAD END (#317: "I need a place to input a preset I have already"): with nothing saved,
-    // the command asks for one right here; with presets saved, the picker's LAST row does (last, so
-    // Enter still applies the newest preset, as it always has).
     if (found.length === 0) {
       console.log(GUTTER + "No presets saved yet.");
-      file = await presetFromPaste(pr, home);
-      if (!file) {
-        console.log(GUTTER + "load cancelled.");
-        console.log("");
-        return;
-      }
-    } else {
-      console.log(dim(`  Presets in ${home === homedir() ? "~" : home}  (${ed.PICKER_HINT}):`));
-      const PASTE_ROW = "+ Paste a preset I already have…";
-      const pick = await pickFromList([...found, PASTE_ROW], 0, { keys: ed.PICKER_KEYS });
-      if (!pick || pick.index < 0) {
-        console.log(GUTTER + "load cancelled.");
-        console.log("");
-        return;
-      }
-      if (pick.index === found.length) {
-        file = await presetFromPaste(pr, home);
-        if (!file) {
-          console.log(GUTTER + "load cancelled.");
-          console.log("");
-          return;
-        }
-        pick.action = "select"; // a pasted preset goes on to be applied, whatever key opened the row
-      } else {
-        file = pr.presetFilePath(found[pick.index], home);
-      }
-      if (pick.action === "edit") {
-        await runSavePresetCommand(`/save-preset ${found[pick.index]}`);
-        return;
-      }
-      if (pick.action !== "select") {
-        const shown = pr.validatePresetFile(readFileSync(file, "utf8"));
-        if (!shown.ok) {
-          console.log(GUTTER + `Can't show it — ${shown.problem}`);
-          console.log("");
-          return;
-        }
-        const pname = shown.name || found[pick.index];
-        // A whole-setup preset (#320) is shown and copied AS SAVED — every server, every key.
-        const body = shown.full ? JSON.parse(readFileSync(file, "utf8")) : shown.preset;
-        const command = ed.presetCopyCommand(pname, body);
-        if (pick.action === "view") {
-          const block = ed.presetBlock(pname, body, { width: process.stdout.columns || 80, gutter: GUTTER });
-          const [top, ...restRows] = block.rows;
-          const cut = block.button.from;
-          console.log(dim(top.slice(0, cut)) + accent(top.slice(cut, block.button.to)) + dim(top.slice(block.button.to)));
-          for (const r of restRows) console.log(r);
-          registerCopyBlock(block.rows.length, command, 0, { button: block.button, note: "✓ copied — includes the API key" });
-          console.log(GUTTER + dim("click ⧉ copy for a /save-preset command to paste anywhere — it includes the real key."));
-          console.log(GUTTER + dim(`/open-presets ${pname} applies it.`));
-          console.log("");
-          return;
-        }
-        const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(body) : command);
-        console.log(
-          GUTTER +
-            (res.ok
-              ? accent(`✓ copied ${pick.action === "json" ? "the JSON" : "the /save-preset command"} for "${pname}" — includes the API key.`)
-              : yellow(`couldn't copy (${res.why}) — the preset is in ${file}.`))
-        );
-        console.log("");
-        return;
-      }
+      console.log(GUTTER + dim("/save-preset pastes one in — copy it from another computer's /open-presets.") + "\n");
+      return;
+    }
+    console.log(dim(`  Presets  (${ed.PICKER_HINT}):`));
+    const pick = await pickFromList(found, 0, { keys: ed.PICKER_KEYS });
+    if (!pick || pick.index < 0) {
+      console.log(GUTTER + dim("nothing changed.") + "\n");
+      return;
     }
+    if (pick.action === "open") {
+      await runOpenPresetsCommand(`/open-presets ${found[pick.index]}`);
+      return;
+    }
+    file = pr.presetFilePath(found[pick.index], home);
   }
   const checked = pr.validatePresetFile(readFileSync(file, "utf8"));
   if (checked.ok && checked.full) {
@@ -9513,7 +9454,7 @@ let listAllowDelete = false;
 // happened rather than encoding it into the index and hoping every caller decodes it.
 let listDeleteRequested = false;
 // Single letters that finish a single-select picker with an ACTION on the highlighted row, e.g.
-// /load-presets' { v: "view", c: "copy" } (#312). Null unless a caller asks, like ctrl+d above.
+// /use-presets' { o: "open" } (#312, #322). Null unless a caller asks, like ctrl+d above.
 let listKeys = null;
 let listKeyAction = "";
 function drawList(redraw) {
@@ -12457,13 +12398,13 @@ async function main() {
   }
 
   // #301: setup's "Load a saved preset" — the picker opens now that the terminal exists. The whole
-  // /load-presets flow (the list, the plan, the confirmation, the key) is that command's own.
+  // /use-presets flow (the list, the plan, the confirmation, the key) is that command's own.
   if (openPresetsAtStart) {
     openPresetsAtStart = false;
     try {
-      await runLoadPresetsCommand("/open-presets");
+      await runUsePresetsCommand("/use-presets");
     } catch (e) {
-      console.log(GUTTER + dim(`(could not open the presets: ${e?.message ?? e} — run /open-presets)`));
+      console.log(GUTTER + dim(`(could not open the presets: ${e?.message ?? e} — run /use-presets)`));
     }
   }
 
@@ -12678,9 +12619,12 @@ async function main() {
       await runSavePresetCommand(line);
       continue;
     }
-    // #322: /open-presets, and its old name /load-presets (older backups print it in their undo line)
-    if (line === "/open-presets" || line.startsWith("/open-presets ") || line === "/load-presets" || line.startsWith("/load-presets ")) {
-      await runLoadPresetsCommand(line);
+    if (line === "/open-presets" || line.startsWith("/open-presets ")) {
+      await runOpenPresetsCommand(line);
+      continue;
+    }
+    if (line === "/use-presets" || line.startsWith("/use-presets ")) {
+      await runUsePresetsCommand(line);
       continue;
     }
     if (line === "/save-settings" || line.startsWith("/save-settings ")) {

package/package.json

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

package/preset-apply.mjs

@@ -4,7 +4,7 @@
  * here the REAL code runs in tests against a fake API that records every call and can be told to
  * fail — which is how "loading a preset cannot break the workspace" is checked rather than hoped.
  *
- * Used for /save-preset, /load-presets (a version-2 preset) and /load-settings — one path for all.
+ * Used for /use-presets (a version-2 preset) and /load-settings — one path for all.
  *
  *   api = {
  *     settings():                Promise<object|null>   GET  /api/worker/settings
@@ -101,7 +101,7 @@ export async function applyTransfer(value, { api, io, fromLine = "", carriesSecr
     }
     out.backup = b.file;
     say(`backup of your current setup: ${b.file}`);
-    say(`to undo: /open-presets ${b.file}`);
+    say(`to undo: /use-presets ${b.file}`);
   }
   const patch = toSettingsPatch(value, current);
   const saved = Object.keys(patch).length ? await api.saveSettings(patch) : true;

package/preset-editor.mjs

@@ -11,7 +11,7 @@
  *     user's own 0600 file; root would make it root-owned and ask for a password for nothing.
  *   · The temp file holds a live key: it is created 0600 inside a private 0700 directory and the
  *     directory is removed on every path out, a Ctrl+C included.
- *   · /load-presets can show a preset as one framed block — the key MASKED on screen (scrollback
+ *   · /use-presets could show a preset as one framed block — the key MASKED on screen (scrollback
  *     and logs must not keep it, #248) — and copy it with the real key: as the ready-to-paste
  *     `/save-preset <name> {…}` command (paste it into gu on another computer and it is there),
  *     or as plain JSON.
@@ -52,8 +52,9 @@ export function isHeadless({ env = process.env, platform = process.platform } =
  * `saveHint` is what the header tells the person to press — editors differ, and a server's nano is
  * often someone's first.
  */
-export function pickEditor({ env = process.env, platform = process.platform, has = onPath } = {}) {
+export function pickEditor({ env = process.env, platform = process.platform, has = onPath, readOnly = false } = {}) {
   const headless = isHeadless({ env, platform });
+  const withHints = (ed) => editorHints(ed, { readOnly, platform });
   const named = [env.VISUAL, env.EDITOR].map(splitCommand).filter((w) => w.length);
   for (const words of named) {
     const base = words[0].split(/[\\/]/).pop();
@@ -65,8 +66,30 @@ export function pickEditor({ env = process.env, platform = process.platform, has
   return null;
 }
 
-function withHints(ed) {
+/**
+ * The flags and the "how do I save" line for one editor.
+ *
+ * READ-ONLY (#322, /open-presets with no name — the current setup, to copy to another computer):
+ * nano -v (view mode), vim/vi -R. And for nano, SOFT-WRAP (-$): nano otherwise shows a long line cut
+ * off at the screen edge, and a key copied from an 80-column SSH terminal would come out SHORTER —
+ * a key that looks fine and is wrong. (Not macOS's /usr/bin/nano, which is pico and has no -$; the
+ * line breaks a soft-wrapped copy carries are taken out again by parseEdited.)
+ */
+function editorHints(ed, { readOnly = false, platform = process.platform } = {}) {
   const base = ed.cmd.split(/[\\/]/).pop().replace(/\.exe$/i, "").toLowerCase();
+  if (readOnly) {
+    let args = ed.args;
+    if (base === "nano") {
+      if (!args.includes("-v") && !args.includes("--view")) args = ["-v", ...args];
+      if (platform !== "darwin" && !args.some((a) => a === "-$" || a === "--softwrap")) args = ["-$", ...args];
+    } else if (/^(vim?|nvim|gvim)$/.test(base) && !args.includes("-R")) args = ["-R", ...args];
+    const closeHint =
+      base === "nano" ? "nano: Ctrl+X to close"
+      : /^(vim?|nvim|gvim)$/.test(base) ? "vi: :q Enter to close"
+      : base === "notepad" ? "Notepad: close the window (nothing you change is kept)"
+      : "quit the editor (nothing you change is kept)";
+    return { ...ed, args, saveHint: closeHint, readOnly: true };
+  }
   if (base === "nano" && !ed.args.some((a) => /^(-w|--nowrap|-b|--breaklonglines)$/.test(a))) ed = { ...ed, args: ["-w", ...ed.args] };
   const saveHint =
     base === "nano" ? "nano: Ctrl+O, Enter, Ctrl+X to save · Ctrl+X, N to cancel"
@@ -77,6 +100,47 @@ function withHints(ed) {
   return { ...ed, saveHint };
 }
 
+/**
+ * Take raw line breaks out of JSON STRINGS (never out of the structure between them). Only strings
+ * are touched, and a valid JSON string cannot contain a raw line break — so valid JSON is unchanged.
+ */
+export function joinBrokenStrings(src) {
+  let out = "";
+  let inStr = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (inStr) {
+      if (c === "\\") {
+        out += c + (src[i + 1] ?? "");
+        i++;
+        continue;
+      }
+      if (c === "\r" || c === "\n") continue;
+      if (c === '"') inStr = false;
+    } else if (c === '"') inStr = true;
+    out += c;
+  }
+  return out;
+}
+
+/**
+ * /open-presets with no name (#322): THE CURRENT SETUP, read-only, to copy to another computer and
+ * paste into /save-preset there. The full keys are in it — that is the point — so the header says so.
+ */
+export function currentSetupText(doc) {
+  const { note: _n, savedAt: _a, savedOn: _o, ...body } = doc ?? {};
+  return (
+    [
+      "// Your gu setup NOW — read-only. Copy ALL of it (keys included) and on the",
+      "// other computer run /save-preset there, paste it, save and quit.",
+      "// This CONTAINS your API keys — paste it only somewhere private.",
+    ].join("\n") +
+    "\n" +
+    JSON.stringify({ ...body, gu: "preset", version: FULL_PRESET_VERSION }, null, 2) +
+    "\n"
+  );
+}
+
 /** What to say when a server has no editor at all. */
 export const NO_EDITOR_HINT = "no editor found — install one (Ubuntu: sudo apt install nano) or set $EDITOR";
 
@@ -122,9 +186,11 @@ export function editorText(name, preset = {}) {
     const { note: _n, savedAt: _a, savedOn: _o, ...body } = preset;
     return (
       [
-        `// gu preset "${name}" — THE WHOLE SETUP: every coding server and its models, each server's API key,`,
-        "// the default coder, the agent and the embedder. Edit anything, then save and quit to store it.",
-        "// Lines starting with // are ignored. Quit without saving (or unchanged) to cancel. This CONTAINS your API keys.",
+        // each line fits an 80-column SSH terminal (#322)
+        `// gu preset "${name}" — servers, models, API keys, coder, agent, embedder.`,
+        "// Edit anything, then save and quit to keep it (it is checked first).",
+        "// Quit without saving to leave it as it is. Lines starting // are ignored.",
+        "// This CONTAINS your API keys.",
       ].join("\n") +
       "\n" +
       JSON.stringify({ ...body, gu: "preset", version: FULL_PRESET_VERSION, name }, null, 2) +
@@ -221,11 +287,23 @@ export function jsonErrorIndex(src) {
  * blanked (not removed) so a JSON error's line number is the line the person sees in the editor.
  */
 export function parseEdited(text) {
-  const src = String(text ?? "").replace(/^[ \t]*\/\/.*$/gm, "");
+  let src = String(text ?? "").replace(/^[ \t]*\/\/.*$/gm, "");
   if (!src.trim()) return { ok: false, empty: true, problem: "the file is empty." };
   try {
     JSON.parse(src);
   } catch (e) {
+    // A copy from a soft-wrapping terminal or editor breaks a long line — a key — in two (#322). A
+    // JSON string can never hold a raw line break, so taking them out of strings changes nothing
+    // that was valid; it is only tried when the text does not parse as it is.
+    const joined = joinBrokenStrings(src);
+    if (joined !== src) {
+      try {
+        JSON.parse(joined);
+        return parseEdited(joined);
+      } catch {
+        /* still broken — report the ORIGINAL text's mistake, at the line the person sees */
+      }
+    }
     // Node names the line only for SOME errors ("Expected ':' …"); a stray comma comes back as just a
     // snippet. So when it does not say, find the spot ourselves — the person fixes a LINE in an editor.
     let at = /line (\d+) column (\d+)/.exec(String(e?.message ?? ""));
@@ -301,7 +379,7 @@ export function presetCopyJson(preset) {
 }
 
 /**
- * The framed block /load-presets prints for "view": the key masked, "⧉ copy" in the top border.
+ * The framed block a preset view prints for "view": the key masked, "⧉ copy" in the top border.
  * Every row fits `width - 1` so none wraps (a wrapped row breaks the click arithmetic, #109).
  * → { rows, button: { from, to } } — the button's column span on row 0, 0-based, gutter included.
  */
@@ -325,10 +403,10 @@ export function presetBlock(name, preset, { width = 80, gutter = "   " } = {}) {
   };
 }
 
-/** The keys the /load-presets picker takes, in the order its hint line names them. */
-export const PICKER_KEYS = { v: "view", c: "copy", j: "json", e: "edit" };
+/** The keys the /use-presets picker takes, in the order its hint line names them. */
+export const PICKER_KEYS = { o: "open" };
 // Short enough for one 80-column row with "  Presets in ~  (…):" around it (#322 — it wrapped).
-export const PICKER_HINT = "Enter use · v view · c copy · j JSON · e edit · Esc";
+export const PICKER_HINT = "Enter use it · o open in the editor · Esc";
 
 /**
  * The file the editor opens for "paste a preset" (#322: "load preset doesn't give me any editor so
@@ -347,7 +425,7 @@ export function pasteTemplate(saveHint = "save, then quit the editor") {
 }
 
 /**
- * A PRESET SOMEONE ALREADY HAS, pasted into /load-presets (#317: "I need a place to input a preset
+ * A PRESET SOMEONE ALREADY HAS, pasted into /save-preset (#317: "I need a place to input a preset
  * I have already, which is in JSON format"). Three shapes are accepted, because those are the three
  * things a person could be holding:
  *

package/presets-transfer.mjs

@@ -1,5 +1,5 @@
 /**
- * MODEL PRESETS — the files /save-preset writes and /load-presets reads (#6).
+ * MODEL PRESETS — the files /save-preset writes and /use-presets reads (#6).
  *
  * HOW A PRESET DIFFERS FROM A SETTINGS FILE. /save-settings asks nothing: it writes the whole
  * account, names the keys, and refuses to carry a single secret. /save-preset is the opposite
@@ -15,7 +15,7 @@
  * preset's name, bound to that row, and made the row's DEFAULT key so the resolver finds it.
  *
  * THE MARKER. A preset file carries "gu": "preset" (not "settings") so /load-settings never
- * offers it and /load-presets never offers a settings file — two commands, two folders' worth of
+ * offers it and /use-presets never offers a settings file — two commands, two folders' worth of
  * files, no cross-picking.
  */
 
@@ -56,7 +56,7 @@ export function presetFilePath(typed, home) {
 const withJson = (p) => (extname(basename(p)) ? p : `${p}.json`);
 
 /**
- * The preset files in the default folder, newest first — what /load-presets offers. Only files
+ * The preset files in the default folder, newest first — what /use-presets offers. Only files
  * that ARE preset files (the "gu": "preset" marker). `entries` = [{ name, text, mtimeMs }], and
  * each name is returned as just the preset name (the .json comes off — it is the name the user
  * typed when saving).
@@ -198,7 +198,7 @@ export function presetToSettingsPatch(preset, current = {}) {
   };
 }
 
-/** The lines /load-presets prints before it asks — what applying the preset will do. */
+/** The lines /use-presets prints before it asks — what applying the preset will do. */
 export function presetPlanLines(name, preset, current = {}) {
   const same = (a, b) => clean(a).toLowerCase() === clean(b).toLowerCase();
   const lines = [];
@@ -409,7 +409,7 @@ export function maskedFullPreset(doc) {
   return { ...doc, keys: (Array.isArray(doc?.keys) ? doc.keys : []).map((k) => ({ ...k, ...(k.key ? { key: mask(k.key) } : {}) })) };
 }
 
-/** The lines /load-presets prints before applying a version-2 preset (keys masked). */
+/** The lines /use-presets prints before applying a version-2 preset (keys masked). */
 export function fullPresetSummary(v, codingDefault) {
   const lines = [];
   for (const b of v.backends) {