@tiens.nguyen/gu-cli 1.0.893 → 1.0.895

package/python-windows.mjs

@@ -0,0 +1,91 @@
+/**
+ * PYTHON ON A NEW WINDOWS 11 (GH #363).
+ *
+ * A brand-new Windows 11 has no Python, and gu's agent runs on it. gu used to say "Install Python 3 — winget …"
+ * and then carry on through a long database setup that ended in a broken agent. Like the installer does for
+ * Node, gu now offers to do it: the official python.org installer, for THIS USER only (no administrator, no
+ * system-wide change), after checking that the file is signed by the Python Software Foundation.
+ *
+ * Pure parts (URL, folders, the PowerShell script) are separate; the net and the machine are injected so tests
+ * never download or install anything.
+ */
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+
+// Bump on purpose. 3.12 has prebuilt wheels for everything gu installs (see PYTHON_WHEELS_MAX).
+export const PYTHON_WIN_VERSION = "3.12.8";
+
+export function pythonWinInstallerUrl(version = PYTHON_WIN_VERSION) {
+  return `https://www.python.org/ftp/python/${version}/python-${version}-amd64.exe`;
+}
+
+/** Where a per-user install lands: %LOCALAPPDATA%\Programs\Python\Python312, its Scripts, and the `py` launcher. */
+export function pythonWinFolders(version = PYTHON_WIN_VERSION, localAppData = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local")) {
+  const [maj, min] = version.split(".");
+  const root = join(localAppData, "Programs", "Python", `Python${maj}${min}`);
+  return [root, join(root, "Scripts"), join(localAppData, "Programs", "Python", "Launcher")];
+}
+
+/** Put the new folders on THIS process's PATH: the installer only edits the saved PATH, which only new terminals read. */
+export function withPythonOnPath(pathValue, folders) {
+  const have = String(pathValue ?? "").split(";").map((p) => p.trim().toLowerCase());
+  const add = folders.filter((f) => !have.includes(f.toLowerCase()));
+  return add.length ? add.join(";") + ";" + String(pathValue ?? "") : String(pathValue ?? "");
+}
+
+/** The PowerShell that checks the signature, then installs quietly for the current user. Exit 90 = not signed by the PSF. */
+export function pythonInstallScript(file) {
+  const f = file.replace(/'/g, "''");
+  return [
+    `$f = '${f}'`,
+    `$s = Get-AuthenticodeSignature -FilePath $f`,
+    `if ($s.Status -ne 'Valid' -or "$($s.SignerCertificate.Subject)" -notmatch 'Python Software Foundation') { exit 90 }`,
+    `$p = Start-Process -FilePath $f -ArgumentList '/quiet','InstallAllUsers=0','PrependPath=1','Include_launcher=1','Include_test=0' -Wait -PassThru`,
+    `exit $p.ExitCode`,
+  ].join("; ");
+}
+
+/**
+ * The environment for the Python installer: the REAL profile. A test (or anyone) may point USERPROFILE/HOME at a scratch
+ * folder; the installer then fails with 0x80070003 ("path not found"). LOCALAPPDATA still names the real profile
+ * (<profile>\\AppData\\Local), so the profile is derived from it. Pure.
+ */
+export function pythonInstallerEnv(env = process.env) {
+  const out = { ...env };
+  const m = /^(.*)[\\/]AppData[\\/]Local[\\/]?$/i.exec(String(env.LOCALAPPDATA ?? ""));
+  if (m && m[1]) {
+    out.USERPROFILE = m[1];
+    out.HOME = m[1];
+  }
+  return out;
+}
+
+/**
+ * Download, verify, install. → { ok, folders?, error? }. `fetchFn` and `run` (file → { code }) are injectable.
+ * On success the process PATH is updated so the very next `py -3` in this run finds it.
+ */
+export async function installPythonWindows({ dir = join(homedir(), ".gonext"), version = PYTHON_WIN_VERSION, fetchFn = fetch, run = null, env = process.env } = {}) {
+  const file = join(dir, `python-${version}-amd64.exe`);
+  try {
+    await mkdir(dir, { recursive: true });
+    const res = await fetchFn(pythonWinInstallerUrl(version), { redirect: "follow" });
+    if (!res.ok) return { ok: false, error: `download failed (HTTP ${res.status})` };
+    await writeFile(file, Buffer.from(await res.arrayBuffer()));
+  } catch (e) {
+    return { ok: false, error: `download failed: ${e?.message ?? e}` };
+  }
+  const runner = run ?? ((f) => new Promise((resolve) => {
+    execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", pythonInstallScript(f)], { windowsHide: true, timeout: 900000, env: pythonInstallerEnv(env) }, (err) => {
+      resolve({ code: err ? (typeof err.code === "number" ? err.code : null) : 0 });
+    });
+  }));
+  const r = await runner(file);
+  await rm(file, { force: true }).catch(() => {});
+  if (r.code === 90) return { ok: false, error: "the downloaded file is not signed by the Python Software Foundation, so it was NOT installed" };
+  if (r.code !== 0) return { ok: false, error: `the Python installer stopped with code ${r.code}` };
+  const folders = pythonWinFolders(version, env.LOCALAPPDATA || undefined);
+  env.Path !== undefined ? (env.Path = withPythonOnPath(env.Path, folders)) : (env.PATH = withPythonOnPath(env.PATH, folders));
+  return { ok: true, folders };
+}

