nexrall-code 0.5.74 → 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) {
@@ -64732,23 +64828,50 @@ function footerText(info) {
 }
 var IntlWithSegmenter = Intl;
 var graphemeSegmenter = typeof IntlWithSegmenter.Segmenter === "function" ? new IntlWithSegmenter.Segmenter(void 0, { granularity: "grapheme" }) : null;
-function dropLastGrapheme(text) {
-  if (!text)
-    return "";
+function graphemeBoundaries(text) {
   if (graphemeSegmenter) {
-    let lastStart = 0;
-    for (const { index } of graphemeSegmenter.segment(text))
-      lastStart = index;
-    return text.slice(0, lastStart);
-  }
-  let end = text.length - 1;
-  while (end > 0 && /[\u0300-\u036F\u1AB0-\u1AFF\u20D0-\u20F0]/.test(text[end]))
-    end--;
-  const prev = text.charCodeAt(end - 1);
-  const curr = text.charCodeAt(end);
-  if (end > 0 && prev >= 55296 && prev <= 56319 && curr >= 56320 && curr <= 57343)
-    end--;
-  return text.slice(0, end);
+    const bounds2 = [0];
+    for (const { index } of graphemeSegmenter.segment(text)) {
+      if (index > 0)
+        bounds2.push(index);
+    }
+    bounds2.push(text.length);
+    return bounds2;
+  }
+  const bounds = [0];
+  let i2 = 0;
+  while (i2 < text.length) {
+    let next = i2 + 1;
+    const code = text.charCodeAt(i2);
+    if (code >= 55296 && code <= 56319 && next < text.length) {
+      const low = text.charCodeAt(next);
+      if (low >= 56320 && low <= 57343)
+        next++;
+    }
+    while (next < text.length && /[\u0300-\u036F\u1AB0-\u1AFF\u20D0-\u20F0]/.test(text[next]))
+      next++;
+    bounds.push(next);
+    i2 = next;
+  }
+  return bounds;
+}
+function prevGraphemeBoundary(text, pos) {
+  const bounds = graphemeBoundaries(text);
+  let prev = 0;
+  for (const b of bounds) {
+    if (b >= pos)
+      break;
+    prev = b;
+  }
+  return prev;
+}
+function nextGraphemeBoundary(text, pos) {
+  const bounds = graphemeBoundaries(text);
+  for (const b of bounds) {
+    if (b > pos)
+      return b;
+  }
+  return text.length;
 }
 var handle = null;
 var inkInstance = null;
@@ -64758,8 +64881,9 @@ var App2 = ({ onReady }) => {
   const [items, setItems] = (0, import_react35.useState)([]);
   const [footer, setFooterState] = (0, import_react35.useState)({ mode: "auto", autoApprove: false });
   const { columns } = use_window_size_default();
-  const [inputEnabled, setInputEnabledState] = (0, import_react35.useState)(true);
+  const [busy, setBusyState] = (0, import_react35.useState)(false);
   const [line, setLineState] = (0, import_react35.useState)("");
+  const [cursorPos, setCursorPosState] = (0, import_react35.useState)(0);
   const [prompt2, setPrompt] = (0, import_react35.useState)(DEFAULT_PROMPT);
   const { exit } = use_app_default();
   const lineRef = (0, import_react35.useRef)("");
@@ -64768,18 +64892,30 @@ var App2 = ({ onReady }) => {
     lineRef.current = value;
     setLineState(value);
   }, []);
+  const cursorRef = (0, import_react35.useRef)(0);
+  const setCursorPos = (0, import_react35.useCallback)((next) => {
+    const value = typeof next === "function" ? next(cursorRef.current) : next;
+    cursorRef.current = value;
+    setCursorPosState(value);
+  }, []);
   const askResolverRef = (0, import_react35.useRef)(null);
   const onLineRef = (0, import_react35.useRef)(null);
+  const onQueuedLineRef = (0, import_react35.useRef)(null);
+  const busyRef = (0, import_react35.useRef)(false);
   const [live, setLiveState] = (0, import_react35.useState)("");
   const print = (0, import_react35.useCallback)((text) => {
     setItems((prev) => [...prev, { id: idCounter++, content: text }]);
   }, []);
   const setFooter = (0, import_react35.useCallback)((info) => setFooterState(info), []);
   const setLive = (0, import_react35.useCallback)((text) => setLiveState(text), []);
-  const setInputEnabled = (0, import_react35.useCallback)((enabled) => setInputEnabledState(enabled), []);
+  const setBusy = (0, import_react35.useCallback)((value) => {
+    busyRef.current = value;
+    setBusyState(value);
+  }, []);
   const askLine = (0, import_react35.useCallback)((promptText) => {
     setPrompt(promptText || DEFAULT_PROMPT);
     setLine("");
+    setCursorPos(0);
     return new Promise((resolve3) => {
       askResolverRef.current = (answer) => {
         setPrompt(DEFAULT_PROMPT);
@@ -64790,43 +64926,107 @@ var App2 = ({ onReady }) => {
   const onLine = (0, import_react35.useCallback)((cb) => {
     onLineRef.current = cb;
   }, []);
+  const onQueuedLine = (0, import_react35.useCallback)((cb) => {
+    onQueuedLineRef.current = cb;
+  }, []);
+  const onInterruptRef = (0, import_react35.useRef)(null);
+  const onInterrupt = (0, import_react35.useCallback)((cb) => {
+    onInterruptRef.current = cb;
+  }, []);
   use_input_default((char, key) => {
-    if (!inputEnabled)
-      return;
     if (key.ctrl && char === "c") {
+      const askResolve = askResolverRef.current;
+      if (askResolve) {
+        askResolverRef.current = null;
+        setLine("");
+        setCursorPos(0);
+        askResolve("n");
+        return;
+      }
+      if (busyRef.current && onInterruptRef.current) {
+        onInterruptRef.current();
+        return;
+      }
       exit();
       return;
     }
     if (key.backspace || key.delete) {
-      setLine((s2) => dropLastGrapheme(s2));
+      if (key.delete) {
+        setLine((s2) => {
+          const pos = cursorRef.current;
+          const end = nextGraphemeBoundary(s2, pos);
+          return s2.slice(0, pos) + s2.slice(end);
+        });
+        return;
+      }
+      setLine((s2) => {
+        const pos = cursorRef.current;
+        if (pos === 0)
+          return s2;
+        const start = prevGraphemeBoundary(s2, pos);
+        setCursorPos(start);
+        return s2.slice(0, start) + s2.slice(pos);
+      });
+      return;
+    }
+    if (key.leftArrow) {
+      setCursorPos((pos) => prevGraphemeBoundary(lineRef.current, pos));
       return;
     }
-    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.tab) {
+    if (key.rightArrow) {
+      setCursorPos((pos) => nextGraphemeBoundary(lineRef.current, pos));
+      return;
+    }
+    if (key.upArrow || key.downArrow || key.tab) {
       return;
     }
     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]/, "");
-      const submitted = lineRef.current + before;
+      const pos = cursorRef.current;
+      const submitted = lineRef.current.slice(0, pos) + before + lineRef.current.slice(pos);
       setLine(after);
+      setCursorPos(0);
       print(prompt2 + submitted);
       const askResolve = askResolverRef.current;
       if (askResolve) {
         askResolverRef.current = null;
         askResolve(submitted);
+      } else if (busyRef.current) {
+        onQueuedLineRef.current?.(submitted);
       } else {
         onLineRef.current?.(submitted);
       }
       return;
     }
-    setLine((s2) => s2 + char);
+    setLine((s2) => {
+      const pos = cursorRef.current;
+      setCursorPos(pos + char.length);
+      return s2.slice(0, pos) + char + s2.slice(pos);
+    });
   });
   import_react35.default.useEffect(() => {
-    onReady({ print, setFooter, setLive, askLine, onLine, setInputEnabled, close: () => exit() });
+    onReady({
+      print,
+      setFooter,
+      setLive,
+      askLine,
+      onLine,
+      onQueuedLine,
+      onInterrupt,
+      setBusy,
+      close: () => exit()
+    });
   }, []);
-  return /* @__PURE__ */ import_react35.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react35.default.createElement(Static, { items }, (item) => /* @__PURE__ */ import_react35.default.createElement(Text, { key: item.id }, item.content)), live ? /* @__PURE__ */ import_react35.default.createElement(Text, null, live) : null, /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, "\u2500".repeat(Math.max(1, columns - 1))), inputEnabled ? /* @__PURE__ */ import_react35.default.createElement(Box_default, null, /* @__PURE__ */ import_react35.default.createElement(Text, null, prompt2), /* @__PURE__ */ import_react35.default.createElement(Text, null, line), /* @__PURE__ */ import_react35.default.createElement(Text, { inverse: true }, " ")) : /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, "  (working\u2026)"), /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, footerText(footer)));
+  return /* @__PURE__ */ import_react35.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react35.default.createElement(Static, { items }, (item) => /* @__PURE__ */ import_react35.default.createElement(Text, { key: item.id }, item.content)), live ? /* @__PURE__ */ import_react35.default.createElement(Text, null, live) : null, /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, "\u2500".repeat(Math.max(1, columns - 1))), /* @__PURE__ */ import_react35.default.createElement(Box_default, null, /* @__PURE__ */ import_react35.default.createElement(Text, null, prompt2), /* @__PURE__ */ import_react35.default.createElement(Text, null, line.slice(0, cursorPos)), /* @__PURE__ */ import_react35.default.createElement(Text, { inverse: true }, line.slice(cursorPos, cursorPos + 1) || " "), /* @__PURE__ */ import_react35.default.createElement(Text, null, line.slice(cursorPos + 1))), /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, footerText(footer), busy ? "  \xB7 agent working\u2026" : ""));
 };
 function startInkTerminal() {
   if (handle)
@@ -64842,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"] }
+      }
     );
   });
 }
