nexrall-code 0.5.75 → 0.5.77

package/dist/index.js

@@ -14029,7 +14029,7 @@ ${diff3}${xfile}${sec}` };
       }
       return null;
     }
-    async function fetchUrl(input, _workDir2, _redirectCount = 0) {
+    async function fetchUrl(input, _workDir2, _redirectCount = 0, abortSignal) {
       const url = typeof input.url === "string" ? input.url : "";
       if (!url)
         return { error: "Missing required parameter: url" };
@@ -14073,8 +14073,20 @@ ${diff3}${xfile}${sec}` };
           if (settled)
             return;
           settled = true;
+          if (abortPoll !== void 0)
+            clearInterval(abortPoll);
           resolve3(result);
         };
+        let abortPoll;
+        if (abortSignal) {
+          abortPoll = setInterval(() => {
+            if (abortSignal.aborted && !settled) {
+              selfAborted = true;
+              req.destroy();
+              finish({ error: "Request stopped by user", interrupted: true });
+            }
+          }, 100);
+        }
         const req = transport.get(url, {
           timeout: DEFAULT_TIMEOUT_MS,
           lookup: guardedLookup,
@@ -14096,7 +14108,7 @@ ${diff3}${xfile}${sec}` };
               finish({ error: `Invalid redirect location: ${res.headers.location}` });
               return;
             }
-            fetchUrl({ url: nextUrl }, void 0, _redirectCount + 1).then(finish);
+            fetchUrl({ url: nextUrl }, void 0, _redirectCount + 1, abortSignal).then(finish);
             return;
           }
           const contentType = res.headers["content-type"] ?? "";
@@ -14434,45 +14446,83 @@ ${lines.join("\n")}`;
       }
     }
     var VALID_ASPECT_RATIOS = /* @__PURE__ */ new Set(["1:1", "9:16", "16:9", "3:4", "4:3", "3:2", "2:3", "5:4", "4:5", "21:9", "auto"]);
