@tiens.nguyen/gonext-local-worker 1.0.214 → 1.0.216

package/gonext-local-worker.mjs

@@ -1837,21 +1837,6 @@ async function runAgentChatJob(job) {
       // lands here (must be a registered workspace; the python side re-validates).
       activeWorkspace: payload?.activeWorkspace ?? "",
     });
-    // Remember the terminal's current folder so the web homepage can highlight which
-    // registered workspace is ACTIVE (the local_health job reads this back). Without it
-    // the web can only dump the full workspaces.json list with no "you are here" signal.
-    // Fire-and-forget; a stale value just points at the last-used folder, which is fine.
-    if (typeof payload?.activeWorkspace === "string" && payload.activeWorkspace) {
-      const activePath = payload.activeWorkspace;
-      void mkdir(join(homedir(), ".gonext"), { recursive: true })
-        .then(() =>
-          writeFile(
-            join(homedir(), ".gonext", "active-workspace.json"),
-            JSON.stringify({ path: activePath, at: new Date().toISOString() }) + "\n"
-          )
-        )
-        .catch(() => {});
-    }
     // 30 min max for an agent run: multi-step ReAct on a 14B/31B with a cold prompt
     // cache — or a remote Ollama box on slow GPU cold-loading a big model — can run
     // for many minutes per step. Must stay BELOW the web client's hard WS deadline
@@ -2573,31 +2558,19 @@ async function runLocalHealthJob(job) {
             }
           : undefined,
       // Registered coding workspaces (names/paths only — no secrets) so the web can