@@ -64867,26 +65096,31 @@ var InkReadlineAdapter = class extends EventEmitter3 {
   line = "";
   cursor = 0;
   ink;
-  paused = false;
+  busy = false;
+  pendingInput = [];
   constructor(ink) {
     super();
     this.ink = ink;
     this.ink.onLine((text) => {
-      if (this.paused)
-        return;
       this.emit("line", text);
     });
+    this.ink.onQueuedLine((text) => {
+      this.pendingInput.push(text);
+    });
+    this.ink.onInterrupt(() => {
+      this.emit("interrupt");
+    });
   }
   prompt(_preserveCursor) {
   }
   pause() {
-    this.paused = true;
-    this.ink.setInputEnabled(false);
+    this.busy = true;
+    this.ink.setBusy(true);
     return this;
   }
   resume() {
-    this.paused = false;
-    this.ink.setInputEnabled(true);
+    this.busy = false;
+    this.ink.setBusy(false);
     return this;
   }
   close() {
@@ -64896,6 +65130,21 @@ var InkReadlineAdapter = class extends EventEmitter3 {
   question(query, cb) {
     this.ink.askLine(query).then(cb);
   }
+  /**
+   * Drains and returns every follow-up message the user typed and sent while
+   * `pause()` was active (i.e. during a running agent turn). Intended to be
+   * passed straight through as `AgentLoopOptions.takePendingInput` — see
+   * loop.ts, and the VS Code panel's `_pendingInjections.splice(0)` for the
+   * pattern this mirrors. Returns `[]` when nothing is queued, and empties
+   * the queue on every call so the same follow-up is never folded in twice.
+   */
+  takePendingInput() {
+    return this.pendingInput.splice(0);
+  }
+  /** True while a `pause()`/`resume()` pair is in effect (an agent turn is running). */
+  isBusy() {
+    return this.busy;
+  }
 };
 
 // src/commands/chat.ts
@@ -65103,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({
@@ -65211,7 +65466,7 @@ function formatAgentsList(workDir) {
   }
   return lines.join("\n");
 }
-async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, mode, effort, checkpointManager, onProgress) {
+async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, mode, effort, checkpointManager, onProgress, takePendingInput) {
   let lastUsage;
   const spinner = new Spinner();
   const mdRender = new MarkdownStreamRenderer();
@@ -65252,6 +65507,14 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
     // prompt, and sub-agents inherit the lock.
     planMode: mode === "plan",
     effort,
+    // Claude-Code-style follow-ups: text the user typed and sent WHILE this
+    // turn was already running. inkTerminal.tsx echoes each one into the
+    // transcript itself the moment it's submitted (chronological, matching
+    // the VS Code panel's queueMessage) — so onInjectedInput is intentionally
+    // a no-op here rather than printing it again.
+    takePendingInput,
+    onInjectedInput: () => {
+    },
     // The backend streams a cumulative output-token count (routes/code.js's
     // sendProgress, throttled to ≤5/s) covering thinking, visible text AND
     // tool-argument JSON. This used to be stored in a variable and rendered only
@@ -65569,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();
   }
@@ -65721,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);
@@ -65752,12 +66017,22 @@ ${text}` : "");
     }
   });
   const rl = interactive ? new InkReadlineAdapter(getInkTerminal()) : readline3.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  if (rl instanceof InkReadlineAdapter) {
+    rl.on("interrupt", () => {
+      if (agentRunning) {
+        console.log("\n" + source_default.yellow("  Interrupted."));
+        abortSignal.aborted = true;
+        agentRunning = false;
+      }
+    });
+  }
   setReadlineInterface(rl);
   const updateFooter = () => {
     if (interactive)
       getInkTerminal().setFooter({ mode: agentMode, autoApprove: isYoloMode() });
   };
   updateFooter();
+  const takePendingInput = rl instanceof InkReadlineAdapter ? () => rl.takePendingInput() : void 0;
   let inputBuffer = "";
   rl.on("line", async (rawLine) => {
     if (rawLine.endsWith("\\")) {
@@ -65911,7 +66186,10 @@ ${convText}`;
               env3,
               nexrallMd,
               agentMode,
-              effortLevel
+              effortLevel,
+              void 0,
+              void 0,
+              takePendingInput
             );
             agentRunning = false;
             const summaryText = [...r2.messages].reverse().find((m2) => m2.role === "assistant")?.content[0]?.text ?? "";