package/quick-models.mjs

@@ -55,9 +55,9 @@ export function quickWarning(quick, activeId, { width = 80, gutter = "   " } = {
   const q = normalizeQuick(quick);
   if (q.length === 0 || isQuickActive(q, activeId)) return "";
   const full = q.length === QUICK_MAX
-    ? `⚠ not on a quick model — ← → goes to ${q[0].model} · /quick-models`
-    : "⚠ not on your quick model · pick 2 with /quick-models to use ← →";
-  const short = "⚠ not on a quick model · /quick-models";
+    ? `not on a quick model — ← → goes to ${q[0].model} · /quick-models`
+    : "not on your quick model · pick 2 with /quick-models to use ← →";
+  const short = "not on a quick model · /quick-models";
   const room = Math.max(8, (width || 80) - 1 - gutter.length);
   const pick = full.length <= room ? full : short;
   return pick.length <= room ? pick : pick.slice(0, Math.max(1, room - 1)) + "…";

package/terminal-layout.mjs

@@ -451,9 +451,16 @@ export function promptBreakdownRows(b) {
 export function createMouseKeyWindow({ maxRun = 24 } = {}) {
   let run = 0;
   let current = false;
+  let prev = ""; // the previous key's text, for the split shape below
   return {
     track(str, key) {
-      if (key?.code === "[<") {
+      const text = typeof str === "string" ? str : "";
+      // The joined shape ("[<" as one key) — or the SPLIT one (GH #365): an Esc node timed out
+      // on, then "[" and "<" as ordinary characters. The "[" has already gone by as a key by
+      // then; the run starts at the "<".
+      const split = text === "<" && prev === "[";
+      prev = key?.code === "[<" ? "" : text;
+      if (key?.code === "[<" || (split && !run)) {
         run = 1;
         return (current = true);
       }
@@ -466,6 +473,100 @@ export function createMouseKeyWindow({ maxRun = 24 } = {}) {
   };
 }
 
+/**
+ * KEEP EVERY SHAPE OF A MOUSE REPORT OUT OF THE LINE (GH #365).
+ *
+ * The input filter used to recognise a report only by node's key code "[<" — the shape node
+ * produces when `ESC [ <` arrives together. When the event loop stalls for longer than
+ * readline's escape timeout (500ms) with an ESC at the end of a read, node gives the ESC up as a
+ * lone Esc key and the rest comes through as ORDINARY characters: "[", "<", "35;114;22M". Every
+ * one of those was typed into the line. Reported on Windows 11 after minimising and restoring
+ * the window (a full repaint, and Windows console writes block), then more with every hover,
+ * because the prompt reports mouse motion.
+ *
+ * Shapes, all consumed whole:
+ *     key "[<", then "35;114;22M"           ← the usual one
+ *     Esc, "[", "<", "35;114;22M"           ← the ESC timed out
+ *     "[", "<", "35;114;22M"                ← the Esc went elsewhere (plainLeads only)
+ *     "^", "[", "[", "<", …                 ← ESC spelled in caret notation (plainLeads only)
+ *
+ * Like createProbeReplyReader it holds anything that still fits the grammar and REPLAYS it
+ * verbatim the moment something does not, so a keystroke is delayed, never lost. A plain "[" or
+ * "^" is only held while the terminal is reporting the mouse (`plainLeads`), so typing them is
+ * not slowed down otherwise.
+ */
+const MOUSE_LEADS = ["\x1b[<", "^[[<", "[<"];
+const MOUSE_BODY_DONE = /^(\d+;\d+;\d+[Mm])$/;
+const MOUSE_BODY_PART = /^\d*(?:;\d*){0,2}$/;
+function mouseTextVerdict(text, plainLeads) {
+  for (const lead of MOUSE_LEADS) {
+    if (!plainLeads && lead !== "\x1b[<") continue;
+    if (lead.startsWith(text)) return { kind: "partial" };
+    if (!text.startsWith(lead)) continue;
+    const body = text.slice(lead.length);
+    if (MOUSE_BODY_DONE.test(body)) return { kind: "done", report: body };
+    if (body.length <= 20 && MOUSE_BODY_PART.test(body)) return { kind: "partial" };
+  }
+  return { kind: "bad" };
+}
+export function createMouseReportReader() {
+  let held = null; // [str, key] pairs
+  const textOf = (str, key) =>
+    key?.code === "[<" ? "\x1b[<" : key?.name === "escape" ? "\x1b" : typeof str === "string" ? str : "";
+  const startsOne = (str, key, plainLeads) =>
+    key?.code === "[<" || key?.name === "escape" || (plainLeads && (str === "[" || str === "^"));
+  return {
+    holding: () => held !== null,
+    /**
+     * Feed one keypress. `plainLeads`: the terminal is reporting the mouse right now.
+     *   { action: "pass" }                        — not ours; carry on
+     *   { action: "hold" }                        — may be a report; arm the flush timer
+     *   { action: "consume", report }             — a whole report, e.g. "35;114;22M"
+     *   { action: "replay", keys, hold? }         — not a report: replay `keys`; when `hold` is
+     *                                               set, the last key began a new candidate and
+     *                                               is still held
+     */
+    feed(str, key, { plainLeads = false } = {}) {
+      if (!held) {
+        if (!startsOne(str, key, plainLeads)) return { action: "pass" };
+        held = [[str, key]];
+        const v = mouseTextVerdict(textOf(str, key), plainLeads);
+        if (v.kind === "partial") return { action: "hold" };
+        held = null;
+        return { action: "pass" };
+      }
+      held.push([str, key]);
+      const text = held.map(([s, k]) => textOf(s, k)).join("");
+      const v = mouseTextVerdict(text, plainLeads);
+      if (v.kind === "done") {
+        held = null;
+        return { action: "consume", report: v.report };
+      }
+      if (v.kind === "partial") return { action: "hold" };
+      // Not a report. If the key that broke it could START one ("[" after "[", an Esc), keep it.
+      const last = held.pop();
+      const keys = held;
+      held = null;
+      if (startsOne(last[0], last[1], plainLeads) && mouseTextVerdict(textOf(last[0], last[1]), plainLeads).kind === "partial") {
+        held = [last];
+        return { action: "replay", keys, hold: true };
+      }
+      return { action: "replay", keys: [...keys, last] };
+    },
+    /** Timer fired: hand back whatever is still held. */
+    flush() {
+      const keys = held ?? [];
+      held = null;
+      return keys;
+    },
+  };
+}
+
+/** Last line of defence at submit: a report that got past every reader is not a question. */
+export function stripLeakedMouseReports(line) {
+  return String(line).replace(/(?:\x1b|\^\[)?\[<\d+;\d+;\d+[Mm]/g, "");
+}
+
 /**
  * A failed turn's message, as something a person can act on.
  *
@@ -1152,6 +1253,16 @@ export function syncPrevRowsForResize(rl) {
 // signature — a tool's own line never contains it.
 export const isToolStepSummary = (line) => / \| → /.test(line);
 
+/**
+ * A WARNING STEP (GH #378). The agent marks one with a leading "⚠" ("⚠ RAG unavailable …").
+ * The terminal shows it as yellow text with NO icon: Windows 11 terminals draw "⚠" as a wide
+ * colour emoji, which broke the row and looked amateur next to the plain marks. The "⚠" stays
+ * in the protocol (it is how a warning is recognised, and the web app shows it); only the
+ * terminal drops it, here.
+ */
+export const WARN_MARK_RE = /^\s*⚠\uFE0F?\s*/;
+export const stripWarnMark = (text) => String(text ?? "").replace(WARN_MARK_RE, "");
+
 // Glyph vocabulary for an action line: a FAILURE pops (✗, full-bright), a completed
 // action recedes (✓, dim), anything else is neutral (●, dim). Returns the KIND only —
 // the REPL owns the colours, so this stays pure and testable.
@@ -1201,6 +1312,7 @@ export function isSoftFailCommand(cmd) {
 }
 
 export function bulletKind(text) {
+  if (WARN_MARK_RE.test(String(text ?? ""))) return "warn";
   const mFail = /^Command failed → (.+)$/.exec(String(text ?? "").trim());
   if (mFail && isSoftFailCommand(mFail[1])) return "soft";
   if (/\bfail(ed|s|ure)?\b|\berror(ed)?\b|→\s*(?:HTTP\s*)?[45]\d\d\b/i.test(text)) return "fail";
@@ -2725,7 +2837,7 @@ export function identityRow(
   const where = String(folder ?? "").trim();
   // The mark only means anything beside a named coder: with none shown there is nothing for it
   // to be about, and it would read as a fault in the folder.
-  const mark = name && keyUnchosen ? red(" ⚠ key not chosen") : "";
+  const mark = name && keyUnchosen ? red(" key not chosen") : "";
   // API key tail: show the last 4 characters of the API key when available (e.g., "| abcd")
   const keyIndicator = apiKeyTail ? dim(" | ") + dim(apiKeyTail) : "";
   return (name ? orange(name) + mark + keyIndicator + dim(" | ") : "") + cyan(where);

package/theme.mjs

@@ -7,8 +7,13 @@
  *   Windows (win32) with no TERM/COLORTERM/WT_SESSION       -> ask stdout.getColorDepth()
  *     (conhost on Windows 11 supports 24-bit but advertises nothing).
  *
- * Variants: GU_THEME=dark (default) | light | mono.  GU_ASCII=1 swaps the "⏺" glyph for "*"
- * (older Windows console fonts lack U+23FA).
+ * Variants: GU_THEME=dark (default) | light | mono.
+ *
+ * NO ICON BEFORE A CARD (GH #378). The header was "⏺ Update(path)"; Windows 11 terminals draw "⏺"
+ * as a wide colour emoji, which broke the row and looked amateur. The coloured verb — green
+ * Create, yellow Update, red Delete — already says what happened, so the glyph is a space that
+ * keeps the text column, on every platform. ("⏺" is still the line protocol from
+ * gonext_agent_chat.py: it is how a header is RECOGNISED, never what is drawn.)
  *
  * Rules every caller relies on:
  *  - background tiers fill a row by PADDING SPACES (measured with visibleLen), never ESC[K,
@@ -102,7 +107,8 @@ const EMPTY_SIGN = { row: "", sign: "", signOff: "", wordOn: "", wordOff: "" };
 
 /** Every escape sequence the edit card uses, for one tier + variant. "" = nothing to emit. */
 export function makeTheme(tier = "16", variant = "dark", { ascii = false, syntax = false } = {}) {
-  const glyph = ascii ? "*" : "⏺";
+  void ascii; // GU_ASCII used to swap "⏺" for "*"; nothing is drawn now (GH #378)
+  const glyph = " ";
   if (tier === "none") {
     return {
       tier, variant, glyph, fill: false, reset: "", lineNo: "", lineNoOff: "", grey: "",