-    function _httpsPost(url, body, headers, timeoutMs = 3e4) {
+    function _httpsPost(url, body, headers, timeoutMs = 3e4, abortSignal) {
       return new Promise((resolve3, reject) => {
         const u = new URL(url);
         const chunks = [];
+        let settled = false;
+        let abortPoll;
+        const done = (fn) => {
+          if (settled)
+            return;
+          settled = true;
+          if (abortPoll)
+            clearInterval(abortPoll);
+          fn();
+        };
         const req = https3.request({ hostname: u.hostname, path: u.pathname + u.search, method: "POST", headers: { ...headers, "Content-Length": Buffer.byteLength(body) }, timeout: timeoutMs }, (res) => {
           res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve3({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") }));
+          res.on("end", () => done(() => resolve3({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") })));
         });
         req.on("timeout", () => {
           req.destroy();
-          reject(new Error(`Request timed out after ${timeoutMs}ms`));
+          done(() => reject(new Error(`Request timed out after ${timeoutMs}ms`)));
         });
-        req.on("error", reject);
+        req.on("error", (err) => done(() => reject(err)));
+        if (abortSignal) {
+          abortPoll = setInterval(() => {
+            if (abortSignal.aborted && !settled) {
+              req.destroy();
+              done(() => reject(Object.assign(new Error("Stopped by user"), { name: "AbortError" })));
+            }
+          }, 100);
+        }
         req.write(body);
         req.end();
       });
     }
-    function _httpsGet(url, headers, timeoutMs = 2e4) {
+    function _httpsGet(url, headers, timeoutMs = 2e4, abortSignal) {
       return new Promise((resolve3, reject) => {
         const u = new URL(url);
         const transport = u.protocol === "https:" ? https3 : http3;
         const chunks = [];
+        let settled = false;
+        let abortPoll;
+        const done = (fn) => {
+          if (settled)
+            return;
+          settled = true;
+          if (abortPoll)
+            clearInterval(abortPoll);
+          fn();
+        };
         const req = transport.get({ hostname: u.hostname, path: u.pathname + u.search, headers, timeout: timeoutMs }, (res) => {
           if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) && res.headers.location) {
             req.destroy();
-            _httpsGet(new URL(res.headers.location, url).href, headers, timeoutMs).then(resolve3, reject);
+            done(() => {
+              _httpsGet(new URL(res.headers.location, url).href, headers, timeoutMs, abortSignal).then(resolve3, reject);
+            });
             return;
           }
           res.on("data", (c) => chunks.push(c));
-          res.on("end", () => resolve3({ status: res.statusCode ?? 0, body: Buffer.concat(chunks), contentType: res.headers["content-type"] ?? "" }));
+          res.on("end", () => done(() => resolve3({ status: res.statusCode ?? 0, body: Buffer.concat(chunks), contentType: res.headers["content-type"] ?? "" })));
         });
         req.on("timeout", () => {
           req.destroy();
-          reject(new Error(`Download timed out after ${timeoutMs}ms`));
+          done(() => reject(new Error(`Download timed out after ${timeoutMs}ms`)));
         });
-        req.on("error", reject);
+        req.on("error", (err) => done(() => reject(err)));
+        if (abortSignal) {
+          abortPoll = setInterval(() => {
+            if (abortSignal.aborted && !settled) {
+              req.destroy();
+              done(() => reject(Object.assign(new Error("Stopped by user"), { name: "AbortError" })));
+            }
+          }, 100);
+        }
       });
     }
-    async function generateImage(input, workDir) {
+    async function generateImage(input, workDir, abortSignal) {
       const prompt2 = typeof input.prompt === "string" ? input.prompt.trim() : "";
       const relPath = typeof input.path === "string" ? input.path.trim() : "";
       const aspectRatio = typeof input.aspect_ratio === "string" && VALID_ASPECT_RATIOS.has(input.aspect_ratio) ? input.aspect_ratio : "1:1";
@@ -14487,7 +14537,7 @@ ${lines.join("\n")}`;
       let cost;
       let balance;
       try {
-        const r2 = await _httpsPost(`${client_1.API_BASE}/api/code/assets/generate`, JSON.stringify({ prompt: prompt2, aspect_ratio: aspectRatio }), { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, 17e4);
+        const r2 = await _httpsPost(`${client_1.API_BASE}/api/code/assets/generate`, JSON.stringify({ prompt: prompt2, aspect_ratio: aspectRatio }), { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, 17e4, abortSignal);
         let json = {};
         try {
           json = JSON.parse(r2.body);
@@ -14501,6 +14551,8 @@ ${lines.join("\n")}`;
         if (!imageUrl)
           return { error: "Image generation succeeded but no URL was returned." };
       } catch (err) {
+        if (err.name === "AbortError")
+          return { error: "generate_image stopped by user", interrupted: true };
         return { error: `generate_image failed: ${err.message}` };
       }
       const destPath = resolvePath(relPath, workDir);
@@ -14509,7 +14561,7 @@ ${lines.join("\n")}`;
       } catch (_) {
       }
       try {
-        const dl = await _httpsGet(imageUrl, { "User-Agent": FETCH_USER_AGENT }, 6e4);
+        const dl = await _httpsGet(imageUrl, { "User-Agent": FETCH_USER_AGENT }, 6e4, abortSignal);
         if (dl.status !== 200)
           return { error: `Failed to download generated image (HTTP ${dl.status}).` };
         fs9.writeFileSync(destPath, dl.body);
@@ -14517,10 +14569,12 @@ ${lines.join("\n")}`;
         const costNote = cost != null ? ` ($${cost.toFixed(2)} charged` + (balance != null ? `, balance $${balance.toFixed(2)})` : ")") : "";
         return { output: `Generated and saved image to ${destPath} (${kb} KB)${costNote}.` };
       } catch (err) {
+        if (err.name === "AbortError")
+          return { error: "generate_image stopped by user (image was generated and billed, but the download was interrupted)", interrupted: true };
         return { error: `Failed to save image to ${destPath}: ${err.message}` };
       }
     }
-    async function stockPhoto(input, workDir) {
+    async function stockPhoto(input, workDir, abortSignal) {
       const query = typeof input.query === "string" ? input.query.trim() : "";
       const relPath = typeof input.path === "string" ? input.path.trim() : "";
       const count = typeof input.count === "number" ? Math.min(Math.max(Math.floor(input.count), 1), 10) : 3;
@@ -14537,7 +14591,7 @@ ${lines.join("\n")}`;
         u.searchParams.set("count", String(count));
         if (orientation)
           u.searchParams.set("orientation", orientation);
-        const r2 = await _httpsGet(u.toString(), { Authorization: `Bearer ${token}` });
+        const r2 = await _httpsGet(u.toString(), { Authorization: `Bearer ${token}` }, 2e4, abortSignal);
         let json = {};
         try {
           json = JSON.parse(r2.body.toString("utf-8"));
@@ -14549,6 +14603,8 @@ ${lines.join("\n")}`;
         if (!photos.length)
           return { output: `No stock photos found for "${query}".` };
       } catch (err) {
+        if (err.name === "AbortError")
+          return { error: "stock_photo stopped by user", interrupted: true };
         return { error: `stock_photo search failed: ${err.message}` };
       }
       if (relPath) {
@@ -14561,7 +14617,7 @@ ${lines.join("\n")}`;
         } catch (_) {
         }
         try {
-          const dl = await _httpsGet(top.url, { "User-Agent": FETCH_USER_AGENT });
+          const dl = await _httpsGet(top.url, { "User-Agent": FETCH_USER_AGENT }, 2e4, abortSignal);
           if (dl.status !== 200)
             return { error: `Failed to download photo (HTTP ${dl.status}).` };
           fs9.writeFileSync(destPath, dl.body);
@@ -14569,6 +14625,8 @@ ${lines.join("\n")}`;
           const credit = top.credit ? ` \u2014 Photo by ${top.credit} on Unsplash` : "";
           return { output: `Downloaded "${top.alt || query}" to ${destPath} (${kb} KB).${credit}` };
         } catch (err) {
+          if (err.name === "AbortError")
+            return { error: "stock_photo download stopped by user", interrupted: true };
           return { error: `Failed to save photo to ${destPath}: ${err.message}` };
         }
       }
@@ -14576,7 +14634,7 @@ ${lines.join("\n")}`;
       return { output: `Found ${photos.length} photo(s) for "${query}":
 ${lines.join("\n")}` };
     }
-    async function webSearch(input) {
+    async function webSearch(input, _workDir2, abortSignal) {
       const query = typeof input.query === "string" ? input.query.trim() : "";
       if (!query)
         return { error: "Missing required parameter: query" };
@@ -14584,7 +14642,7 @@ ${lines.join("\n")}` };
       if (!token)
         return { error: "Not authenticated. Run `nexrall-code login` first." };
       try {
-        const r2 = await _httpsPost(`${client_1.API_BASE}/api/code/tools/web_search`, JSON.stringify({ query }), { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, 3e4);
+        const r2 = await _httpsPost(`${client_1.API_BASE}/api/code/tools/web_search`, JSON.stringify({ query }), { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, 3e4, abortSignal);
         let json = {};
         try {
           json = JSON.parse(r2.body);
@@ -14597,6 +14655,8 @@ ${lines.join("\n")}` };
           return { error: "web_search succeeded but returned no results text." };
         return { output: text };
       } catch (err) {
+        if (err.name === "AbortError")
+          return { error: "web_search stopped by user", interrupted: true };
         return { error: `web_search failed: ${err.message}` };
       }
     }
@@ -14731,8 +14791,6 @@ ${expanded}` };
       "delete_file",
       "notebook_read",
       "notebook_edit",
-      "generate_image",
-      "stock_photo",
       "get_symbols",
       "get_workspace_symbols",
       "go_to_definition",
@@ -14752,6 +14810,14 @@ ${expanded}` };
           return await todoWrite(input, agentScope);
         if (name === "todo_read")
           return await todoRead(input, agentScope);
+        if (name === "fetch_url")
+          return await fetchUrl(input, workDir, 0, abortSignal);
+        if (name === "web_search")
+          return await webSearch(input, workDir, abortSignal);
+        if (name === "generate_image")
+          return await generateImage(input, workDir, abortSignal);
+        if (name === "stock_photo")
+          return await stockPhoto(input, workDir, abortSignal);
         if (WORKDIR_TOOLS.has(name)) {
           return await TOOL_MAP[name](input, workDir);
         }
@@ -17791,7 +17857,7 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
                   if (external !== null && external !== void 0) {
                     result = external;
                   } else if (options.mcpManager?.isMcpTool(name)) {
-                    const mcpOutput = await options.mcpManager.callTool(name, input);
+                    const mcpOutput = await options.mcpManager.callTool(name, input, options.abortSignal);
                     result = { output: mcpOutput ?? "" };
                   } else {
                     options.checkpointManager?.recordBeforeMutation(name, input);
@@ -18555,8 +18621,24 @@ var require_manager = __commonJS({
         }
         return tools;
       }
-      /** Execute an MCP tool call. Returns null if this tool is not an MCP tool. */
-      async callTool(prefixedName, input) {
+      /**
+       * Execute an MCP tool call. Returns null if this tool is not an MCP tool.
+       *
+       * `abortSignal` is optional and best-effort: the underlying transports (stdio
+       * JSON-RPC / HTTP / SSE) have no cancellation message in this client, so an
+       * abort here does NOT stop the server from finishing its work — it only stops
+       * THIS CALL from making the caller wait for it. Before this was added, Ctrl+C
+       * during an MCP tool call was silently swallowed: loop.ts set
+       * `abortSignal.aborted = true` but nothing downstream of `options.mcpManager
+       * .callTool(name, input)` ever looked at it, so the user's only way out was
+       * to wait out the full 60s MCP_TOOL_TIMEOUT_MS (or however long the server
+       * actually took). Racing the same abortSignal the 60s timeout already races
+       * against makes Ctrl+C return control immediately instead of up to a minute
+       * later — matching how the `bash` tool already behaves (its own 200ms abort
+       * poll in executor.ts), just without the ability to also kill a remote
+       * server's in-flight work the way `bash` can kill a local child process.
+       */
+      async callTool(prefixedName, input, abortSignal) {
         const serverName = this._toolMap.get(prefixedName);
         if (!serverName)
           return null;
@@ -18566,7 +18648,21 @@ var require_manager = __commonJS({
         const toolName = prefixedName.slice(serverName.length + 2);
         const MCP_TOOL_TIMEOUT_MS = 6e4;
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP tool "${prefixedName}" timed out after ${MCP_TOOL_TIMEOUT_MS / 1e3}s`)), MCP_TOOL_TIMEOUT_MS));
-        return Promise.race([client.callTool(toolName, input), timeoutPromise]);
+        const racers = [client.callTool(toolName, input), timeoutPromise];
+        if (abortSignal) {
+          let pollId;
+          const abortPromise = new Promise((_, reject) => {
+            pollId = setInterval(() => {
+              if (abortSignal.aborted) {
+                clearInterval(pollId);
+                reject(Object.assign(new Error("Aborted"), { name: "AbortError" }));
+              }
+            }, 100);
+          });
+          racers.push(abortPromise);
+          return Promise.race(racers).finally(() => clearInterval(pollId));
+        }
+        return Promise.race(racers);
       }
       /** True if this tool name belongs to an MCP server. */
       isMcpTool(name) {
@@ -64886,6 +64982,12 @@ var App2 = ({ onReady }) => {
     }
     const newlineIdx = char.search(/[\r\n]/);
     const hasNewline = key.return || newlineIdx !== -1;
+    if (hasNewline && key.shift) {
+      const pos = cursorRef.current;
+      setLine((s2) => s2.slice(0, pos) + "\n" + s2.slice(pos));
+      setCursorPos(pos + 1);
+      return;
+    }
     if (hasNewline) {
       const before = newlineIdx === -1 ? char : char.slice(0, newlineIdx);
       const after = newlineIdx === -1 ? "" : char.slice(newlineIdx + 1).replace(/^[\r\n]/, "");
@@ -64940,7 +65042,36 @@ function startInkTerminal() {
           }
         }
       ),
-      { exitOnCtrlC: false }
+      {
+        exitOnCtrlC: false,
+        // Opt into the Kitty keyboard protocol so `key.shift` is actually
+        // populated for Enter (see the Shift+Enter handling in useInput
+        // above) instead of always being false/undefined.
+        //
+        // MUST be 'enabled', not 'auto'. 'auto' has Ink send a CSI `?u` query
+        // to the terminal and then listen on `stdin`'s 'data' event for the
+        // reply (see ink/build/ink.js confirmKittySupport). That listener
+        // races Ink's own input pipeline, which reads stdin via 'readable' +
+        // `.read()` (paused mode) for its normal keystroke handling — Node
+        // streams do not support mixing 'data' (flowing) and 'readable'
+        // (paused) consumers safely, and in practice the 'readable' consumer
+        // wins the terminal's query response. The reply itself (`\x1b[?1u`)
+        // then gets fed through Ink's normal key parser, which doesn't
+        // recognise it as any special key and inserts it as literal text —
+        // this is exactly the "[?1u" that appears in the input box right
+        // after Ink mounts (e.g. right after confirming the trust prompt).
+        //
+        // 'enabled' skips the query/response dance entirely: Ink just writes
+        // the enable sequence once (`\x1b[>1u`) and never listens for a
+        // reply, so there is nothing to leak into the input box. Terminals
+        // that don't support the protocol silently ignore the unrecognised
+        // escape sequence (the same way they ignore bracketed-paste mode),
+        // so Shift+Enter still safely falls back to the '\' continuation
+        // there — this trades "verify support first" for "assume support,
+        // no-op if absent", which is safe here because the only visible
+        // effect of enabling on an unsupporting terminal is nothing at all.
+        kittyKeyboard: { mode: "enabled", flags: ["disambiguateEscapeCodes"] }
+      }
     );
   });
 }
