nexrall-code 0.5.75 → 0.5.78

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) {
@@ -55721,7 +55817,18 @@ function prepareSessionScreen() {
     return;
   process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
 }
-var BOTTOM_CHROME_ROWS = 3;
+function bottomChromeRows(opts = {
+  footerText: ""
+}) {
+  const columns = opts.columns ?? process.stdout.columns ?? 80;
+  const separatorRows = 1;
+  const inputRows = rowsOccupied(
+    " ".repeat(opts.promptWidth ?? 2) + (opts.inputText ?? ""),
+    columns
+  );
+  const footerRows = rowsOccupied(opts.footerText, columns);
+  return separatorRows + inputRows + footerRows;
+}
 function rowsOccupied(text, columns = process.stdout.columns || 80) {
   let rows = 0;
   for (const line of text.split("\n")) {
@@ -55730,11 +55837,12 @@ function rowsOccupied(text, columns = process.stdout.columns || 80) {
   }
   return rows;
 }
-function padToBottom(rowsAlreadyPrinted) {
+function padToBottom(rowsAlreadyPrinted, footerText2 = "") {
   const rows = process.stdout.rows;
   if (!process.stdout.isTTY || !rows)
     return;
-  const filler = rows - rowsAlreadyPrinted - BOTTOM_CHROME_ROWS - 2;
+  const chromeRows = bottomChromeRows({ footerText: footerText2, columns: process.stdout.columns ?? 80 });
+  const filler = rows - rowsAlreadyPrinted - chromeRows - 2;
   const MIN_WORTHWHILE_FILLER = 3;
   if (filler < MIN_WORTHWHILE_FILLER)
     return;
@@ -55745,19 +55853,26 @@ function startRowCount() {
   if (rowCounter)
     return;
   const columns = process.stdout.columns || 80;
-  const original = console.log;
-  const state = { rows: 0, original };
+  const originalLog = console.log;
+  const originalError = console.error;
+  const state = { rows: 0, originalLog, originalError };
   rowCounter = state;
+  const measure = (args) => args.length === 0 ? 1 : rowsOccupied(args.map(String).join(" "), columns);
   console.log = (...args) => {
-    state.rows += args.length === 0 ? 1 : rowsOccupied(args.map(String).join(" "), columns);
-    original(...args);
+    state.rows += measure(args);
+    originalLog(...args);
+  };
+  console.error = (...args) => {
+    state.rows += measure(args);
+    originalError(...args);
   };
 }
 function stopRowCount() {
   if (!rowCounter)
     return 0;
-  const { rows, original } = rowCounter;
-  console.log = original;
+  const { rows, originalLog, originalError } = rowCounter;
+  console.log = originalLog;
+  console.error = originalError;
   rowCounter = null;
   return rows;
 }
@@ -64777,6 +64892,26 @@ function nextGraphemeBoundary(text, pos) {
   }
   return text.length;
 }
+function renderInputSlices(line, cursorPos) {
+  const end = nextGraphemeBoundary(line, cursorPos);
+  return {
+    before: line.slice(0, cursorPos),
+    atCursor: line.slice(cursorPos, end) || " ",
+    after: line.slice(end)
+  };
+}
+var CTRL_C_QUIT_WINDOW_MS = 3e3;
+var CTRL_C_HINT = "Press Ctrl+C again to exit";
+function decideCtrlC(state) {
+  if (state.hasPendingQuestion)
+    return "answer-prompt";
+  if (state.busy)
+    return "interrupt-turn";
+  if (state.quitArmedAt !== null && state.now - state.quitArmedAt <= CTRL_C_QUIT_WINDOW_MS) {
+    return "quit";
+  }
+  return "arm-quit";
+}
 var handle = null;
 var inkInstance = null;
 var idCounter = 0;
@@ -64806,6 +64941,12 @@ var App2 = ({ onReady }) => {
   const onLineRef = (0, import_react35.useRef)(null);
   const onQueuedLineRef = (0, import_react35.useRef)(null);
   const busyRef = (0, import_react35.useRef)(false);
+  const [quitArmed, setQuitArmedState] = (0, import_react35.useState)(null);
+  const quitArmedAtRef = (0, import_react35.useRef)(null);
+  const setQuitArmed = (0, import_react35.useCallback)((at) => {
+    quitArmedAtRef.current = at;
+    setQuitArmedState(at);
+  }, []);
   const [live, setLiveState] = (0, import_react35.useState)("");
   const print = (0, import_react35.useCallback)((text) => {
     setItems((prev) => [...prev, { id: idCounter++, content: text }]);
@@ -64837,23 +64978,49 @@ var App2 = ({ onReady }) => {
   const onInterrupt = (0, import_react35.useCallback)((cb) => {
     onInterruptRef.current = cb;
   }, []);
+  const onExitRef = (0, import_react35.useRef)(null);
+  const onExit = (0, import_react35.useCallback)((cb) => {
+    onExitRef.current = cb;
+  }, []);
+  const exitedRef = (0, import_react35.useRef)(false);
+  const requestExit = (0, import_react35.useCallback)((notify) => {
+    if (exitedRef.current)
+      return;
+    exitedRef.current = true;
+    if (notify)
+      onExitRef.current?.();
+    exit();
+  }, []);
   use_input_default((char, key) => {
     if (key.ctrl && char === "c") {
-      const askResolve = askResolverRef.current;
-      if (askResolve) {
+      const action = decideCtrlC({
+        hasPendingQuestion: askResolverRef.current !== null,
+        busy: busyRef.current && onInterruptRef.current !== null,
+        quitArmedAt: quitArmedAtRef.current,
+        now: Date.now()
+      });
+      if (action === "answer-prompt") {
+        const askResolve = askResolverRef.current;
         askResolverRef.current = null;
         setLine("");
         setCursorPos(0);
         askResolve("n");
         return;
       }
-      if (busyRef.current && onInterruptRef.current) {
-        onInterruptRef.current();
+      if (action === "interrupt-turn") {
+        setQuitArmed(null);
+        onInterruptRef.current?.();
+        return;
+      }
+      if (action === "arm-quit") {
+        setQuitArmed(Date.now());
         return;
       }
-      exit();
+      requestExit(true);
       return;
     }
+    if (quitArmedAtRef.current !== null)
+      setQuitArmed(null);
     if (key.backspace || key.delete) {
       if (key.delete) {
         setLine((s2) => {
@@ -64886,6 +65053,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]/, "");
@@ -64920,11 +65093,13 @@ var App2 = ({ onReady }) => {
       onLine,
       onQueuedLine,
       onInterrupt,
+      onExit,
       setBusy,
-      close: () => exit()
+      close: () => requestExit(false)
     });
   }, []);
-  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" : ""));
+  const slices = renderInputSlices(line, cursorPos);
+  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, slices.before), /* @__PURE__ */ import_react35.default.createElement(Text, { inverse: true }, slices.atCursor), /* @__PURE__ */ import_react35.default.createElement(Text, null, slices.after)), quitArmed !== null ? /* @__PURE__ */ import_react35.default.createElement(Text, { color: "yellow" }, CTRL_C_HINT) : /* @__PURE__ */ import_react35.default.createElement(Text, { dimColor: true }, footerText(footer), busy ? "  \xB7 agent working\u2026" : ""));
 };
 function startInkTerminal() {
   if (handle)
@@ -64940,7 +65115,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"] }
+      }
     );
   });
 }
@@ -64979,6 +65183,9 @@ var InkReadlineAdapter = class extends EventEmitter3 {
     this.ink.onInterrupt(() => {
       this.emit("interrupt");
     });
+    this.ink.onExit(() => {
+      this.emit("close");
+    });
   }
   prompt(_preserveCursor) {
   }
@@ -65221,23 +65428,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 +65908,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();
   }
@@ -65729,15 +65944,20 @@ Set ${TRUST_ENV_VAR}=1 to confirm non-interactively, or run \`nex\` interactivel
   let skills = (0, import_code_core3.loadSkills)(workDir);
   if (skills.length && !headless)
     console.log(source_default.dim(`  ${skills.length} skill(s) loaded`));
-  try {
-    await initMcp(workDir);
-    const connected = _mcpManager?.serverNames.length ?? 0;
-    const total = _mcpConfig ? Object.keys(_mcpConfig.mcpServers).length : 0;
-    if (total && !headless) {
-      console.log(source_default.dim(`  ${connected}/${total} MCP server(s) connected`) + source_default.dim("  (/mcp for details)"));
+  const mcpStarted = (async () => {
+    try {
+      await initMcp(workDir);
+      const connected = _mcpManager?.serverNames.length ?? 0;
+      const total = _mcpConfig ? Object.keys(_mcpConfig.mcpServers).length : 0;
+      if (total && !headless) {
+        console.log(source_default.dim(`  ${connected}/${total} MCP server(s) connected`) + source_default.dim("  (/mcp for details)"));
+      }
+    } catch {
     }
-  } catch {
-  }
+  })();
+  const mcpReady = () => mcpStarted;
+  if (!interactive)
+    await mcpStarted;
   if (headless && !options.prompt && !options.stdinText) {
     process.stdout.write(JSON.stringify({ type: "error", error: "--output-format json/stream-json requires a one-shot prompt (or piped stdin)." }) + "\n");
     process.exit(1);
@@ -65847,7 +66067,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);
@@ -65860,7 +66080,7 @@ ${text}` : "");
   console.log();
   if (interactive) {
     await flushInkFrame();
-    padToBottom(stopRowCount());
+    padToBottom(stopRowCount(), footerText({ mode: agentMode, autoApprove: isYoloMode() }));
   }
   let agentRunning = false;
   const abortSignal = { aborted: false };
@@ -66330,6 +66550,7 @@ ${text}
           rl.pause();
           abortSignal.aborted = false;
           agentRunning = true;
+          await mcpReady();
           try {
             const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput);
             messages = result.messages;
@@ -66371,6 +66592,7 @@ ${text}
           return;
         }
         case "/mcp": {
+          await mcpReady();
           console.log();
           console.log(source_default.bold("  MCP servers:"));
           console.log(formatMcpStatus());
@@ -66450,6 +66672,7 @@ ${text}
           rl.pause();
           abortSignal.aborted = false;
           agentRunning = true;
+          await mcpReady();
           try {
             const result = await runTurn(messages, turnModel, workDir, abortSignal, env3, nexrallMd, turnMode, effortLevel, checkpoints, saveProgress, takePendingInput);
             messages = result.messages;
@@ -66474,6 +66697,7 @@ ${text}
     rl.pause();
     abortSignal.aborted = false;
     agentRunning = true;
+    await mcpReady();
     try {
       const result = await runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress, takePendingInput);
       messages = result.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.75",
+  "version": "0.5.78",
   "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.46",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "diff": "^5.2.0",