-      // show which folders the agent may read/edit on this Mac. The one the `gonext`
-      // terminal last ran in is flagged `active` (persisted per agent job) and sorted
-      // first so the web can highlight it instead of dumping the whole list flat.
-      workspaces: await (async () => {
-        const activePath = await readFile(
-          join(homedir(), ".gonext", "active-workspace.json"),
-          "utf8"
-        )
-          .then((raw) => String(JSON.parse(raw)?.path ?? ""))
-          .catch(() => "");
-        return readFile(join(homedir(), ".gonext", "workspaces.json"), "utf8")
-          .then((raw) => {
-            const parsed = JSON.parse(raw);
-            if (!Array.isArray(parsed?.workspaces)) return undefined;
-            const list = parsed.workspaces.map((w) => ({
-              name: String(w.name ?? ""),
-              path: String(w.path ?? ""),
-              allowRun: Boolean(w.allowRun),
-              active: Boolean(activePath) && String(w.path ?? "") === activePath,
-            }));
-            // Active folder first; the rest keep their registration order.
-            return list.sort((a, b) => Number(b.active) - Number(a.active));
-          })
-          .catch(() => undefined);
-      })(),
+      // show which folders the agent may read/edit on this Mac.
+      workspaces: await readFile(join(homedir(), ".gonext", "workspaces.json"), "utf8")
+        .then((raw) => {
+          const parsed = JSON.parse(raw);
+          return Array.isArray(parsed?.workspaces)
+            ? parsed.workspaces.map((w) => ({
+                name: String(w.name ?? ""),
+                path: String(w.path ?? ""),
+                allowRun: Boolean(w.allowRun),
+              }))
+            : undefined;
+        })
+        .catch(() => undefined),
     };
     const totalTimeSeconds = (Date.now() - start) / 1000;
     const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {

package/gonext_agent_chat.py

@@ -1143,6 +1143,80 @@ def _normalize_code_tags(text: str) -> str:
     return fixed
 
 
+def _escape_raw_newlines_in_strings(code: str) -> str:
+    """Turn RAW newlines/tabs that sit INSIDE a single/double-quoted string literal into
+    \\n/\\t escapes. Triple-quoted strings, comments, and everything outside a string are
+    copied verbatim. A tiny hand-rolled scanner (the code doesn't parse, so ast/tokenize
+    can't help). Used only by _repair_unterminated_string below."""
+    out = []
+    i, n = 0, len(code)
+    quote = None      # the delimiter of the string we're inside, or None
+    escaped = False
+    while i < n:
+        ch = code[i]
+        if quote is None:
+            three = code[i:i + 3]
+            if three in ("'''", '"""'):          # legal multi-line string — copy whole
+                end = code.find(three, i + 3)
+                if end == -1:
+                    out.append(code[i:]); break
+                out.append(code[i:end + 3]); i = end + 3; continue
+            if ch == "#":                          # comment — copy to end of line
+                j = code.find("\n", i)
+                if j == -1:
+                    out.append(code[i:]); break
+                out.append(code[i:j]); i = j; continue
+            if ch in ("'", '"'):
+                quote = ch
+            out.append(ch); i += 1
+        else:
+            if escaped:
+                out.append(ch); escaped = False; i += 1; continue
+            if ch == "\\":
+                out.append(ch); escaped = True; i += 1; continue
+            if ch == quote:
+                out.append(ch); quote = None; i += 1; continue
+            out.append({"\n": "\\n", "\r": "\\r", "\t": "\\t"}.get(ch, ch)); i += 1
+    return "".join(out)
+
+
+def _repair_unterminated_string(code: str) -> str:
+    """Rescue the 'unterminated string literal' failure weak models hit when they pass
+    multi-line file content with RAW line breaks inside a normal "..." (create_file /
+    edit_lines / edit_file). Escapes those newlines and returns the repaired code ONLY if
+    it now compiles; otherwise returns the ORIGINAL unchanged (never yields non-parsing
+    code, and never touches code that already compiles)."""
+    try:
+        compile(code, "<gonext-code>", "exec")
+        return code  # already valid — do nothing
+    except SyntaxError as e:
+        msg = (getattr(e, "msg", "") or "").lower()
+        if "unterminated string literal" not in msg and "eol while scanning" not in msg:
+            return code
+    except Exception:  # noqa: BLE001
+        return code
+    try:
+        fixed = _escape_raw_newlines_in_strings(code)
+        compile(fixed, "<gonext-code>", "exec")
+        return fixed
+    except Exception:  # noqa: BLE001
+        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
+    block already parses."""
+    m = re.search(r"<code>([\s\S]*?)</code>", text)
+    if not m:
+        return text
+    inner = m.group(1)
+    fixed = _repair_unterminated_string(inner)
+    if fixed == inner:
+        return text
+    return text[:m.start(1)] + fixed + text[m.end(1):]
+
+
 def _strip_think(text: str) -> str:
     """Remove Qwen3-style <think>…</think> reasoning traces from a model reply.
 
@@ -2178,6 +2252,57 @@ def _ws_listening_ports(pgid: int) -> list:
         return []
 
 
+def _ws_gui_pids(pgid: int) -> list:
+    """pids in the group that OWN AN ON-SCREEN WINDOW — the behavioral definition of
+    'this command is a desktop/GUI app' (tkinter, pygame, PyQt…), the third outcome
+    alongside 'exited' and 'listening on a port'. macOS only; empty on other platforms
+    or when the signal is unavailable (safe no-op → falls back to the old wait/kill).
+
+    Detection is RUNTIME/behavior-based (what the process actually did), never a command
+    name — consistent with _ws_listening_ports. Primary: Quartz's window list filtered by
+    owner pid (definitive). Fallback: lsof for a mapped macOS windowing framework a process
+    only loads once it has a real GUI (AppKit/HIToolbox/Tk) or a live WindowServer socket."""
+    import sys
+    if sys.platform != "darwin":
+        return []
+    pids = set(_ws_pgroup_pids(pgid))
+    if not pids:
+        return []
+    # Primary: on-screen window ownership via Quartz (import-guarded — pyobjc may be absent).
+    try:
+        from Quartz import (  # type: ignore
+            CGWindowListCopyWindowInfo,
+            kCGWindowListOptionOnScreenOnly,
+            kCGNullWindowID,
+            kCGWindowOwnerPID,
+        )
+        info = CGWindowListCopyWindowInfo(
+            kCGWindowListOptionOnScreenOnly, kCGNullWindowID) or []
+        owners = {int(w.get(kCGWindowOwnerPID, 0)) for w in info}
+        hit = sorted(pids & owners)
+        if hit:
+            return hit
+    except Exception:  # noqa: BLE001 — Quartz missing/failed → fall through to lsof
+        pass
+    # Fallback: a process that mapped the GUI stack (or holds a WindowServer connection).
+    import subprocess
+    try:
+        out = subprocess.run(
+            ["lsof", "-p", ",".join(map(str, sorted(pids)))],
+            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, timeout=5)
+        gui = set()
+        for line in out.stdout.splitlines()[1:]:
+            if ("AppKit.framework" in line or "HIToolbox.framework" in line
+                    or "/Tk.framework" in line or "WindowServer" in line):
+                try:
+                    gui.add(int(line.split()[1]))
+                except (ValueError, IndexError):
+                    pass
+        return sorted(gui & pids)
+    except Exception:  # noqa: BLE001
+        return []
+
+
 def _ws_servers_path() -> str:
     import os
     base = os.path.join(os.path.expanduser("~"), ".gonext")
@@ -2794,10 +2919,18 @@ def run_agent_chat(cfg):
         "replace a line range (backup saved automatically).\n"
         "    - edit_file(path, old_string, new_string) — replace one exact unique string "
         "(must match byte-for-byte; prefer edit_lines).\n"
-        "    - create_file(path, content) — create a NEW file.\n"
+        "    - create_file(path, content, overwrite=False) — create a file; pass "
+        "overwrite=True to REPLACE an existing file in ONE call (don't read+edit_lines "
+        "just to rewrite everything).\n"
         "    - run_command(command, workdir='') — run a build/test command (npm test, mvn "
-        "test, pytest…) to VERIFY changes (only in workspaces with run permission).\n"
+        "test, pytest…) to VERIFY changes, or start an app. A server/desktop-GUI app is "
+        "left RUNNING (its window opens on the user's Mac); stop_server closes it. An "
+        "interactive input() CLI can't be driven here (EOFError) — make it non-interactive "
+        "or give the user the command.\n"
         "    NOTE: plain `import os`/`open()` is blocked — use ONLY these tools for files.\n"
+        "    WRITING FILE CONTENT: multi-line content MUST use \\n for newlines (or a "
+        "triple-quoted string). NEVER put a raw line break inside a normal \"...\" — it "
+        "causes 'unterminated string literal'.\n"
     ) if _WS_AVAILABLE else ""
     _ws_choose_line = (
         "- user asks to FIX A BUG / MODIFY / ADD CODE in a workspace -> "
@@ -3659,7 +3792,14 @@ def run_agent_chat(cfg):
                         normalized = _normalize_code_tags(content)
                         if normalized != content:
                             _log("normalized code-block tags (<code >/fence → <code>)")
-                            msg.content = normalized
+                        # Facet 1: rescue multi-line file content passed with RAW newlines
+                        # inside a normal "..." ("unterminated string literal") — repair the
+                        # <code> block ONLY when it makes the snippet compile.
+                        repaired = _repair_code_block_strings(normalized)
+                        if repaired != normalized:
+                            _log("repaired unterminated string literal in tool-call code")
+                        if repaired != content:
+                            msg.content = repaired
                     else:
                         stripped = content.strip()
                         looks_final = (
@@ -4282,31 +4422,38 @@ def run_agent_chat(cfg):
                 return msg
 
         @tool
-        def create_file(path: str, content: str) -> str:
-            """Create a NEW file inside a registered workspace (errors if it already exists — use edit tools for existing files).
+        def create_file(path: str, content: str, overwrite: bool = False) -> str:
+            """Create a file inside a registered workspace, or REPLACE the whole file when overwrite=True. Pass overwrite=True to rewrite an existing file in one call (a backup is saved for revert) — no need to read_file_lines + edit_lines just to replace everything. Multi-line content MUST use \\n for line breaks (or a triple-quoted string); a raw line break inside a normal "..." causes an 'unterminated string literal' error.
 
             Args:
-                path: new file path inside a workspace.
+                path: file path inside a workspace.
                 content: full file content.
+                overwrite: replace the file if it already exists (default False = error on existing).
             """
             try:
                 rp = _ws_write_allowed((path or "").strip())
                 import os
-                if os.path.exists(rp):
-                    msg = f"Error: {path} already exists — use edit_lines/edit_file to change it."
+                existed = os.path.exists(rp)
+                if existed and not overwrite:
+                    msg = (f"Error: {path} already exists — pass overwrite=True to replace the "
+                           "whole file, or use edit_lines/edit_file for a partial change.")
                     _last_obs["text"] = msg
                     return msg
+                # Snapshot BEFORE overwriting so revert restores the prior version. Record as
+                # an "edit" (not "create") when the file already existed, so revert restores
+                # the backup instead of deleting a file the user may have had before.
+                backup = _ws_snapshot(rp) if existed else ""
                 os.makedirs(os.path.dirname(rp) or ".", exist_ok=True)
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(content)
-                _ws_record_change("create", rp, None)
+                _ws_record_change("edit" if existed else "create", rp, backup or None)
                 content_ls = content.splitlines() or [""]
                 _emit({"type": "step", "text": _render_edit_card(
-                    "Create", rp,
-                    f"Added {len(content_ls)} line(s)",
+                    "Update" if existed else "Create", rp,
+                    ("Rewrote file — " if existed else "Added ") + f"{len(content_ls)} line(s)",
                     added=[(i + 1, t) for i, t in enumerate(content_ls)],
                 )})
-                out = f"Created {rp} ({len(content)} chars)."
+                out = f"{'Overwrote' if existed else 'Created'} {rp} ({len(content)} chars)."
                 _last_obs["text"] = out
                 return out
             except Exception as ex:  # noqa: BLE001
@@ -4349,7 +4496,7 @@ def run_agent_chat(cfg):
 
         @tool
         def run_command(command: str, workdir: str = "", timeout_seconds: int = 180) -> str:
-            """Run a command inside a workspace that has run permission (e.g. 'npm test', 'npm run build', 'npm start', 'mvn test'). One-shot commands return their output when they exit. If the command turns out to be a SERVER (keeps running and listens on a port), it is left RUNNING in the background and its URL is reported — tell the user the URL, and use stop_server to stop it when asked.
+            """Run a command inside a workspace that has run permission (e.g. 'npm test', 'npm run build', 'npm start', 'mvn test', 'python3 app.py'). One-shot commands return their output when they exit. If the command turns out to be a SERVER (keeps running and listens on a port), it is left RUNNING and its URL is reported. If it is a DESKTOP/GUI app (opens a window — tkinter, pygame, PyQt…), it is LAUNCHED and left running: its window appears on the user's Mac; tell them it's open. Both are stoppable via stop_server. Note: an interactive CLI that reads stdin (input()) cannot be driven here — it will fail with EOFError; make it non-interactive or give the user the command to run themselves.
 
             Args:
                 command: the command line (allowlisted runners only; no shells or sudo).
@@ -4436,6 +4583,29 @@ def run_agent_chat(cfg):
                                       f"Startup output:\n{tail}")
                             _last_obs["text"] = result
                             return result
+                        # Not a server, but still alive AND it OPENED A WINDOW → a desktop
+                        # app. Launch-and-leave like a server (a GUI never exits and opens
+                        # no port, so it would otherwise hit the timeout kill below and its
+                        # window would be destroyed). Returning fast here also dodges the
+                        # smolagents 60s executor cap that was killing the tool call.
+                        if _ws_gui_pids(proc.pid):
+                            servers = _ws_load_servers()
+                            servers.append({
+                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "workdir": wd, "ports": [], "kind": "gui", "log": log_path,
+                                "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
+                            })
+                            _ws_save_servers(servers)
+                            _emit({"type": "step",
+                                   "text": f"App launched → window open (left running)"})
+                            tail = _ws_distill_output(_read_log())
+                            result = (f"LAUNCHED: '{command}' — its window should be open on "
+                                      f"the user's Mac now (pid {proc.pid}). It keeps running "
+                                      "in the background; use stop_server (or just close the "
+                                      "window) to quit."
+                                      + (f"\nStartup output:\n{tail}" if tail.strip() else ""))
+                            _last_obs["text"] = result
+                            return result
                     if _t.time() - start >= t:
                         try:
                             os.killpg(proc.pid, signal.SIGKILL)
@@ -4459,7 +4629,7 @@ def run_agent_chat(cfg):
 
         @tool
         def stop_server(port_or_pid: str = "") -> str:
-            """Stop a background server previously started by run_command. Use when the user asks to stop/kill the server.
+            """Stop a background server OR desktop app previously started by run_command (closes its window). Use when the user asks to stop/kill/close it.
 
             Args:
                 port_or_pid: the server's port or pid (empty = the most recently started one).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.214",
+  "version": "1.0.216",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",