@tiens.nguyen/gu-cli 1.0.895 → 1.0.896

package/README.md

@@ -188,7 +188,7 @@ gu fix-path | fix-powershell   repair PATH / remove PowerShell's `gu` alias
 | --- | --- | --- |
 | **Free trial** | 30 days, from the first run | nothing: the token is created for you |
 | **Free plan** | 3 more months on that computer | a free account at [gucli.com](https://gucli.com) |
-| **Pro** | **$4 a month** or **$40 a year** (+ VAT where it applies) | hosted models (no model server to run), up to 5 computers, provider budgets |
+| **Pro** | **$4 a month** or **$40 a year** (+ VAT where it applies) | hosted models (no model server to run), any number of computers, provider budgets |
 
 On Pro, the hosted models and the hosted API run on gu's servers, so the prompts and code you
 send through them go there. A free install keeps everything on your computer.

package/cli-token.mjs

@@ -622,7 +622,8 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     // SHORT AND CALM (#292: "make it simpler … seems so serious"): the fact, then the one thing to
     // do. `urgent` is what the bar colours by — only these two need the user to act.
     if (ended) return { kind: "plan-ended", urgent: true, text: `Pro ended ${shortDate(p.paidUntil)} · renew at ${pricingUrl}` };
-    if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
+    // Pro has no computer limit (GH #371): an over-limit line is for the other plans only.
+    if (p.plan !== "pro" && Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
       return {
         kind: "over-limit",
         urgent: true,
@@ -728,7 +729,10 @@ export function tokenSummary(payload, now = new Date()) {
   }
   if (Number.isInteger(payload.activeDevices)) {
     const n = payload.activeDevices;
-    lines.push(`Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
+    const paidPro = payload.plan === "pro" && payload.paidUntil && Date.parse(payload.paidUntil) > now.getTime();
+    lines.push(paidPro
+      ? `Used on ${computers(n)} in the last 30 days — Pro has no computer limit.`
+      : `Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
   }
   lines.push(`Issued ${shortDate(payload.issuedAt)}.`);
   return lines;
@@ -827,7 +831,8 @@ export function enforcementDecision({ token, publicKeyB64, now = new Date(), sit
       );
     }
   }
-  if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
+  // PRO HAS NO COMPUTER LIMIT (GH #371) — not even with a token from a server that still sends a count.
+  if (!paid && Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
     return {
       enforced: true,
       allowed: false,

package/gonext_agent_chat.py

@@ -6569,17 +6569,24 @@ def _rg_binary(env=None):
     """The ripgrep to use, or "" for none. GU_RG=0 turns it off; GU_RG=<path> picks one; then PATH,
     then gu's own copy in ~/.gonext/bin."""
     import os
-    import shutil
     env = os.environ if env is None else env
     want = (env.get("GU_RG") or "").strip()
     if want.lower() in ("0", "off", "false", "no"):
         return ""
     if want:
         return want if os.path.isfile(want) and os.access(want, os.X_OK) else ""
-    found = shutil.which("rg", path=env.get("PATH"))
-    if found:
-        return found
-    own = os.path.join(os.path.expanduser("~"), ".gonext", "bin", "rg.exe" if os.name == "nt" else "rg")
+    # PATH by hand, not shutil.which: on Windows which() looks in the CURRENT folder first, and
+    # gu runs inside the user's project — a repo that ships its own rg.exe would be executed.
+    # Relative PATH entries ("", ".") are skipped for the same reason.
+    exe = "rg.exe" if os.name == "nt" else "rg"
+    for d in (env.get("PATH") or "").split(os.pathsep):
+        d = d.strip().strip('"')
+        if not d or not os.path.isabs(d):
+            continue
+        cand = os.path.join(d, exe)
+        if os.path.isfile(cand) and os.access(cand, os.X_OK):
+            return cand
+    own = os.path.join(os.path.expanduser("~"), ".gonext", "bin", exe)
     return own if os.path.isfile(own) and os.access(own, os.X_OK) else ""
 
 

package/gu-repl.mjs

@@ -46,6 +46,7 @@ import dotenv from "dotenv";
 import {
   clipVisible,
   createMouseKeyWindow,
+  createTurnTypingDetector,
   promptBreakdownRows,
   promptTotal,
   resumeTask,
@@ -3236,8 +3237,8 @@ function frozenZone() {
     // #258: typing during a turn is not sent — the row says so (an ask() label still comes first).
     prompt: secretInput && secretPrompt
       ? accent(secretPrompt)
-      : following && typedDuringTurn && !inlinePrompt
-        ? yellow(typedNotice(width))
+      : turnRowNotice(width) && !inlinePrompt
+        ? yellow(turnRowNotice(width))
         : inlinePrompt ? accent(inlinePrompt) : PROMPT,
     // WHILE A SECRET IS OPEN, THIS ROW IS THE PROMPT — "kimi-k3 API key: ••••" rather than
     // ">> ••••". Same row, same masking; what changes is that it now says what it wants. The
@@ -3246,8 +3247,8 @@ function frozenZone() {
     promptCols:
       secretInput && secretPrompt
         ? visibleLen(secretPrompt)
-        : following && typedDuringTurn && !inlinePrompt
-          ? visibleLen(typedNotice(width))
+        : turnRowNotice(width) && !inlinePrompt
+          ? visibleLen(turnRowNotice(width))
           : inlinePrompt
             ? visibleLen(inlinePrompt)
             : PROMPT_COLS,
@@ -4742,7 +4743,11 @@ if (process.stdin.isTTY) {
     // are part of a payload readline never sees. Without this, every pasted character also
     // re-rendered the slash overlay (the line still starts with "/" from before the paste) and
     // re-walked the paste store. Same for a mouse report's characters, which are not keys.
-    if (pasteBuffer !== null || inMouseKeyWindow()) return;
+    if (pasteBuffer !== null) return;
+    if (inMouseKeyWindow()) {
+      turnTyping.reset(); // a held "[" was the start of that report (GH #382)
+      return;
+    }
     // Issue #120: compacting → every key is locked (Ctrl+C still arrives as SIGINT).
     if (compactLocked()) {
       rl.line = "";
@@ -4789,8 +4794,9 @@ if (process.stdin.isTTY) {
       if (key && key.name === "tab" && key.shift) switchEditMode();
       // A printable key (or Enter after one) means the user is typing a question that will not
       // be sent — say so in the input row now, not after they have typed the whole thing (#258).
-      const printable = typeof _ch === "string" && _ch.length > 0 && !/[\x00-\x1f\x7f]/.test(_ch) && !key?.ctrl && !key?.meta;
-      if (printable && !typedDuringTurn) {
+      // Not every printable key is typing: a mouse report or cursor reply whose ESC came alone
+      // arrives as "[", "^[[", "[12;5R" (Windows, GH #382) — the detector sits those out.
+      if (turnTyping.feed(_ch, key) && !typedDuringTurn) {
         typedDuringTurn = true;
         if (barPinned()) paintBar();
       }
@@ -8869,8 +8875,13 @@ async function refreshLogsSize() {
 // What is collected and how it is sent is support-bundle.mjs; this is the terminal half only.
 let supportBusy = false;
 async function runSupport() {
+  // DURING A TURN (GH #382): it used to print one dim line into the turn's output — easy to
+  // miss, then nothing happened, and a stuck turn is exactly when someone wants support. Now it
+  // is QUEUED: the input row says so (with the way out, Ctrl-C) and it opens when the turn ends.
   if (following) {
-    console.log("\n" + GUTTER + dim("A turn is running - /support is available when it finishes (Ctrl-C stops it)."));
+    supportAfterTurn = true;
+    if (barPinned()) paintBar();
+    else console.log("\n" + GUTTER + yellow(SUPPORT_AFTER_TURN_NOTICE.trim()));
     return;
   }
   if (supportBusy || listPickerActive || approvalActive || askWaiting) return;
@@ -11148,11 +11159,28 @@ let following = false;
 // typed while the previous one was still queued simply vanished. Now the input row says so the
 // moment a key lands, and keeps saying it until the turn ends. Nothing is queued or sent.
 let typedDuringTurn = false;
+const turnTyping = createTurnTypingDetector(); // what counts as typing during a turn (GH #382)
 const TYPED_DURING_TURN_NOTICE = "(a turn is running — typing is not sent; type it again when it finishes) ";
 const TYPED_DURING_TURN_SHORT = "(turn running — not sent) ";
+// "? support" clicked during a turn (GH #382): it opens when the turn ends; Ctrl-C ends it now.
+let supportAfterTurn = false;
+const SUPPORT_AFTER_TURN_NOTICE = "(support opens when this turn ends — Ctrl-C stops the turn now) ";
+const SUPPORT_AFTER_TURN_SHORT = "(support after this turn — Ctrl-C) ";
+// After the first Ctrl-C the turn is stopping; a worker that never answers needs a second one.
+const SUPPORT_AFTER_STOP_NOTICE = "(support opens when this turn ends — Ctrl-C again to stop waiting) ";
+const SUPPORT_AFTER_STOP_SHORT = "(support after this turn — Ctrl-C again) ";
 /** The notice that fits: the input row must never wrap because of its label (#109/#132). */
 const typedNotice = (width) =>
   visibleLen(TYPED_DURING_TURN_NOTICE) + 12 <= width ? TYPED_DURING_TURN_NOTICE : TYPED_DURING_TURN_SHORT;
+/** What the input row says during a turn instead of ">>", or "" — queued support comes first. */
+const turnRowNotice = (width) =>
+  !following
+    ? ""
+    : supportAfterTurn
+      ? cancelRequested
+        ? visibleLen(SUPPORT_AFTER_STOP_NOTICE) + 12 <= width ? SUPPORT_AFTER_STOP_NOTICE : SUPPORT_AFTER_STOP_SHORT
+        : visibleLen(SUPPORT_AFTER_TURN_NOTICE) + 12 <= width ? SUPPORT_AFTER_TURN_NOTICE : SUPPORT_AFTER_TURN_SHORT
+      : typedDuringTurn ? typedNotice(width) : "";
 // Is the turn we are following one this terminal STARTED, or another terminal's that we merely
 // attached to (task #211)? `attached` is local to runAgentTurn, and onInterrupt — which lives in
 // main() — had no way to ask. So Ctrl+C while watching somebody else's agent took the "cancel my
@@ -12546,6 +12574,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   following = true;
   followingAttached = attached;
   typedDuringTurn = false;
+  turnTyping.reset();
   compactSeenPasses = 0; // issue #120: python counts passes per turn
   followAborted = false;
   currentJobId = jobId;
@@ -13901,6 +13930,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     following = false;
     followingAttached = false;
     typedDuringTurn = false;
+    turnTyping.reset();
     endCompactLock(); // issue #120: never leave the terminal locked after a turn
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
@@ -14875,6 +14905,7 @@ async function main() {
         // not just detach. The worker sees the "cancelled" status and kills the Python
         // agent; the poll loop then returns cleanly with the "(cancelled)" note.
         cancelRequested = true;
+        if (supportAfterTurn && barPinned()) paintBar(); // its row now says "Ctrl-C again" (GH #382)
         const jobId = currentJobId;
         // #307: while the question is still held (nothing printed yet), nothing goes to the
         // transcript either — a quick change of mind leaves no trace.
@@ -14981,6 +15012,11 @@ async function main() {
     // the turn ends; a queued line carries no Enter keypress, so its re-prompt overwrites
     // in place (\r + refresh) rather than stacking ">> >> >> " on one row.
     let lineRaw;
+    // "? support" was clicked during the turn that just ended (GH #382) — however it ended.
+    if (supportAfterTurn) {
+      supportAfterTurn = false;
+      _lineQueue.unshift("/support");
+    }
     mainPromptWaiting = true; // a finished background shell may start a recap turn now (#362)
     for (;;) {
       lineRaw = await nextLine();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.895",
+  "version": "1.0.896",
   "description": "gu: the coding agent in your terminal. It reads your repo, makes the change and runs the tests, with your own models (Ollama or any OpenAI-compatible provider). Free installs run entirely on your machine. macOS, Linux and Windows.",
   "keywords": [
     "ai",

package/terminal-layout.mjs

@@ -434,6 +434,68 @@ export function promptBreakdownRows(b) {
     }));
 }
 
+/**
+ * DID THE USER TYPE DURING THE TURN? (GH #382) — for the "(a turn is running — typing is not
+ * sent …)" notice. A printable key used to be enough, but the terminal also sends text nobody
+ * typed: a mouse report or a cursor-position reply already on its way when Enter started the
+ * turn. On Windows its ESC often comes alone (node gives it up after 500ms) and the rest arrives
+ * as ordinary characters — "[", "^[[", "[12;5R" — which showed the notice with no key pressed.
+ *
+ * A lone Esc, "[" or "^" starts a held run. It stays a reply while the characters fit a mouse
+ * report or cursor reply ("[", "<", "^", digits, ";") and ends silently on its "M", "m" or "R".
+ * Anything else means it was typing after all: `feed` → true. Enter after a held "[" too.
+ * The joined mouse shape never gets here (createMouseKeyWindow); the caller calls `reset()` for
+ * the keys that window takes, which includes the rest of a split report after its "[".
+ */
+export function createTurnTypingDetector({ maxRun = 32 } = {}) {
+  let active = false;
+  let held = "";
+  const reset = () => {
+    active = false;
+    held = "";
+  };
+  return {
+    /** → true when this key shows the user typed. Feed every key of the turn, in order. */
+    feed(ch, key) {
+      if (key?.name === "escape") {
+        active = true;
+        held = "";
+        return false;
+      }
+      if (key && (key.name === "return" || key.name === "enter")) {
+        const typed = active && held !== "";
+        reset();
+        return typed;
+      }
+      const printable =
+        typeof ch === "string" && ch.length > 0 && !/[\x00-\x1f\x7f]/.test(ch) && !key?.ctrl && !key?.meta;
+      if (!printable) {
+        reset();
+        return false;
+      }
+      if (!active) {
+        if (ch === "[" || ch === "^") {
+          active = true;
+          held = ch;
+          return false;
+        }
+        return true;
+      }
+      if (/^[MmR]$/.test(ch) && held.includes("[")) {
+        reset();
+        return false;
+      }
+      if (/^[[<^\d;]$/.test(ch) && held.length < maxRun && (held !== "" || ch === "[" || ch === "^")) {
+        held += ch;
+        return false;
+      }
+      reset();
+      return true;
+    },
+    reset,
+  };
+}
+
 /**
  * A MOUSE REPORT IS NOT TYPING — the window in which keypress events belong to the mouse.
  *