@@ -65221,23 +65352,29 @@ var Spinner = class {
    * No-op when the spinner isn't active: progress events can arrive a tick after
    * something else (a tool row, the first text delta) legitimately stopped it, and
    * resurrecting the spinner there would fight the printed output for the status line.
+   *
+   * Deliberately does NOT call render() immediately. onThinkingDelta/onThinkingProgress
+   * can fire many times per second while the model streams (one SSE delta each), and
+   * each of those used to trigger its own Ink re-render (setLive -> React state update ->
+   * full-frame clear/redraw) layered on TOP of the interval's own 100ms redraw already
+   * running in start(). Two independent, unsynchronized render sources hitting the same
+   * frame is exactly what produced the visible jitter users reported ("dòng working...
+   * giật giật liên tục") — every fast delta briefly repainted the status line out of
+   * step with the spinner's own tick. Just updating the field here and letting the
+   * existing setInterval pick it up on its next 100ms tick caps the redraw rate at a
+   * steady 10fps with zero perceptible added latency (worst case: one stale frame for
+   * <100ms), and removes the race entirely.
    */
   setDetail(detail) {
     if (this.interval === null)
       return;
-    if (this.detail === detail)
-      return;
     this.detail = detail;
-    this.render();
   }
-  /** Swap the label without resetting the elapsed timer (phase change within one turn). */
+  /** Swap the label without resetting the elapsed timer (phase change within one turn). Same reasoning as setDetail() above: no immediate render, the interval tick picks it up. */
   setText(text) {
     if (this.interval === null)
       return;
-    if (this.baseText === text)
-      return;
     this.baseText = text;
-    this.render();
   }
   render() {
     getInkTerminal()?.setLive(composeStatusLine({
@@ -65695,6 +65832,8 @@ Set ${TRUST_ENV_VAR}=1 to confirm non-interactively, or run \`nex\` interactivel
     process.on("exit", () => {
       stopInkTerminal();
     });
+    if (process.stdin.isTTY)
+      process.stdin.setRawMode(true);
     await startInkTerminal();
     startRowCount();
   }
@@ -65847,7 +65986,7 @@ ${text}` : "");
       } else {
         console.error(source_default.red("\nError: ") + String(err.message));
         if (salvaged) {
-          console.error(source_default.dim("  Progress was saved \u2014 run `nex --continue` to resume this session."));
+          console.error(source_default.dim("  Progress was saved \u2014 run `nex --resume` (or `nex -r`) to resume this session."));
         }
       }
       process.exit(1);

package/nex-watch.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+// nex-watch — auto-relaunch `nex` if the OS kills it with SIGKILL.
+//
+// Usage:
+//   nex-watch [any nex flags/prompt...]
+//   nex-watch                       # interactive session, auto-resumes on kill
+//   nex-watch -y "long unattended task"
+//
+// Why this exists (not something `nex` itself can do):
+//   SIGKILL (signal 9 — what a shell reports as "killed") is the one POSIX
+//   signal a process can NEVER intercept, handle, or clean up after — the
+//   kernel tears it down before a single line of the process's own code can
+//   run. On macOS this is the Jetsam low-memory killer; on Linux it's the
+//   OOM killer. Both pick a victim purely from system-wide memory pressure at
+//   that instant — a machine with plenty of total RAM is not immune if
+//   something else (browser, IDE, other builds) is using nearly all of it
+//   right now. No amount of code inside `nex` can catch or prevent this.
+//
+// What this script actually does:
+//   `nex` already persists its conversation to ~/.nexrall/cli-sessions on
+//   every turn boundary (≤3s debounce), independent of this script. That
+//   means a SIGKILL loses at most a few seconds of progress, not the whole
+//   session — but resuming still requires a human to notice the crash and
+//   type `nex --resume`. This script automates exactly that: it spawns nex
+//   as a child process and watches HOW it exits. Node's child_process
+//   reports the terminating signal directly (no exit-code-to-signal
+//   guesswork needed) — if nex died from SIGKILL or SIGTERM specifically,
+//   this relaunches it with `--resume last` so the run continues from the
+//   last saved turn instead of silently stopping. Any OTHER exit (success,
+//   a real error, Ctrl+C which nex already handles gracefully) stops the
+//   watch loop — this is a safety net for the un-catchable kill case, not a
+//   generic "keep retrying forever" wrapper.
+//
+// A capped retry count (not infinite) matters: if the machine is so starved
+// of memory that every relaunch gets killed again within seconds, retrying
+// forever would just contribute to the same memory pressure that caused the
+// first kill. Capping means it gives up loudly instead of thrashing.
+// Cross-platform note: on Windows there is no SIGKILL/SIGTERM in the POSIX
+// sense — a killed process there typically just reports a non-zero exit
+// code with signal:null. This tool's relaunch-on-signal logic is therefore
+// a no-op (and harmless) on Windows; the memory-pressure-kill scenario it
+// guards against is a macOS/Linux OOM-killer phenomenon in the first place.
+
+import { spawnSync } from 'child_process';
+
+const MAX_RETRIES = Number(process.env.NEX_WATCH_MAX_RETRIES) > 0
+  ? Math.floor(Number(process.env.NEX_WATCH_MAX_RETRIES))
+  : 5;
+const NEX_BIN = process.env.NEX_WATCH_BIN || 'nex';
+
+const isTTY = process.stderr.isTTY === true;
+const c = isTTY
+  ? { dim: '\x1b[2m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', reset: '\x1b[0m' }
+  : { dim: '', green: '', yellow: '', red: '', reset: '' };
+
+const info  = (msg) => process.stderr.write(`${c.dim}[nex-watch]${c.reset} ${msg}\n`);
+const warn  = (msg) => process.stderr.write(`${c.yellow}[nex-watch]${c.reset} ${msg}\n`);
+const ok    = (msg) => process.stderr.write(`${c.green}[nex-watch]${c.reset} ${msg}\n`);
+const fatal = (msg) => { process.stderr.write(`${c.red}[nex-watch]${c.reset} ${msg}\n`); process.exit(1); };
+
+// Kill-type signals worth auto-relaunching on. SIGKILL is the un-catchable
+// OOM/Jetsam case this tool exists for; SIGTERM is included because some
+// low-memory managers (and `docker stop`) send it first before escalating —
+// treating it the same way costs nothing extra since nex has no in-flight
+// state to lose beyond what's already persisted.
+const KILL_SIGNALS = new Set(['SIGKILL', 'SIGTERM']);
+
+const userArgs = process.argv.slice(2);
+
+let attempt = 0;
+for (;;) {
+  const args = attempt === 0 ? userArgs : ['--resume', 'last', ...userArgs];
+  if (attempt === 0) {
+    info(`starting: ${NEX_BIN} ${args.join(' ')}`.trim());
+  } else {
+    info(`relaunch #${attempt}: ${NEX_BIN} ${args.join(' ')}`.trim());
+  }
+
+  const result = spawnSync(NEX_BIN, args, { stdio: 'inherit' });
+
+  if (result.error) {
+    // e.g. ENOENT — nex isn't on PATH. Not a kill scenario; fail immediately
+    // with a clear message rather than retrying something that can't work.
+    fatal(`failed to launch '${NEX_BIN}': ${result.error.message}. Install it first: npm install -g nexrall-code`);
+  }
+
+  if (result.signal && KILL_SIGNALS.has(result.signal)) {
+    attempt += 1;
+    if (attempt > MAX_RETRIES) {
+      fatal(
+        `nex was killed (${result.signal}) ${MAX_RETRIES} times in a row — giving up. ` +
+        `This usually means the machine is critically low on memory; close other applications ` +
+        `before retrying. Progress is saved — run 'nex --resume last' manually once memory is free.`
+      );
+    }
+    warn(
+      `nex was killed (${result.signal}) — this is the OS's low-memory killer, not a nex bug. ` +
+      `Progress up to the last saved turn is safe. Retrying (${attempt}/${MAX_RETRIES}) in 2s...`
+    );
+    // Synchronous sleep via spawnSync on a no-op — avoids pulling in an async
+    // main() just for one delay, keeping this script a simple top-level loop.
+    spawnSync(process.platform === 'win32' ? 'timeout' : 'sleep', [process.platform === 'win32' ? '/t 2' : '2'], { stdio: 'ignore', shell: process.platform === 'win32' });
+    continue;
+  }
+
+  // Any other outcome — normal exit, a real error, or a signal nex already
+  // handles gracefully (e.g. SIGINT from Ctrl+C) — stop here and mirror the
+  // child's result so scripts calling nex-watch see the same status nex itself
+  // would have produced.
+  if (result.status === 0) ok('nex exited normally.');
+  if (result.signal) {
+    // A non-kill signal (rare) — exit with the conventional 128+n code.
+    const SIGNUMS = { SIGINT: 2, SIGHUP: 1, SIGQUIT: 3 };
+    process.exit(128 + (SIGNUMS[result.signal] || 0));
+  }
+  process.exit(result.status ?? 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.75",
+  "version": "0.5.77",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",
@@ -20,13 +20,15 @@
   "license": "MIT",
   "type": "module",
   "bin": {
-    "nex": "dist/index.js"
+    "nex": "dist/index.js",
+    "nex-watch": "nex-watch.js"
   },
   "main": "dist/index.js",
   "files": [
     "dist",
     "install.sh",
-    "install.ps1"
+    "install.ps1",
+    "nex-watch.js"
   ],
   "engines": {
     "node": ">=18"
@@ -39,7 +41,7 @@
     "release": "node build.js && node scripts/upload-release.cjs"
   },
   "dependencies": {
-    "@nexrall/code-core": "^1.4.44",
+    "@nexrall/code-core": "^1.4.45",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "diff": "^5.2.0",