@tiens.nguyen/gu-cli 1.0.773 → 1.0.775

package/cli-token.mjs

@@ -185,6 +185,75 @@ export function trialStartedLine(endsAt, site = DEFAULT_SITE) {
     `Then get a free token for 1 computer at ${accountUrl} — gu token <paste> links it.`;
 }
 
+/**
+ * How the trial token is shown in the input: its ends, with "…" between (a whole token is ~520
+ * characters — five rows of input). Only ever compared, never saved: the real token is kept aside.
+ */
+export function shortToken(token) {
+  const t = String(token ?? "");
+  return t.length <= 24 ? t : `${t.slice(0, 16)}…${t.slice(-6)}`;
+}
+
+/**
+ * THE TOKEN QUESTION, WITH THE TRIAL AS ITS DEFAULT (#305, the user's correction: "gu should still
+ * wait for the user to input a token, but show a default token and hint that it is a free trial
+ * for 10 days — not silently").
+ *
+ *     Input token: gu1.eyJ2IjoxLCJz…Xk9aQw          ← typed in: Enter takes it, or delete it
+ *     This is a free trial token: 10 days on this computer, until 10 Oct 2026.     ← yellow, under
+ *     For a free token for 1 computer, log in at gu.example/account and create one — or buy Pro …
+ *
+ * The trial is fetched first (it is the same one every time for this computer). Nothing is saved
+ * without an answer: the shown default → the trial; anything else is checked as a pasted token;
+ * nothing at all (the default deleted) → skipped. Asked at the end of first-time setup, and before
+ * a private-mode turn whenever there is still no token.
+ *
+ * `ask(label, { prefill, hint })` → the typed line. `log(line, kind)` prints: "title" | "ok" | "warn".
+ * → { ok: true, kind: "trial" | "pasted" } | { ok: false, why: "skipped" | "refused" }
+ */
+export async function promptForToken({
+  ask,
+  dir,
+  log = (l) => console.log(l),
+  hostedBase,
+  site = siteUrl(),
+  device,
+  claim = claimTrial,
+  publicKeyB64 = publicKey(),
+}) {
+  const accountUrl = `${String(site).replace(/^https?:\/\//, "")}/account`;
+  const dev = device === undefined ? await trialDevice().catch(() => null) : device;
+  const trial = dev ? await claim({ hostedBase, device: dev }) : { ok: false, why: "no-device" };
+  const trialOk = trial.ok && verifyCliToken(trial.token, publicKeyB64).ok;
+
+  const shown = trialOk ? shortToken(trial.token) : "";
+  const getOne = `For a free token for 1 computer, log in at ${accountUrl} and create one — or buy Pro there for more computers.`;
+  const hint = trialOk
+    ? [`This is a free trial token: 10 days on this computer, until ${shortDate(trial.endsAt)}.`, getOne, "Enter uses it — or delete it and paste your own token."]
+    : [
+        ...(trial.why === "used" && trial.endedAt ? [`The free trial on this computer ended on ${shortDate(trial.endedAt)}.`] : []),
+        getOne,
+        "Paste it here — or Enter to skip for now.",
+      ];
+  log("This computer needs a gu token before the agent can start — one time only.", "title");
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const typed = String((await ask("Input token: ", { prefill: shown, hint })) ?? "").trim();
+    if (!typed) return { ok: false, why: "skipped" };
+    if (trialOk && (typed === shown || typed === trial.token)) {
+      await writeState(dir, { token: trial.token, lastAttemptAt: new Date().toISOString() });
+      log(`✓ free trial token saved — 10 days on this computer, until ${shortDate(trial.endsAt)}.`, "ok");
+      return { ok: true, kind: "trial" };
+    }
+    const saved = await saveTokenFromPaste(dir, typed, publicKeyB64);
+    if (saved.ok) {
+      log("✓ token saved — it renews itself from now on.", "ok");
+      return { ok: true, kind: "pasted" };
+    }
+    log(`That token was not saved: ${saved.reason}.`, "warn");
+  }
+  return { ok: false, why: "refused" };
+}
+
 /** What renewals send about this computer. The raw OS id never leaves the machine — only a salted hash. */
 export async function thisDevice({ platform = process.platform, hostName = osHostname(), machineId, instanceId } = {}) {
   const raw = machineId ?? (await osMachineId({ platform }));

package/client-expert-run.mjs

@@ -1153,6 +1153,26 @@ export async function runClientExpertSetup({
     await saveState(state);
   }
 
+  // THE gu TOKEN, AS THE LAST SETUP STEP (#305): private mode needs one before the first turn, so
+  // it is asked while the person is still answering setup questions — with this computer's free
+  // 10-day trial as the default (Enter), never taken silently. Skipped → asked at the first turn.
+  try {
+    const ct = await import("./cli-token.mjs");
+    const had = await ct.readState(join(homedir(), ".gonext"));
+    if (ct.publicKey() && !(had.token && ct.verifyCliToken(had.token, ct.publicKey()).ok)) {
+      const { DEFAULT_API_BASE } = await import("./device-login.mjs");
+      console.log("");
+      await ct.promptForToken({
+        ask: (label, opts) => ask("  " + label, opts),
+        dir: join(homedir(), ".gonext"),
+        hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
+        log: (l, kind) => console.log("  " + (kind === "ok" ? cyan(l) : kind === "title" ? bold(l) : kind === "warn" ? yellow(l) : dim(l))),
+      });
+    }
+  } catch (e) {
+    console.log(dim(`  (the gu token can be added later: gu token <paste> — ${e?.message ?? e})`));
+  }
+
   console.log(
     "\n  " + cyan(bold("Local mode is set up.")) +
     dim("\n  Everything — conversations, token counts, workspaces — stays in MongoDB on this") +

package/gu-repl.mjs

@@ -98,6 +98,7 @@ import {
   inputPhysicalRows,
   buildFooterRows,
   pasteHint,
+  hintRows as questionHintRows,
   footerDrawSeq,
   footerEraseSeq,
   clearBlockSeq,
@@ -657,8 +658,11 @@ if (!workerKey || !apiBase) {
         input: process.stdin,
         output: process.stdout,
       });
-      const ask0 = (q) =>
-        new Promise((res) => rl0.question(accent(q), (a) => res(String(a || ""))));
+      // #305: a question with a typed-in default or a hint under it goes through askOn, which draws both.
+      const ask0 = async (q, opts) =>
+        opts
+          ? String((await (await import("./setup-prompts.mjs")).askOn(rl0, q, { style: accent, ...opts })) || "")
+          : new Promise((res) => rl0.question(accent(q), (a) => res(String(a || ""))));
       let typed = "";
       // Set when Client Expert setup stops on something the user must do first: the run ends
       // after the instructions instead of continuing into questions that assume a paired,
@@ -879,8 +883,8 @@ 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> {"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: "/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: "/load-presets", usage: "/load-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: "/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
@@ -1477,6 +1481,7 @@ function applyClick({ row, col }) {
     // A click in the SCROLLING area is not aimed at the caret — it may be aimed at a thought
     // block asking to be opened (task #148). Checked before the input-row test so the two
     // never compete for the same event.
+    if (!onInputRow(row) && clickCopyButton(row, col)) return;
     if (!onInputRow(row) && toggleThoughtAtRow(row)) return;
     if (!onInputRow(row) || !clickOffsetAt) return;
     rl.cursor = clickOffsetAt(inputRowIndex(row), col);
@@ -2186,31 +2191,6 @@ let startupRenewDone = false;
 let licenceBlock = null;
 let licenceDecided = false;
 
-/**
- * THE FREE TRIAL (#305): a first install gets ten days on this computer instead of a "paste your
- * token" stop. Once per computer — the gu service decides, keyed on the OS machine id's hash. → true
- * when a trial token is now saved. Tried at most once per start by the startup refresh, and again
- * right before the token question (a first start may have been offline).
- */
-let trialTried = false;
-let trialEndedAt = ""; // this computer's trial has ended — the token question says so
-async function tryTrialToken(ct, dir, { announce = true } = {}) {
-  const device = await ct.trialDevice().catch(() => null);
-  if (!device) return false; // no stable machine id → no trial (see trialDevice)
-  const { DEFAULT_API_BASE } = await import("./device-login.mjs");
-  const hostedBase = String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE;
-  const r = await ct.claimTrial({ hostedBase, device });
-  if (r.ok && ct.verifyCliToken(r.token, ct.publicKey()).ok) {
-    await ct.writeState(dir, { token: r.token, lastAttemptAt: new Date().toISOString() });
-    if (announce) {
-      console.log(GUTTER + accent(r.created ? ct.trialStartedLine(r.endsAt, ct.siteUrl()) : `Free trial on this computer until ${ct.shortDate(r.endsAt)}.`));
-    }
-    return true;
-  }
-  if (r.why === "used" && r.endedAt) trialEndedAt = r.endedAt;
-  return false;
-}
-
 async function refreshCliToken() {
   if (tokenBusy) return;
   tokenBusy = true;
@@ -2225,11 +2205,6 @@ async function refreshCliToken() {
     const mode = isClientExpert() ? "expert" : "client";
     const site = ct.siteUrl();
     let state = await ct.readState(dir);
-    // #305: private mode with no usable token → this computer's free trial, before anything asks.
-    if (mode === "expert" && !trialTried && !(state.token && ct.verifyCliToken(state.token, pk).ok)) {
-      trialTried = true;
-      if (await tryTrialToken(ct, dir)) state = await ct.readState(dir);
-    }
     const now = new Date();
     const noticeNow = () =>
       ct.barNotice({ token: state.token, publicKeyB64: pk, mode, now: new Date(), attempted: Boolean(state.lastAttemptAt), site });
@@ -2511,6 +2486,9 @@ const footerRows = () =>
     // Task #14: the skipped-setup warning — persistent (not a timed notice), red, its own row.
     missing: missingNoticeText() ? red(missingNoticeText()) : "",
   });
+// An ask()'s hint lines (#305), drawn in yellow under its input while it waits. Plain text.
+let askHint = [];
+const askHintRows = (width) => questionHintRows(askHint, { width, gutter: GUTTER, paint: yellow });
 // True only while the MAIN loop's ">> " prompt is waiting for input. The bar belongs to that
 // prompt, so it must never appear under an ask()/askSecret() question or during a turn.
 let footerActive = false;
@@ -2652,7 +2630,7 @@ function frozenZone() {
     selection: secretInput ? null : inputSelection,
     highlight: highlightRow,
   });
-  const rows = status.concat(zone.rows, footerRows());
+  const rows = status.concat(zone.rows, askHintRows(width), footerRows());
   // THE SEPARATOR IS NO LONGER ROW 0. With the status block prepended it sits `status.length`
   // rows down, and every affordance below writes to it by index — a bare rows[0] would paint
   // the jump hint over the thought line and hit-test the wrong row.
@@ -2787,7 +2765,7 @@ let inputSelection = null;
  */
 const maxInputRows = () => {
   const MIN_VIEW = 4;
-  const spare = viewportRows() - footerRows().length - INPUT_HEAD_ROWS - MIN_VIEW;
+  const spare = viewportRows() - footerRows().length - askHintRows(process.stdout.columns || 80).length - INPUT_HEAD_ROWS - MIN_VIEW;
   return Math.max(1, Math.min(10, spare));
 };
 /**
@@ -3149,7 +3127,7 @@ async function copyAtRow(row) {
  * `trailingBlanks` is how many blank lines the write left BELOW the block — see
  * registeredRange, where getting it wrong silently shifts the whole range by one.
  */
-function registerCopyBlock(rowCount, text, trailingBlanks = 0) {
+function registerCopyBlock(rowCount, text, trailingBlanks = 0, extra = {}) {
   if (!rowCount || !String(text ?? "").trim()) return;
   const { from, to } = registeredRange({
     dropped: transcript.dropped(),
@@ -3157,7 +3135,9 @@ function registerCopyBlock(rowCount, text, trailingBlanks = 0) {
     rowCount,
     trailingBlanks,
   });
-  copyBlocks.push({ from, to, text: String(text) });
+  // `extra.button` = { from, to } columns on the block's FIRST row that copy on a single click
+  // (the preset block's "⧉ copy", #312); `extra.note` is the badge it shows.
+  copyBlocks.push({ from, to, text: String(text), ...extra });
   if (copyBlocks.length > 200) copyBlocks = copyBlocks.slice(-200);
 }
 
@@ -3397,6 +3377,30 @@ function paintCopyBadge(row, place, ok = true) {
   }, 2000);
 }
 
+/**
+ * A single click on a block's "⧉ copy" (#312) → copy its source text. → true when the click was
+ * on a button (handled), false to let the click do whatever else it does.
+ */
+function clickCopyButton(row, col) {
+  if (!barPinned() || !copyBlocks.length) return false;
+  const width = Math.max(20, process.stdout.columns || 80) - 1;
+  const owners = displayRowOwners(transcript.lines(), width);
+  const logical = lineAtViewportRow(owners, row, transcriptRows(), scrollOffset);
+  if (logical < 0) return false;
+  const abs = transcript.dropped() + logical;
+  const b = blockAt(copyBlocks, abs);
+  if (!b?.button || abs !== b.from || col - 1 < b.button.from || col - 1 >= b.button.to) return false;
+  void (async () => {
+    try {
+      const res = await writeClipboard(b.text);
+      showCopyBadge(row, res.ok ? b.note || "copied" : copyBadge({ ok: false, why: res.why }), res.ok);
+    } catch {
+      /* a failed copy must never take the session down */
+    }
+  })();
+  return true;
+}
+
 function copyTargetAtRow(row) {
   if (!barPinned()) return null;
   const width = Math.max(20, process.stdout.columns || 80) - 1;
@@ -4268,7 +4272,7 @@ function maybeCancelPrompt(str, key) {
   submitSyntheticLine(CANCEL_LINE);
   return true;
 }
-const ask = async (q) => {
+const ask = async (q, { prefill = "", hint = [] } = {}) => {
   // Route the question through readline's own prompt so its redraw logic stays
   // consistent (a raw stdout write here would re-create the stale-cursor artifact
   // that terminal:true mode is designed to avoid). Restored to ">> " afterwards.
@@ -4333,6 +4337,13 @@ const ask = async (q) => {
     // the turn's empty-prompt behaviour must come back.
     const wasVisible = inputVisible;
     inputVisible = true;
+    // #305: a default typed in for the person to take (Enter) or delete, and a hint drawn under
+    // the input (frozenZone) — both only for this question.
+    askHint = hint;
+    if (prefill) {
+      rl.line = String(prefill);
+      rl.cursor = rl.line.length;
+    }
     // ELLIPSIS, so a truncation is VISIBLE. Silently cutting "…[https://ollama2.gomarsic.cc/v1]:"
     // to "…[https:/" hides the default Enter would accept, which is worse than not showing it —
     // the reader cannot tell whether the value is short or the row lied. Callers should keep the
@@ -4350,13 +4361,17 @@ const ask = async (q) => {
       return (a ?? "").trim();
     } finally {
       askWaiting = false;
+      askHint = [];
       inlinePrompt = "";
       inputVisible = wasVisible;
       paintBar(); // put ">> " back, or the next question wears this one's label
     }
   }
+  // Unpinned (piped output, a short window): no frozen zone to draw under, so the hint goes above.
+  for (const l of hint) console.log(GUTTER + yellow(l));
   rl.setPrompt(gutterLines(q));
   rl.prompt();
+  if (prefill) rl.write(String(prefill));
   let a;
   try {
     askWaiting = true;
@@ -6712,24 +6727,70 @@ function settingsArg(line, word) {
 }
 
 /**
- * /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.
+ * Give the terminal to a full-screen program (an editor, #312) and take it back afterwards.
+ *
+ * gu owns the screen while it runs: a pinned frozen zone (DECSTBM), raw mode, mouse reporting and
+ * bracketed paste. An editor started on top of that would get gu's scroll region and mouse bytes,
+ * and gu's readline would keep reading the keys meant for the editor. Everything is switched off
+ * first and switched back on — and the view repainted from the transcript — whatever happens.
+ */
+function withTerminalHandedOver(run) {
+  const wasPinned = barPinned();
+  const hadClick = _clickEnabled;
+  disableMouse();
+  disableClickToPosition();
+  ui(PASTE_MODE_OFF);
+  unpinBar();
+  const wasRaw = Boolean(process.stdin.isRaw);
+  try {
+    process.stdin.setRawMode?.(false);
+  } catch {
+    /* not a TTY — nothing to switch */
+  }
+  rl.pause();
+  try {
+    return run();
+  } finally {
+    try {
+      process.stdin.setRawMode?.(wasRaw);
+    } catch {
+      /* not a TTY */
+    }
+    rl.resume();
+    ui(PASTE_MODE_ON);
+    if (hadClick) enableClickToPosition();
+    if (wasPinned) {
+      ui("\x1b[2J");
+      pinBar();
+      paintLiveTail();
+    }
+  }
+}
+
+/**
+ * /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.
  */
 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();
+  const usage = "usage: /save-preset <name>  (opens your editor)   or   /save-preset <name> {\"apiUrl\":\"…\",\"apiKey\":\"…\",\"agentModel\":\"…\",\"codingModel\":\"…\",\"embedModel\":\"…\"}";
+  let rest = line.trim().slice("/save-preset".length).trim().replace(/(^|\s)--edit(?=\s|$)/, " ").trim();
   if (!rest) {
-    console.log(GUTTER + usage);
-    console.log("");
-    return;
+    const typed = String((await ask("preset name: ")) ?? "").trim();
+    if (!typed) {
+      console.log(GUTTER + dim("cancelled — nothing saved.") + "\n");
+      return;
+    }
+    rest = typed;
   }
   const space = rest.search(/\s/);
   const name = space === -1 ? rest : rest.slice(0, space);
@@ -6739,22 +6800,68 @@ async function runSavePresetCommand(line) {
     console.log("");
     return;
   }
-  if (!json) {
-    console.log(GUTTER + "the JSON is missing — " + usage);
+  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("");
+  };
+  if (json) {
+    const checked = pr.validatePreset(json);
+    if (!checked.ok) {
+      console.log(GUTTER + `Preset not saved — ${checked.problem}`);
+      console.log("");
+      return;
+    }
+    store(checked.preset);
     return;
   }
-  const checked = pr.validatePreset(json);
-  if (!checked.ok) {
-    console.log(GUTTER + `Preset not saved — ${checked.problem}`);
+
+  // THE EDITOR. Filled in from the preset being edited, else from what this account runs now.
+  const ed = await import("./preset-editor.mjs");
+  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("");
     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("");
+  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 = 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.`));
+  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("");
+      return;
+    }
+    if (r.text === initial) {
+      console.log(GUTTER + dim("Not saved — nothing changed.") + "\n");
+      return;
+    }
+    const parsed = ed.parseEdited(r.text);
+    if (parsed.ok) {
+      store(parsed.preset);
+      return;
+    }
+    console.log(GUTTER + yellow(`Not saved yet — ${parsed.problem}`));
+    if (!(await askYesNo("Edit again?", true))) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    text = r.text; // their text, with the mistake in it — not the template again
+  }
 }
 
 /**
@@ -6887,26 +6994,61 @@ async function runLoadPresetsCommand(line) {
       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));
     if (found.length === 0) {
-      console.log(GUTTER + `no presets in ${home} — save one with /save-preset <name> {…}`);
+      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(dim(`  Presets in ${home}  (${ed.PICKER_HINT}):`));
+    const pick = await pickFromList(found, 0, { keys: ed.PICKER_KEYS });
+    if (!pick || pick.index < 0) {
       console.log(GUTTER + "load cancelled.");
       console.log("");
       return;
     }
-    file = pr.presetFilePath(found[pick], home);
+    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];
+      const command = ed.presetCopyCommand(pname, shown.preset);
+      if (pick.action === "view") {
+        const block = ed.presetBlock(pname, shown.preset, { 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(`/load-presets ${pname} applies it.`));
+        console.log("");
+        return;
+      }
+      const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(shown.preset) : 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;
+    }
   }
   const checked = pr.validatePresetFile(readFileSync(file, "utf8"));
   if (!checked.ok) {
@@ -9148,6 +9290,10 @@ let listAllowDelete = false;
 // Set by the ctrl+d branch and read by finishList, so the resolved value can say WHICH action
 // 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.
+let listKeys = null;
+let listKeyAction = "";
 function drawList(redraw) {
   // Gutter (task #128 Phase 2): inset each row after its line-clear. Clipped to width-1 like
   // every other in-place block: a long item (a model id on a narrow terminal) that wrapped
@@ -9210,6 +9356,10 @@ function finishList(index) {
   const deleting = listDeleteRequested;
   listAllowDelete = false;
   listDeleteRequested = false;
+  const keyed = listKeys;
+  const keyAction = listKeyAction;
+  listKeys = null;
+  listKeyAction = "";
   // Multi-select resolves with the TICKED indices — and with null, not [], when cancelled: an
   // empty selection is a legitimate answer ("offer none of them"), so it must be distinguishable
   // from Escape, or cancelling would silently save "none".
@@ -9223,7 +9373,9 @@ function finishList(index) {
           : checked
         : allowDelete
           ? { index, action: index >= 0 && deleting ? "delete" : "select" }
-          : index
+          : keyed
+            ? { index, action: index >= 0 ? keyAction || "select" : "cancel" }
+            : index
     );
   }
 }
@@ -9278,6 +9430,9 @@ function onListKey(key) {
     // Enter still selects; nothing about the ordinary path changes.
     listDeleteRequested = true;
     finishList(listSel);
+  } else if (listKeys && !listMulti && !key.ctrl && !key.meta && key.name && Object.hasOwn(listKeys, key.name)) {
+    listKeyAction = listKeys[key.name];
+    finishList(listSel);
   } else if (key.name === "return" || key.name === "enter") {
     finishList(listSel);
   } else if (key.name === "escape" || (key.ctrl && key.name === "c")) {
@@ -9322,6 +9477,8 @@ function pickFromList(items, initialSel = 0, opts = {}) {
     listMulti = false; // explicit: a cancelled multi-select must not leak its mode into this one
     listAllowDelete = opts.allowDelete === true;
     listDeleteRequested = false;
+    listKeys = opts.keys && typeof opts.keys === "object" ? opts.keys : null;
+    listKeyAction = "";
     listChecked = new Set();
     listItems = items;
     listTop = 0;
@@ -9759,26 +9916,20 @@ async function ensureTokenForTurn() {
   const state = await ct.readState(dir);
   if (!ct.turnNeedsToken({ privateMode: true, token: state.token })) return true;
   console.log("");
-  // #305: the free trial first — a first start that was offline gets it here, with no question.
-  if (await tryTrialToken(ct, dir)) {
+  // #305: the question, with this computer's free trial as the default — offered, never taken
+  // silently (the user's rule). Enter takes the trial; a pasted token replaces it.
+  const { DEFAULT_API_BASE } = await import("./device-login.mjs");
+  const r = await ct.promptForToken({
+    ask: (label, opts) => ask("  " + label, opts),
+    dir,
+    hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
+    log: (l, kind) =>
+      console.log(GUTTER + (kind === "title" ? yellow(l) : kind === "ok" ? accent(l) : kind === "warn" ? yellow(l) : dim(l))),
+  });
+  if (r.ok) {
     console.log("");
     return true;
   }
-  if (trialEndedAt) console.log(GUTTER + dim(`The free trial on this computer ended on ${ct.shortDate(trialEndedAt)}.`));
-  for (const l of ct.tokenAskLines()) console.log(GUTTER + (l.startsWith("  ") ? dim(l) : yellow(l)));
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const pasted = String((await ask("  gu token: ")) ?? "").trim();
-    if (!pasted) {
-      console.log(GUTTER + dim("Not sent. Run `gu token <paste>` any time, then send your message again.") + "\n");
-      return false;
-    }
-    const saved = await ct.saveTokenFromPaste(dir, pasted);
-    if (saved.ok) {
-      console.log(GUTTER + accent("✓ token saved") + dim(" — it renews itself from now on.") + "\n");
-      return true;
-    }
-    console.log(GUTTER + yellow(`That token was not saved: ${saved.reason}.`));
-  }
   console.log(GUTTER + dim("Not sent. Run `gu token <paste>` any time, then send your message again.") + "\n");
   return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.773",
+  "version": "1.0.775",
   "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",
@@ -65,6 +65,7 @@
     "credential-recovery.mjs",
     "settings-transfer.mjs",
     "presets-transfer.mjs",
+    "preset-editor.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",

package/preset-editor.mjs

@@ -0,0 +1,187 @@
+/**
+ * PRESETS IN A REAL EDITOR, AND OUT AGAIN AS TEXT (#312).
+ *
+ * Asked for: "it doesn't allow to input the presets as a text editor, we need to allow with
+ * something like sudo nano … and for load-preset should load all as a long text somehow so that
+ * I can copy with a copy button or icon".
+ *
+ *   · /save-preset <name> opens the person's own editor ($VISUAL, $EDITOR, then nano, then vi;
+ *     Notepad on Windows) on a temp file already filled in — the current setup, or the preset
+ *     being edited — so it is edited rather than typed from nothing. NOT sudo: the preset is the
+ *     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
+ *     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.
+ *
+ * Pure helpers plus one spawn; the terminal hand-over (unpinning gu's frozen zone, raw mode, the
+ * mouse) is the REPL's job, because only the REPL knows what it switched on.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { validatePreset } from "./presets-transfer.mjs";
+
+const clean = (v) => (typeof v === "string" ? v.trim() : "");
+
+/**
+ * Which editor to run → { cmd, args }. $VISUAL then $EDITOR (either may carry arguments, e.g.
+ * "code --wait"), then the first of nano / vi that exists; Notepad on Windows, which blocks until
+ * its window closes. `has(cmd)` says whether a program is on PATH (injected for tests).
+ */
+export function pickEditor({ env = process.env, platform = process.platform, has = onPath } = {}) {
+  for (const v of [env.VISUAL, env.EDITOR]) {
+    const words = splitCommand(v);
+    if (words.length) return { cmd: words[0], args: words.slice(1) };
+  }
+  if (platform === "win32") return { cmd: "notepad", args: [] };
+  for (const cmd of ["nano", "vi"]) if (has(cmd)) return { cmd, args: [] };
+  return null;
+}
+
+/** "code --wait" → ["code", "--wait"]; quotes group ("'/Applications/My Editor' -w"). */
+export function splitCommand(s) {
+  const out = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(String(s ?? "")))) out.push(m[1] ?? m[2] ?? m[3]);
+  return out;
+}
+
+function onPath(cmd) {
+  const probe = process.platform === "win32" ? spawnSync("where", [cmd]) : spawnSync("/bin/sh", ["-c", `command -v ${cmd}`]);
+  return probe.status === 0;
+}
+
+/**
+ * The preset as it would be in a preset file, from whatever is set on this account now. The key
+ * is never known here (the API keeps it), so it is left empty for the person to fill in.
+ */
+export function presetFromSettings(settings = {}) {
+  const rows = Array.isArray(settings.agentCodingBackends) ? settings.agentCodingBackends : [];
+  const agentUrl = clean(settings.agentModelUrl);
+  const norm = (u) => clean(u).replace(/\/+$/, "").toLowerCase();
+  const row = rows.find((r) => agentUrl && norm(r?.url) === norm(agentUrl)) ?? rows.find((r) => r?.enabled !== false) ?? rows[0] ?? {};
+  const apiUrl = agentUrl || clean(row.url);
+  return {
+    apiUrl,
+    apiKey: "",
+    agentModel: clean(settings.agentModelName),
+    codingModel: clean(row.defaultModel),
+    embedModel: clean(settings.ragEmbedModel),
+    embedUrl: clean(settings.ragEmbedUrl) || apiUrl,
+  };
+}
+
+const FIELDS = ["apiUrl", "apiKey", "agentModel", "codingModel", "embedModel", "embedUrl"];
+
+/** The text the editor opens with: a few `//` lines saying what to do, then the JSON. */
+export function editorText(name, preset = {}) {
+  const body = {};
+  for (const f of FIELDS) body[f] = clean(preset[f]);
+  return (
+    [
+      `// gu preset "${name}" — edit the values, then save and quit to store it.`,
+      "// Every field is needed except embedUrl (it defaults to apiUrl). Lines starting with // are ignored.",
+      "// Quit without saving (or leave it unchanged) to cancel. The file you save CONTAINS your API key.",
+    ].join("\n") +
+    "\n" +
+    JSON.stringify(body, null, 2) +
+    "\n"
+  );
+}
+
+/**
+ * What came back from the editor → { ok, preset } | { ok: false, problem }. The // lines are
+ * 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, "");
+  if (!src.trim()) return { ok: false, empty: true, problem: "the file is empty." };
+  try {
+    JSON.parse(src);
+  } catch (e) {
+    const at = /line (\d+) column (\d+)/.exec(String(e?.message ?? ""));
+    const where = at ? ` (line ${at[1]}, column ${at[2]})` : "";
+    return { ok: false, problem: `that is not valid JSON${where} — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$|\s*\(line \d+ column \d+\)/g, "")}.` };
+  }
+  return validatePreset(src);
+}
+
+/**
+ * Open `initial` in `editor` and return what was saved: { ok: true, text } | { ok: false, why }.
+ * The temp file is 0600 in a 0700 directory, and the directory is removed whatever happens.
+ * `run` is spawnSync with the terminal inherited (injected for tests).
+ */
+export function editText(initial, { editor, run = spawnSync, tmpRoot = tmpdir(), fileName = "gu-preset.json" } = {}) {
+  if (!editor) return { ok: false, why: "no editor found — set $EDITOR (e.g. export EDITOR=nano)" };
+  const dir = mkdtempSync(join(tmpRoot, "gu-preset-"));
+  try {
+    chmodSync(dir, 0o700);
+    const file = join(dir, fileName);
+    writeFileSync(file, initial, { mode: 0o600 });
+    const r = run(editor.cmd, [...editor.args, file], { stdio: "inherit" });
+    if (r?.error) return { ok: false, why: `${editor.cmd} could not start — ${r.error.message}` };
+    if (typeof r?.status === "number" && r.status !== 0) return { ok: false, why: `${editor.cmd} exited with status ${r.status} — nothing saved` };
+    return { ok: true, text: readFileSync(file, "utf8") };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** A key as it may appear on screen: its first few and last four characters. */
+export function maskKey(key) {
+  const k = clean(key);
+  if (!k) return "";
+  if (k.length <= 8) return "…" + k.slice(-2);
+  const head = k.startsWith("sk-") ? "sk-" : k.slice(0, 3);
+  return `${head}…${k.slice(-4)}`;
+}
+
+const presetBody = (preset) => {
+  const o = {};
+  for (const f of FIELDS) if (f !== "embedUrl" || clean(preset.embedUrl) !== clean(preset.apiUrl)) o[f] = clean(preset[f]);
+  return o;
+};
+
+/** What "copy" puts on the clipboard: the command that recreates the preset — WITH the key. */
+export function presetCopyCommand(name, preset) {
+  return `/save-preset ${clean(name)} ${JSON.stringify(presetBody(preset))}`;
+}
+
+/** …or just the JSON, pretty, WITH the key. */
+export function presetCopyJson(preset) {
+  return JSON.stringify(presetBody(preset), null, 2);
+}
+
+/**
+ * The framed block /load-presets 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.
+ */
+export function presetBlock(name, preset, { width = 80, gutter = "   " } = {}) {
+  const shown = { ...presetBody(preset), apiKey: maskKey(preset.apiKey) };
+  const inner = JSON.stringify(shown, null, 2).split("\n");
+  const room = Math.max(24, width - 1 - gutter.length);
+  const innerW = Math.min(room - 4, Math.max(...inner.map((l) => [...l].length), 30));
+  const fit = (l) => {
+    const cs = [...l];
+    return cs.length > innerW ? cs.slice(0, innerW - 1).join("") + "…" : l + " ".repeat(innerW - cs.length);
+  };
+  const title = `┌ preset "${clean(name)}" `;
+  const copy = " ⧉ copy ";
+  const dashes = Math.max(1, innerW + 4 - [...title].length - [...copy].length - 1);
+  const top = `${title}${"─".repeat(dashes)}${copy}┐`;
+  const buttonFrom = gutter.length + [...title].length + dashes;
+  return {
+    rows: [top, ...inner.map((l) => `│ ${fit(l)} │`), `└${"─".repeat(innerW + 2)}┘`].map((r) => gutter + r),
+    button: { from: buttonFrom, to: buttonFrom + [...copy].length },
+  };
+}
+
+/** 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" };
+export const PICKER_HINT = "↑↓ · Enter apply · v view · c copy command · j copy JSON · e edit · Esc back";

package/setup-prompts.mjs

@@ -16,23 +16,39 @@
  * the one stretch of the program that runs before it.
  */
 import { SKIP_ALL, isEscapeKey } from "./model-setup-ui.mjs";
+import { footerDrawSeq, visibleLen, hintRows } from "./terminal-layout.mjs";
 
 /**
  * One question on `rl`. Options: `secret` (mask + keep out of history), `esc` (Esc → SKIP_ALL).
- * `style` decorates the label (the accent colour). Resolves with the answer string, or SKIP_ALL.
+ * `style` decorates the label (the accent colour). `prefill` is typed into the input for the
+ * person to take with Enter or delete (#305); `hint` is lines drawn in yellow UNDER the input,
+ * word-wrapped to one physical row each (terminal-layout hintRows), and wiped once answered.
+ * Resolves with the answer string, or SKIP_ALL.
  */
-export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, input = process.stdin, output = process.stdout } = {}) {
+export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, prefill = "", hint = [], input = process.stdin, output = process.stdout } = {}) {
   return new Promise((resolve) => {
     const shown = style(q);
     const ac = new AbortController();
     const origWrite = rl._writeToOutput;
     const origRefresh = rl._refreshLine;
     let done = false;
+    const showHint = !secret && hint.length > 0 && output.isTTY;
+    // Drawn below the input's LAST row with relative moves (footerDrawSeq), so it survives the
+    // terminal scrolling; redrawn after every key because readline clears below on a refresh.
+    const drawHint = () => {
+      const cols = Math.max(20, output.columns || 80);
+      const pos = rl.getCursorPos?.() ?? { rows: 0, cols: 0 };
+      const inputRows = Math.floor((visibleLen(shown) + String(rl.line ?? "").length) / cols) + 1;
+      const rows = hintRows(hint, { width: cols, gutter: "  ", paint: (t) => `\x1b[33m${t}\x1b[0m` });
+      output.write(footerDrawSeq({ rows, caretRows: pos.rows, caretCols: pos.cols, inputRows }));
+    };
 
     const finish = (value) => {
       if (done) return;
       done = true;
       input.removeListener?.("keypress", onKey);
+      // Enter left the caret on the first hint row: the hint goes with the question.
+      if (showHint && value !== SKIP_ALL) output.write("\r\x1b[J");
       if (secret) {
         rl._writeToOutput = origWrite;
         rl._refreshLine = origRefresh;
@@ -60,11 +76,14 @@ export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, in
       if (secret && output.isTTY) {
         output.write(`\r\x1b[2K${shown}${"•".repeat(String(rl.line ?? "").length)}`);
       }
+      if (showHint) drawHint();
     }
 
     input.on?.("keypress", onKey);
     // question() draws the label synchronously — mute only AFTER, or the label is muted too.
     rl.question(shown, { signal: ac.signal }, (a) => finish(String(a ?? "")));
+    if (prefill && !secret) rl.write(String(prefill));
+    if (showHint) drawHint();
     if (secret) {
       rl._writeToOutput = () => {};
       rl._refreshLine = () => {};

package/terminal-layout.mjs

@@ -2788,3 +2788,27 @@ export function slashMenuWindow(total, sel, top, rows = SLASH_MENU_ROWS) {
   const w = listWindow(n, sel < 0 ? 0 : sel, sel < 0 ? 0 : top, rows + 2);
   return { from: w.from, to: w.to, above: w.above, below: w.below, top: w.top };
 }
+
+/**
+ * A QUESTION'S HINT, drawn UNDER the input (#305: the trial token's "this is a trial — get a free
+ * token for 1 computer, or Pro for more" sits under the token it describes). Word-wrapped so every
+ * row is ONE physical row — a wrapped row corrupts every redraw that counts rows (#109/#132/#138).
+ * A word longer than the row is hard-cut rather than allowed to wrap.
+ */
+export function hintRows(lines, { width, gutter = "   ", paint = (s) => s } = {}) {
+  const room = Math.max(10, Math.max(20, width || 80) - 1 - visibleLen(gutter));
+  const out = [];
+  for (const line of lines ?? []) {
+    let row = "";
+    for (const word of String(line).split(/\s+/).filter(Boolean)) {
+      const next = row ? `${row} ${word}` : word;
+      if (visibleLen(next) <= room) row = next;
+      else {
+        if (row) out.push(row);
+        row = visibleLen(word) > room ? clipVisible(word, room) : word;
+      }
+    }
+    if (row) out.push(row);
+  }
+  return out.map((r) => gutter + paint(r));
+}