@@ -65970,7 +66248,10 @@ ${dirList}`;
               env3,
               nexrallMd,
               "auto",
-              effortLevel
+              effortLevel,
+              void 0,
+              void 0,
+              takePendingInput
             );
             agentRunning = false;
             const content = [...r2.messages].reverse().find((m2) => m2.role === "assistant")?.content[0]?.text ?? "";
@@ -66189,7 +66470,7 @@ ${text}
           abortSignal.aborted = false;
           agentRunning = true;
           try {
-            const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress);
+            const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput);
             messages = result.messages;
             updateTitle();
             saveSession(sessionId, sessionTitle, workDir, messages);
@@ -66309,7 +66590,7 @@ ${text}
           abortSignal.aborted = false;
           agentRunning = true;
           try {
-            const result = await runTurn(messages, turnModel, workDir, abortSignal, env3, nexrallMd, turnMode, effortLevel, checkpoints, saveProgress);
+            const result = await runTurn(messages, turnModel, workDir, abortSignal, env3, nexrallMd, turnMode, effortLevel, checkpoints, saveProgress, takePendingInput);
             messages = result.messages;
             updateTitle();
             saveSession(sessionId, sessionTitle, workDir, messages);
@@ -66333,7 +66614,7 @@ ${text}
     abortSignal.aborted = false;
     agentRunning = true;
     try {
-      const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress);
+      const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput);
       messages = result.messages;
       updateTitle();
       saveSession(sessionId, sessionTitle, workDir, messages);

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.74",
+  "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",