@tiens.nguyen/gu-cli 1.0.829 → 1.0.830

package/gonext_agent_chat.py

@@ -5109,6 +5109,46 @@ def _repair_unterminated_string(code: str) -> str:
         return code
 
 
+# A COMMIT MESSAGE IN A SHELL LINE IN A PYTHON STRING (#360 follow-up). The model passes run_command
+# a whole `git commit -F - <<'EOF' … EOF` (or -m "…") as ONE normal "…" string. The message has
+# line breaks AND, often, the string's own quote ('"node /opt/…/gu"', "turn's") — so the literal
+# ends early and escaping newlines cannot help. Measured 2026-10-14: 2 of the last 2 commit turns
+# lost a step to exactly this. The command argument runs from the call's opening quote to the
+# LAST matching quote that is followed by the next argument or the closing paren; re-quoted as a
+# triple-quoted string it is the text the model meant. Kept only when the block then compiles.
+_RUN_CMD_OPEN_RE = re.compile(r"\brun_command\(\s*(?:command\s*=\s*)?(['\"])(?!\1\1)")
+
+
+def _repair_run_command_string(code: str) -> str:
+    try:
+        compile(code, "<gu-code>", "exec")
+        return code
+    except SyntaxError:
+        pass
+    except Exception:  # noqa: BLE001
+        return code
+    m = _RUN_CMD_OPEN_RE.search(code)
+    if not m:
+        return code
+    q, start = m.group(1), m.end()
+    closer = re.compile(re.escape(q) + r"(?=\s*(?:,\s*(?:workdir|timeout_seconds|background)\s*=|,\s*['\"]|\)))")
+    next_arg = re.compile(re.escape(q) + r"\s*,\s*(?:workdir|timeout_seconds|background)\s*=")
+    for end in reversed([x.start() for x in closer.finditer(code, start)]):
+        body = code[start:end]
+        if next_arg.search(body):
+            continue  # it swallowed the next argument — the command ends earlier
+        for wrap in ('"""', "'''"):
+            if wrap in body or body.endswith(wrap[0]):
+                continue
+            fixed = code[:m.start(1)] + wrap + body + wrap + code[end + 1:]
+            try:
+                compile(fixed, "<gu-code>", "exec")
+                return fixed
+            except SyntaxError:
+                continue
+    return code
+
+
 def _repair_code_block_strings(text: str) -> str:
     """Apply _repair_unterminated_string to the python inside a <code>…</code> block
     (leaving the surrounding Thought prose untouched). No-op when there's no block or the
@@ -5134,6 +5174,8 @@ def _repair_code_block_strings(text: str) -> str:
     close_start = open_end + cm.start()
     inner = text[open_end:close_start]
     fixed = _repair_unterminated_string(inner)
+    if fixed == inner:
+        fixed = _repair_run_command_string(inner)
     if fixed != inner:
         return text[:open_end] + fixed + text[close_start:]
     # Stage 2 — only worth trying when there's MORE than one </code> (extra tags in content).
@@ -7950,6 +7992,18 @@ _BG_LINE = ("A LONG job (build, deploy, big test run) → run_command(…, backg
             "timeout moves to the background by itself instead of being killed.\n")
 
 
+# What to do instead, said where quoting broke — in gu's own pre-check (an unbalanced quote never
+# reaches bash) and in bash's error. In a commit turn the next step was otherwise a guess.
+_HEREDOC_HINT = ("\n\nSHELL QUOTING broke this line. For text with quotes or line breaks (a commit "
+                 "message, an issue body) use a heredoc inside a triple-quoted string: "
+                 "run_command(\"\"\"git commit -F - <<'EOF'\n<message>\nEOF\"\"\") — nothing in the "
+                 "message needs escaping.")
+
+# bash's words for a line whose quotes do not pair up.
+_SHELL_QUOTE_ERR_RE = re.compile(
+    r"unexpected EOF while looking for matching|syntax error near unexpected token|"
+    r"syntax error: unexpected end of file|unterminated quoted string")
+
 _RUN_DOC_ARGV = ("No other shell syntax (no pipes/redirects/;). sudo/su are blocked.")
 _RUN_DOC_SHELL = ("It runs in bash, so pipes, redirects, ;, ||, $( ), globs and heredocs work too "
                   "(e.g. 'npm test 2>&1 | tail -40'). sudo/su are blocked.")
@@ -8941,6 +8995,70 @@ def _shell_find(shells: list, key: str):
     return None
 
 
+_EPHEMERAL_FLOOR = None
+
+
+def _ws_ephemeral_floor() -> int:
+    """First port of the OS's ephemeral range — where a bind to port 0 lands. Linux reads
+    ip_local_port_range (32768 by default), macOS its sysctl (49152); Windows and anything
+    unreadable use the IANA 49152."""
+    global _EPHEMERAL_FLOOR
+    if _EPHEMERAL_FLOOR is None:
+        floor = 49152
+        try:
+            if sys.platform.startswith("linux"):
+                with open("/proc/sys/net/ipv4/ip_local_port_range", encoding="utf-8") as fh:
+                    floor = int(fh.read().split()[0])
+            elif sys.platform == "darwin":
+                import subprocess
+                out = subprocess.run(["sysctl", "-n", "net.inet.ip.portrange.first"],
+                                     capture_output=True, text=True, timeout=3).stdout.strip()
+                floor = int(out) if out.isdigit() else floor
+        except Exception:  # noqa: BLE001
+            pass
+        _EPHEMERAL_FLOOR = max(1024, floor)
+    return _EPHEMERAL_FLOOR
+
+
+def _ws_is_ephemeral_port(port) -> bool:
+    try:
+        return int(port) >= _ws_ephemeral_floor()
+    except (TypeError, ValueError):
+        return False
+
+
+def _server_as_shell(srv: dict) -> dict:
+    """A left-running server/app in the shape shell_output reads, so a command that was filed as
+    a server (wrongly, or not) can still be waited on and read (#360)."""
+    import time as _t
+    started = srv.get("started")
+    if started is None:
+        try:
+            started = _t.mktime(_t.strptime(str(srv.get("started_at")), "%Y-%m-%d %H:%M:%S"))
+        except (ValueError, OverflowError):
+            started = _t.time()
+    return {"id": str(srv.get("pid")), "pid": srv.get("pid"), "pgid": srv.get("pgid") or srv.get("pid"),
+            "command": srv.get("command"), "workdir": srv.get("workdir"), "log": srv.get("log"),
+            "exit_file": "", "started": started, "read_offset": srv.get("read_offset", 0),
+            "server": True}
+
+
+def _shell_or_server(shells: list, servers: list, key: str):
+    """shell_output's target: a shell by id, else a server by pid or port; with no key, the newest
+    of both — the model asking about "the" background job means the one it just started."""
+    key = (key or "").strip().lstrip("#")
+    if key:
+        sh = _shell_find(shells, key)
+        if sh is not None:
+            return sh
+        for srv in reversed(servers):
+            if key == str(srv.get("pid")) or any(key == str(p) for p in srv.get("ports") or []):
+                return _server_as_shell(srv)
+        return None
+    cands = list(shells) + [_server_as_shell(x) for x in servers]
+    return max(cands, key=lambda x: float(x.get("started") or 0)) if cands else None
+
+
 def _shell_kill(s: dict) -> None:
     """Stop a shell's whole process group and mark it killed (unless it already finished)."""
     import time as _t
@@ -9020,8 +9138,19 @@ def _range_is_covered(served, start: int, end: int):
     return None
 
 
-def _ws_distill_output(out: str, cap_head: int = 1200, cap_tail: int = 4000) -> str:
-    """Cap huge build/test output: failures live at the tail, context at the head."""
+_DISTILL_FLOOR = 5200  # 1200 head + 4000 tail — what every window got before #360
+
+
+def _ws_distill_output(out: str, cap_head: int = None, cap_tail: int = None) -> str:
+    """Cap huge build/test output: failures live at the tail, context at the head.
+
+    THE CAP SCALES WITH THE WINDOW, like a file read (#360 follow-up, issue #49). A fixed 5,200
+    chars cut a `git diff` in a commit turn and the model spent a step re-reading it with sed;
+    a command's output is a read too. Never below the old size, so a small window is unchanged."""
+    if cap_head is None or cap_tail is None:
+        total = max(_DISTILL_FLOOR, int(_OBS_CAPS.get("read") or 0))
+        cap_head = cap_head if cap_head is not None else int(total * 0.23)
+        cap_tail = cap_tail if cap_tail is not None else total - cap_head
     if len(out) <= cap_head + cap_tail + 200:
         return out
     return (out[:cap_head] + f"\n…[{len(out) - cap_head - cap_tail} chars omitted]…\n"
@@ -14356,7 +14485,8 @@ def run_agent_chat(cfg):
                 _scan = _shell_scan(command) if _shell_bin else None
                 if _scan and _scan["error"]:
                     msg = (f"Error: that command did NOT run — {_scan['error']}. Nothing was "
-                           "executed; fix the quoting and send it again.")
+                           "executed; fix the quoting and send it again."
+                           + (_HEREDOC_HINT if "quote" in str(_scan["error"]) else ""))
                     _last_obs["text"] = msg
                     return msg
                 _use_shell = bool(_scan) and _shell_needed(_scan)
@@ -14620,6 +14750,12 @@ def run_agent_chat(cfg):
                         # denied" is the part the reader already has; who we were and what we
                         # were allowed to be is the part they need, and without it both the
                         # model and the user are guessing at the next step.
+                        # A QUOTING ERROR NAMES THE FORM THAT WORKS (#360 follow-up). The model's
+                        # `git commit -m '…turn'\''s…'` lost its backslash to Python and bash
+                        # stopped on the quote; the next step was spent guessing. A heredoc in a
+                        # triple-quoted string has no quoting to get wrong.
+                        if rc != 0 and _use_shell and _SHELL_QUOTE_ERR_RE.search(out or ""):
+                            result += _HEREDOC_HINT
                         if rc != 0 and _WS_PERM_ERR_RE.search(out or ""):
                             _f = _ws_access_facts()
                             result = f"{result}\n\n{_ws_access_report(_f, _ws_paths_in(command))}"
@@ -14629,10 +14765,16 @@ def run_agent_chat(cfg):
                         return result
                     if _t.time() - start >= 3:
                         ports = _ws_listening_ports(proc.pid)
+                        # A port the OS PICKED (bind to 0) is a test run's own helper — the UI
+                        # suite's fake API on :52192 was filed as a "server", so the model could
+                        # not wait for the run and spent 3 steps polling it by hand (#360). Keep
+                        # waiting for it like any command; it hands off at the deadline if needed.
+                        if ports and all(_ws_is_ephemeral_port(p_) for p_ in ports):
+                            ports = []
                         if ports:
                             servers = _ws_load_servers()
                             servers.append({
-                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "pgid": proc.pid, "pid": proc.pid, "command": command, "started": start,
                                 "workdir": wd, "ports": ports, "log": log_path,
                                 "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
                             })
@@ -14642,7 +14784,9 @@ def run_agent_chat(cfg):
                             tail = _ws_distill_output(_read_log())
                             result = (f"RUNNING: '{command}' is up and listening — {urls} "
                                       f"(pid {proc.pid}, log {log_path}). It stays running in "
-                                      "the background; use stop_server to stop it. "
+                                      "the background; use stop_server to stop it. If it is "
+                                      "NOT meant to stay up (a test run that opened a port), "
+                                      f"shell_output('{proc.pid}', wait_seconds=…) waits for it. "
                                       f"Startup output:\n{tail}")
                             _last_obs["text"] = result
                             return result
@@ -14654,7 +14798,7 @@ def run_agent_chat(cfg):
                         if _ws_gui_pids(proc.pid):
                             servers = _ws_load_servers()
                             servers.append({
-                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "pgid": proc.pid, "pid": proc.pid, "command": command, "started": start,
                                 "workdir": wd, "ports": [], "kind": "gui", "log": log_path,
                                 "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
                             })
@@ -14785,11 +14929,13 @@ def run_agent_chat(cfg):
             try:
                 import time as _t
                 shells = _shells_load()
-                sh = _shell_find(shells, shell_id)
+                servers = _ws_load_servers()
+                sh = _shell_or_server(shells, servers, shell_id)
                 if sh is None:
-                    msg = ("No background shell matches '" + (shell_id or "") + "'. "
-                           + ("Shells: " + ", ".join(str(x.get("id")) for x in shells) if shells
-                              else "No background shells were started."))
+                    ids = [str(x.get("id")) for x in shells] + [str(x.get("pid")) for x in servers]
+                    msg = ("No background shell or server matches '" + (shell_id or "") + "'. "
+                           + ("Running: " + ", ".join(ids) if ids
+                              else "Nothing was left running in the background."))
                     _last_obs["text"] = msg
                     return msg
                 deadline = _t.time() + max(0, min(int(wait_seconds or 0), 540))
@@ -14804,14 +14950,22 @@ def run_agent_chat(cfg):
                 except OSError:
                     chunk = b""
                 # Re-read the file before writing: the terminal may have killed it meanwhile.
-                shells = _shells_load()
-                cur = _shell_find(shells, str(sh.get("id"))) or sh
-                cur["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
-                if st["state"] != "running":
-                    cur["seen"] = True
-                _shells_save(shells)
+                if sh.get("server"):
+                    servers = _ws_load_servers(prune=False)
+                    for x in servers:
+                        if str(x.get("pid")) == str(sh.get("id")):
+                            x["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
+                    _ws_save_servers(servers)
+                else:
+                    shells = _shells_load()
+                    cur = _shell_find(shells, str(sh.get("id"))) or sh
+                    cur["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
+                    if st["state"] != "running":
+                        cur["seen"] = True
+                    _shells_save(shells)
                 new = _ws_distill_output(chunk.decode("utf-8", errors="replace"))
-                head = (f"shell {sh.get('id')}: {_shell_status_text(st).upper()} after "
+                head = (f"{'server' if sh.get('server') else 'shell'} {sh.get('id')}: "
+                        f"{_shell_status_text(st).upper()} after "
                         f"{_fmt_runtime(st['runtime'])} — '{_clip(str(sh.get('command')), 200)}' "
                         f"(log {sh.get('log')})")
                 if st["state"] == "exited":

package/package.json

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