nexrall-code 0.5.23 → 0.5.27

package/dist/index.js

@@ -12673,7 +12673,7 @@ Resolve the conflict (remove <<<<<<< / ======= / >>>>>>> markers and keep the in
     var _bgCounter = 0;
     function startBackgroundShell(command, displayCommand, workDir, note) {
       const id = `bg_${++_bgCounter}`;
-      const child = (0, child_process_1.spawn)(command, { shell: true, cwd: workDir ?? process.cwd(), env: process.env, detached: true });
+      const child = (0, child_process_1.spawn)(command, { shell: true, cwd: workDir ?? process.cwd(), env: process.env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
       const shell = {
         id,
         command: displayCommand,
@@ -12800,7 +12800,7 @@ ${fresh || "(no new output)"}${trunc}` };
       }
       return { output: `Background shell ${id} ${shell.status}.` };
     }
-    async function bash(input, abortSignal, sandbox, workDir) {
+    async function bash(input, abortSignal, sandbox, workDir, onStream) {
       const command = typeof input.command === "string" ? input.command : "";
       const _rawDesc = typeof input.description === "string" ? input.description : "";
       void _rawDesc.slice(0, 200);
@@ -12835,7 +12835,8 @@ ${r2.output}`;
           shell: true,
           cwd: workDir ?? process.cwd(),
           env: process.env,
-          detached: true
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"]
         });
         const killTree = (sig) => {
           try {
@@ -12951,8 +12952,22 @@ ${body}` : void 0 }));
             resolve3(prependNote({ output: body, exitCode: 0 }));
           }
         };
-        child.stdout?.on("data", (chunk) => appendOutput(chunk.toString("utf-8")));
-        child.stderr?.on("data", (chunk) => appendOutput(chunk.toString("utf-8")));
+        child.stdout?.on("data", (chunk) => {
+          const text = chunk.toString("utf-8");
+          appendOutput(text);
+          try {
+            onStream?.(text);
+          } catch {
+          }
+        });
+        child.stderr?.on("data", (chunk) => {
+          const text = chunk.toString("utf-8");
+          appendOutput(text);
+          try {
+            onStream?.(text);
+          } catch {
+          }
+        });
         child.on("close", (code, signal) => done(code, signal));
         child.on("error", (err) => {
           settled = true;
@@ -14148,12 +14163,12 @@ ${expanded}` };
       "memory_read",
       "use_skill"
     ]);
-    async function executeTool(name, input, abortSignal, sandbox, workDir, agentScope) {
+    async function executeTool(name, input, abortSignal, sandbox, workDir, agentScope, onStream) {
       if (!TOOL_MAP[name])
         return { error: `Unknown tool: ${name}` };
       try {
         if (name === "bash")
-          return await bash(input, abortSignal, sandbox, workDir);
+          return await bash(input, abortSignal, sandbox, workDir, input.run_in_background === true ? void 0 : onStream);
         if (name === "todo_write")
           return await todoWrite(input, agentScope);
         if (name === "todo_read")
@@ -14218,7 +14233,7 @@ var require_agentTypes = __commonJS({
       };
     }();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.loadAgentTypes = loadAgentTypes;
+    exports2.loadAgentTypes = loadAgentTypes2;
     exports2.summariseAgents = summariseAgents;
     exports2.findAgentType = findAgentType;
     var fs6 = __importStar(require("fs"));
@@ -14297,7 +14312,7 @@ var require_agentTypes = __commonJS({
         }
       }
     }
-    function loadAgentTypes(workDir) {
+    function loadAgentTypes2(workDir) {
       const out = /* @__PURE__ */ new Map();
       loadDir(path5.join(workDir, ".nexrall", "agents"), "project", out);
       loadDir(path5.join(os5.homedir(), ".nexrall", "agents"), "global", out);
@@ -14718,14 +14733,16 @@ var require_loop = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.VERIFY_CMD_RE = exports2.WRITE_TOOL_NAMES = void 0;
     exports2.resolveMaxIterations = resolveMaxIterations;
-    exports2.estimateBodyBytes = estimateBodyBytes;
+    exports2.contextWindowFor = contextWindowFor2;
+    exports2.compactionThresholds = compactionThresholds2;
+    exports2.estimateBodyBytes = estimateBodyBytes2;
     exports2.findSafeCutIndex = findSafeCutIndex;
     exports2.transcriptOf = transcriptOf;
     exports2.createLedger = createLedger;
     exports2.ledgerRecord = ledgerRecord;
     exports2.ledgerSummary = ledgerSummary;
     exports2.pruneOldToolResults = pruneOldToolResults;
-    exports2.estimateTokensRough = estimateTokensRough;
+    exports2.estimateTokensRough = estimateTokensRough2;
     exports2.compactMessagesForResume = compactMessagesForResume2;
     exports2.runAgentLoop = runAgentLoop2;
     exports2.trimToResumableBoundary = trimToResumableBoundary;
@@ -14961,6 +14978,7 @@ var require_loop = __commonJS({
     }
     var MAX_TASK_DEPTH = 2;
     var _subTaskCounter = 0;
+    var SUBTASK_TIMEOUT_MS = Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) > 0 ? Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) : 10 * 60 * 1e3;
     async function runSubTask(input, options, agentTypes) {
       const prompt2 = typeof input.prompt === "string" ? input.prompt.trim() : "";
       if (!prompt2)
@@ -14990,6 +15008,14 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
       const subMessages = [
         { role: "user", content: [{ type: "text", text: prompt2 }] }
       ];
+      const subAbort = { aborted: false };
+      const timer = setTimeout(() => {
+        subAbort.aborted = true;
+      }, SUBTASK_TIMEOUT_MS);
+      const parentAbortPoll = setInterval(() => {
+        if (options.abortSignal?.aborted)
+          subAbort.aborted = true;
+      }, 250);
       try {
         const result = await runAgentLoop2(subMessages, {
           ...options,
@@ -15000,6 +15026,7 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           // fresh isolated context for sub-agent
           model: agent?.model ?? options.model,
           nexrallMd: subNexrallMd,
+          abortSignal: subAbort,
           requestPermission: gatedPermission,
           onText: () => {
           },
@@ -15025,11 +15052,15 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           // when the name was already labelled, and mixed display concerns into the data layer).
           onToolUse: (n, i2) => options.onToolUse(n, i2, true),
           onToolResult: (n, r2) => options.onToolResult(n, r2, true),
+          onToolStreamChunk: (n, c) => options.onToolStreamChunk?.(n, c, true),
           // Forward thinking so the UI shows the indicator while sub-agent reasons
           onThinking: (text2) => options.onThinking?.(text2),
           onThinkingDelta: (text2) => options.onThinkingDelta?.(text2),
           onThinkingProgress: (tok) => options.onThinkingProgress?.(tok)
         });
+        if (subAbort.aborted && !options.abortSignal?.aborted) {
+          return { error: `Sub-task stalled and was stopped after ${Math.round(SUBTASK_TIMEOUT_MS / 6e4)} minutes with no completion. Consider breaking it into smaller sub-tasks or investigating what it may have been stuck on (a hung command, an unresponsive MCP/tool call, or a very large scope).` };
+        }
         const lastAssistant = [...result].reverse().find((m2) => m2.role === "assistant");
         let text = (lastAssistant?.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("").trim();
         const SUBTASK_MAX = 48e3;
@@ -15045,6 +15076,9 @@ ${tail}`;
         return { output: text || "(sub-task completed with no text output)" };
       } catch (err) {
         return { error: `Sub-task failed: ${err.message}` };
+      } finally {
+        clearTimeout(timer);
+        clearInterval(parentAbortPoll);
       }
     }
     var MODEL_CONTEXT_TOKENS = {
@@ -15052,16 +15086,22 @@ ${tail}`;
       pro: 1e6,
       ultra: 1e6
     };
+    function contextWindowFor2(model) {
+      return MODEL_CONTEXT_TOKENS[model ?? "turbo"] ?? 1e6;
+    }
     function envFraction(name, fallback) {
       const v = Number(process.env[name]);
       return Number.isFinite(v) && v > 0 && v < 1 ? v : fallback;
     }
     var AUTO_PRUNE_THRESHOLD = envFraction("NEXRALL_PRUNE_THRESHOLD", 0.35);
     var AUTO_COMPACT_THRESHOLD = envFraction("NEXRALL_COMPACT_THRESHOLD", 0.8);
+    function compactionThresholds2() {
+      return { prune: AUTO_PRUNE_THRESHOLD, compact: AUTO_COMPACT_THRESHOLD };
+    }
     var PRUNE_MIN_RECLAIM_BYTES = 256 * 1024;
     var COMPACT_KEEP_MIN = 6;
     var MAX_BODY_BYTES = 8 * 1024 * 1024;
-    function estimateBodyBytes(messages) {
+    function estimateBodyBytes2(messages) {
       try {
         return Buffer.byteLength(JSON.stringify(messages), "utf-8");
       } catch {
@@ -15327,8 +15367,8 @@ Continue the work from here.` }] });
       }
     }
     var RESUME_CHARS_PER_TOKEN = 4;
-    function estimateTokensRough(messages) {
-      return Math.ceil(estimateBodyBytes(messages) / RESUME_CHARS_PER_TOKEN);
+    function estimateTokensRough2(messages) {
+      return Math.ceil(estimateBodyBytes2(messages) / RESUME_CHARS_PER_TOKEN);
     }
     async function compactMessagesForResume2(messages, opts) {
       if (messages.length <= COMPACT_KEEP_MIN + 2)
@@ -15337,8 +15377,8 @@ Continue the work from here.` }] });
       if (!resolveAutoCompact(void 0, settings.raw))
         return false;
       const contextWindow = MODEL_CONTEXT_TOKENS[opts.model ?? "turbo"] ?? 1e6;
-      let bodyBytes = estimateBodyBytes(messages);
-      let tokenGuess = estimateTokensRough(messages);
+      let bodyBytes = estimateBodyBytes2(messages);
+      let tokenGuess = estimateTokensRough2(messages);
       const overPruneThreshold = () => tokenGuess > contextWindow * AUTO_PRUNE_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
       const overCompactThreshold = () => tokenGuess > contextWindow * AUTO_COMPACT_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
       if (!overPruneThreshold())
@@ -15347,8 +15387,8 @@ Continue the work from here.` }] });
       if (messages.length > PRUNE_KEEP_RECENT + 2) {
         const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
         if (reclaimed > 0) {
-          bodyBytes = estimateBodyBytes(messages);
-          tokenGuess = estimateTokensRough(messages);
+          bodyBytes = estimateBodyBytes2(messages);
+          tokenGuess = estimateTokensRough2(messages);
           compacted = true;
           opts.onNotice?.(`
 \u267B\uFE0F Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of older tool output before resuming this chat.
@@ -15376,8 +15416,8 @@ Continue the work from here.` }] });
         if (!did)
           break;
         compacted = true;
-        bodyBytes = estimateBodyBytes(messages);
-        tokenGuess = estimateTokensRough(messages);
+        bodyBytes = estimateBodyBytes2(messages);
+        tokenGuess = estimateTokensRough2(messages);
       }
       if (compacted) {
         opts.onNotice?.(`
@@ -15422,14 +15462,14 @@ Continue the work from here.` }] });
         for (; iteration < budget; iteration++) {
           if (options.abortSignal?.aborted)
             break;
-          let bodyBytes = estimateBodyBytes(messages);
+          let bodyBytes = estimateBodyBytes2(messages);
           const prunePressure = lastPromptTokens > contextWindow * AUTO_PRUNE_THRESHOLD;
           const tokenPressure = lastPromptTokens > contextWindow * AUTO_COMPACT_THRESHOLD;
           let bytePressure = bodyBytes > MAX_BODY_BYTES;
           if (autoCompact && !compacting && (prunePressure || bytePressure) && messages.length > PRUNE_KEEP_RECENT + 2) {
             const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
             if (reclaimed > 0) {
-              bodyBytes = estimateBodyBytes(messages);
+              bodyBytes = estimateBodyBytes2(messages);
               bytePressure = bodyBytes > MAX_BODY_BYTES;
               (options.onNotice ?? options.onText)(`\u267B\uFE0F Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of already-processed tool output to keep this chat cheap to continue.`);
             }
@@ -15649,12 +15689,13 @@ Continue the work from here.` }] });
                   } else {
                     options.checkpointManager?.recordBeforeMutation(name, input);
                     const WRITE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "multi_edit", "delete_file", "move_file", "copy_file", "notebook_edit"]);
+                    const onStream = options.onToolStreamChunk ? (chunk) => options.onToolStreamChunk(name, chunk) : void 0;
                     if (WRITE_TOOLS.has(name)) {
                       const targetPath = typeof input.path === "string" ? input.path : typeof input.source === "string" ? input.source : "";
                       const absTarget = targetPath && options.workDir ? path5.resolve(options.workDir, targetPath) : targetPath;
-                      result = await withFileLock(absTarget || name, () => (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope));
+                      result = await withFileLock(absTarget || name, () => (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope, onStream));
                     } else {
-                      result = await (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope);
+                      result = await (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope, onStream);
                     }
                   }
                 } catch (err) {
@@ -16323,7 +16364,7 @@ var require_manager = __commonJS({
     var httpClient_1 = require_httpClient();
     var sseClient_1 = require_sseClient();
     var index_1 = require_plugins();
-    var McpManager = class _McpManager {
+    var McpManager2 = class _McpManager {
       constructor() {
         this._clients = /* @__PURE__ */ new Map();
         this._toolMap = /* @__PURE__ */ new Map();
@@ -16496,7 +16537,7 @@ var require_manager = __commonJS({
         this._needsAuth.clear();
       }
     };
-    exports2.McpManager = McpManager;
+    exports2.McpManager = McpManager2;
   }
 });
 
@@ -23365,6 +23406,49 @@ function formatToolUse(name, input) {
   const argDisplay = primaryArg ? source_default.dim(" ") + source_default.white(String(primaryArg).replace(/\n/g, "\u21B5").slice(0, 80)) : "";
   return source_default.yellow(icons.tool) + " " + source_default.bold(name) + argDisplay;
 }
+var ToolStreamPrinter = class _ToolStreamPrinter {
+  carry = "";
+  linesShown = 0;
+  // Cap visible lines per command so a runaway/very chatty process (e.g. a
+  // build tool re-printing a progress bar thousands of times) doesn't flood
+  // the terminal — the full output is still available afterward via
+  // formatToolResult's summary and, for large output, the spill file.
+  static MAX_LINES = 200;
+  capped = false;
+  feed(chunk) {
+    if (this.capped)
+      return;
+    this.carry += chunk;
+    const lines = this.carry.split("\n");
+    this.carry = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!this.printLine(line))
+        return;
+    }
+  }
+  printLine(line) {
+    if (this.linesShown >= _ToolStreamPrinter.MAX_LINES) {
+      if (!this.capped) {
+        this.capped = true;
+        process.stdout.write(source_default.dim("  \u2502 \u2026 output continues (full log in the result above once finished)\n"));
+      }
+      return false;
+    }
+    this.linesShown++;
+    process.stdout.write(source_default.dim("  \u2502 ") + source_default.gray(line.slice(0, 300)) + "\n");
+    return true;
+  }
+  flush() {
+    if (!this.capped && this.carry)
+      this.printLine(this.carry);
+    this.carry = "";
+  }
+  reset() {
+    this.carry = "";
+    this.linesShown = 0;
+    this.capped = false;
+  }
+};
 function formatToolResult(name, result, durationMs) {
   if (result.error) {
     return source_default.red(icons.cross) + " " + source_default.dim(name) + source_default.dim(" \xB7 ") + source_default.red("error") + source_default.dim(` \xB7 ${durationMs}ms`);
@@ -23385,6 +23469,77 @@ function formatUsage(outputTokens) {
   return source_default.dim(`\u2193 ${tok} tokens`);
 }
 
+// src/ui/paste.ts
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+function enableBracketedPaste() {
+  if (process.stdout.isTTY)
+    process.stdout.write("\x1B[?2004h");
+}
+function disableBracketedPaste() {
+  if (process.stdout.isTTY)
+    process.stdout.write("\x1B[?2004l");
+}
+function installPasteHandling(rl, stdin) {
+  const originalListeners = stdin.listeners("data");
+  for (const l of originalListeners)
+    stdin.removeListener("data", l);
+  const forward = (buf) => {
+    if (!buf.length)
+      return;
+    for (const l of originalListeners)
+      l.call(stdin, buf);
+  };
+  let buffering = false;
+  let buffer = "";
+  const insertPastedText = (text) => {
+    if (!text)
+      return;
+    const flattened = text.replace(/\r\n|\r|\n/g, " ");
+    const anyRl = rl;
+    if (typeof anyRl._insertString === "function") {
+      anyRl._insertString(flattened);
+    } else {
+      rl.write(flattened);
+    }
+  };
+  const onData = (chunk) => {
+    let text = chunk.toString("utf-8");
+    for (; ; ) {
+      if (!buffering) {
+        const startIdx = text.indexOf(PASTE_START);
+        if (startIdx === -1) {
+          forward(Buffer.from(text, "utf-8"));
+          return;
+        }
+        const before = text.slice(0, startIdx);
+        forward(Buffer.from(before, "utf-8"));
+        text = text.slice(startIdx + PASTE_START.length);
+        buffering = true;
+        buffer = "";
+      }
+      const endIdx = text.indexOf(PASTE_END);
+      if (endIdx === -1) {
+        buffer += text;
+        return;
+      }
+      buffer += text.slice(0, endIdx);
+      insertPastedText(buffer);
+      buffer = "";
+      buffering = false;
+      text = text.slice(endIdx + PASTE_END.length);
+      if (!text)
+        return;
+    }
+  };
+  stdin.on("data", onData);
+  return () => {
+    stdin.removeListener("data", onData);
+    for (const l of originalListeners)
+      stdin.on("data", l);
+  };
+}
+
 // src/permissions/handler.ts
 var readline2 = __toESM(require("readline"));
 var fs2 = __toESM(require("fs"));
@@ -24166,7 +24321,7 @@ async function requestPermission(req) {
 var fs3 = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os2 = __toESM(require("os"));
-var SESSIONS_DIR = path.join(os2.homedir(), ".nexrall", "cli-sessions");
+var SESSIONS_DIR = process.env.NEXRALL_CLI_SESSIONS_DIR || path.join(os2.homedir(), ".nexrall", "cli-sessions");
 function ensureDir() {
   fs3.mkdirSync(SESSIONS_DIR, { recursive: true });
 }
@@ -24482,10 +24637,17 @@ var Spinner = class {
   interval = null;
   frames = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
   i = 0;
+  startedAt = 0;
+  baseText = "";
   start(text) {
     this.stop();
+    this.baseText = text;
+    this.startedAt = Date.now();
     this.interval = setInterval(() => {
-      process.stdout.write(`\r${source_default.cyan(this.frames[this.i % this.frames.length])} ${source_default.dim(text)}`);
+      const elapsedSec = Math.floor((Date.now() - this.startedAt) / 1e3);
+      const timer = source_default.dim(` (${elapsedSec}s)`);
+      const hint = elapsedSec >= 15 ? source_default.dim("  \xB7 still running, no output yet is normal for quiet commands") : "";
+      process.stdout.write(`\r\x1B[K${source_default.cyan(this.frames[this.i % this.frames.length])} ${source_default.dim(this.baseText)}${timer}${hint}`);
       this.i++;
     }, 100);
   }
@@ -24500,10 +24662,71 @@ var Spinner = class {
     return this.interval !== null;
   }
 };
+var _mcpManager = null;
+var _mcpConfig = null;
+async function initMcp(workDir) {
+  _mcpConfig = import_code_core3.McpManager.loadConfig(workDir);
+  if (Object.keys(_mcpConfig.mcpServers).length === 0) {
+    _mcpManager = null;
+    return;
+  }
+  const manager = new import_code_core3.McpManager();
+  await manager.connectAll(_mcpConfig);
+  _mcpManager = manager;
+}
+function formatMcpStatus() {
+  if (!_mcpConfig || Object.keys(_mcpConfig.mcpServers).length === 0) {
+    return source_default.dim("  No MCP servers configured. Add one to .nexrall/mcp.json or ~/.nexrall/mcp.json.");
+  }
+  if (!_mcpManager)
+    return source_default.dim("  MCP servers configured but not connected.");
+  const rows = _mcpManager.getStatus();
+  const lines = rows.map((s2) => {
+    if (s2.connected) {
+      return "  " + source_default.green("\u25CF") + " " + source_default.bold(s2.name) + source_default.dim(` (${s2.transport}) \u2014 ${s2.tools.length} tool(s)`);
+    }
+    const authNote = s2.needsAuth ? source_default.yellow(" [needs OAuth \u2014 not supported in CLI yet, add a static Authorization header]") : "";
+    return "  " + source_default.red("\u25CF") + " " + source_default.bold(s2.name) + source_default.dim(` (${s2.transport}) \u2014 `) + source_default.red(s2.error ?? "failed to connect") + authNote;
+  });
+  return lines.join("\n");
+}
+function formatContextUsage(messages, modelAlias) {
+  const window = (0, import_code_core3.contextWindowFor)(modelAlias);
+  const tokens = (0, import_code_core3.estimateTokensRough)(messages);
+  const bytes = (0, import_code_core3.estimateBodyBytes)(messages);
+  const { prune, compact } = (0, import_code_core3.compactionThresholds)();
+  const pct = Math.min(100, tokens / window * 100);
+  const barWidth = 30;
+  const filled = Math.round(pct / 100 * barWidth);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+  const barColor = pct >= compact * 100 ? source_default.red : pct >= prune * 100 ? source_default.yellow : source_default.green;
+  const lines = [
+    "",
+    "  " + source_default.bold("Context usage"),
+    "  " + barColor(bar) + source_default.dim(`  ~${pct.toFixed(1)}%`),
+    source_default.dim(`  ~${tokens.toLocaleString()} / ${window.toLocaleString()} tokens (rough estimate)  \xB7  ${(bytes / 1024).toFixed(0)}KB serialized  \xB7  ${messages.length} messages`),
+    source_default.dim(`  auto-prune at ~${(prune * 100).toFixed(0)}%  \xB7  auto-compact (summarise) at ~${(compact * 100).toFixed(0)}%`),
+    ""
+  ];
+  return lines.join("\n");
+}
+function formatAgentsList(workDir) {
+  const types3 = (0, import_code_core3.loadAgentTypes)(workDir);
+  if (!types3.length)
+    return source_default.dim("  No agent types found (this should not happen \u2014 builtins always register).");
+  const lines = types3.map((t2) => {
+    const tools = t2.tools ? source_default.dim(` \u2014 tools: ${t2.tools.join(", ")}`) : source_default.dim(" \u2014 all tools");
+    const model = t2.model ? source_default.dim(` \u2014 model: ${t2.model}`) : "";
+    const scope = source_default.dim(` (${t2.source})`);
+    return "  " + source_default.cyan(t2.name.padEnd(16)) + source_default.white(t2.description) + scope + tools + model;
+  });
+  return lines.join("\n");
+}
 async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrallMd, mode, effort, checkpointManager, onProgress) {
   let lastUsage;
   const spinner = new Spinner();
   const mdRender = new MarkdownStreamRenderer();
+  const toolStream = new ToolStreamPrinter();
   let toolStartTime = 0;
   let lastToolName = "";
   let thinkingTokens = 0;
@@ -24551,14 +24774,27 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrall
         return;
       mdRender.flush();
       spinner.stop();
+      toolStream.reset();
       process.stdout.write("\n");
       console.log(formatToolUse(name, input));
       lastToolName = name;
       toolStartTime = Date.now();
       spinner.start(`running ${name}\u2026`);
     },
+    // Live progress for foreground bash: the FIRST chunk stops the "running…"
+    // spinner (which would otherwise overwrite/interleave badly with printed
+    // lines) and every subsequent chunk streams straight to the terminal —
+    // see ToolStreamPrinter for the line-buffering/cap logic.
+    onToolStreamChunk: (_name, chunk) => {
+      if (abortSignal.aborted)
+        return;
+      if (spinner.active)
+        spinner.stop();
+      toolStream.feed(chunk);
+    },
     onToolResult: (_name, res) => {
       spinner.stop();
+      toolStream.flush();
       const durationMs = Date.now() - toolStartTime;
       console.log(formatToolResult(lastToolName, res, durationMs));
       toolStartTime = 0;
@@ -24610,7 +24846,8 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrall
     },
     requestPermission,
     checkpointManager,
-    onProgress
+    onProgress,
+    mcpManager: _mcpManager ?? void 0
   });
   mdRender.flush();
   spinner.stop();
@@ -24650,6 +24887,13 @@ async function runTurnHeadless(messages, modelAlias, workDir, _abortSignal, env2
     onToolUse: (name, input) => {
       emit({ type: "tool_use", tool: name, input });
     },
+    // Live bash progress for scripted/CI consumers — lets a wrapper tail a
+    // long-running build/test command instead of blocking silently until
+    // tool_result. Chunk is raw and un-truncated (unlike the final result,
+    // which is head/tail-capped), so a chatty command can emit many of these.
+    onToolStreamChunk: (name, chunk) => {
+      emit({ type: "tool_stream", tool: name, chunk });
+    },
     onToolResult: (name, res) => {
       toolCallCount++;
       emit({ type: "tool_result", tool: name, ok: res.error === void 0, ...res.error ? { error: res.error } : {} });
@@ -24688,7 +24932,8 @@ async function runTurnHeadless(messages, modelAlias, workDir, _abortSignal, env2
       return true;
     },
     checkpointManager,
-    onProgress
+    onProgress,
+    mcpManager: _mcpManager ?? void 0
   });
   if (format === "json") {
     process.stdout.write(JSON.stringify({
@@ -24723,8 +24968,12 @@ function printHelp() {
     ["/yolo", "Auto-approve all permissions"],
     ["/balance", "Show wallet balance"],
     ["/add <filepath>", "Add a file to conversation context"],
+    ["/image <filepath> [caption]", "Attach an image or PDF (png/jpg/gif/webp/pdf, max 10MB) and send it to the model"],
     ["/skills", "List skills (.nexrall/skills/<name>/SKILL.md or .nexrall/commands/*.md) \u2014 the model can also auto-invoke these"],
     ["/plugins", "List installed plugins (.nexrall/plugins/)"],
+    ["/mcp", "Show MCP server connection status"],
+    ["/agents", "List available sub-agent types (for the task tool)"],
+    ["/context", "Show context window usage for this conversation"],
     ["/update", "Update nex to the latest version"]
   ];
   for (const [cmd, desc] of cmds) {
@@ -24785,6 +25034,15 @@ async function startChatSession(options) {
   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)"));
+    }
+  } catch {
+  }
   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);
@@ -24925,6 +25183,9 @@ ${text}` : "");
     prompt: colors.primary.bold("> ")
   });
   setReadlineInterface(rl);
+  enableBracketedPaste();
+  process.on("exit", disableBracketedPaste);
+  const uninstallPasteHandling = installPasteHandling(rl, process.stdin);
   rl.prompt();
   let inputBuffer = "";
   rl.on("line", async (rawLine) => {
@@ -25283,6 +25544,80 @@ ${content}
           rl.prompt();
           return;
         }
+        case "/image": {
+          if (agentRunning) {
+            console.log(source_default.red("  Cannot attach while agent is running."));
+            rl.prompt();
+            return;
+          }
+          if (!arg) {
+            console.log(source_default.red("  Usage: /image <filepath> [caption]"));
+            rl.prompt();
+            return;
+          }
+          const [rawPath, ...captionParts] = arg.split(/\s+/);
+          const caption = captionParts.join(" ").trim();
+          const filePath = path3.isAbsolute(rawPath) ? rawPath : path3.join(workDir, rawPath);
+          const ext = path3.extname(filePath).toLowerCase();
+          const IMAGE_MIME = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp"
+          };
+          const isPdf = ext === ".pdf";
+          const mimeType = IMAGE_MIME[ext];
+          if (!mimeType && !isPdf) {
+            console.log(source_default.red(`  Unsupported file type: ${ext || "(none)"}. Supported: png, jpg, jpeg, gif, webp, pdf.`));
+            rl.prompt();
+            return;
+          }
+          let buf;
+          try {
+            buf = fs5.readFileSync(filePath);
+          } catch (err) {
+            console.error(source_default.red("  Failed: ") + String(err.message));
+            rl.prompt();
+            return;
+          }
+          const MAX_BYTES = 10 * 1024 * 1024;
+          if (buf.length > MAX_BYTES) {
+            console.log(source_default.red(`  File too large (${(buf.length / 1024 / 1024).toFixed(1)}MB) \u2014 max 10MB.`));
+            rl.prompt();
+            return;
+          }
+          const rel = path3.relative(workDir, filePath);
+          const data = buf.toString("base64");
+          const label = caption ? `[Attached: ${rel}]
+${caption}` : `[Attached: ${rel}]`;
+          const content = [{ type: "text", text: label }];
+          content.push(
+            isPdf ? { type: "document", source: { type: "base64", media_type: "application/pdf", data } } : { type: "image", source: { type: "base64", media_type: mimeType, data } }
+          );
+          console.log(source_default.dim(`  Attached ${rel} (${(buf.length / 1024).toFixed(0)}KB) \u2014 sending\u2026`));
+          checkpoints.beginTurn(`/image ${rel}${caption ? " " + caption : ""}`, messages.length);
+          messages.push({ role: "user", content });
+          rl.pause();
+          abortSignal.aborted = false;
+          agentRunning = true;
+          try {
+            const result = await runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrallMd, agentMode, effortLevel, checkpoints, saveProgress);
+            messages = result.messages;
+            updateTitle();
+            saveSession(sessionId, sessionTitle, workDir, messages);
+          } catch (err) {
+            messages = recoverTurn(err, messages);
+            updateTitle();
+            saveSession(sessionId, sessionTitle || "Untitled", workDir, messages);
+          } finally {
+            agentRunning = false;
+            checkpoints.commitTurn();
+          }
+          rl.resume();
+          rl.prompt();
+          return;
+        }
         case "/update": {
           rl.close();
           await updateCommand({ yes: false });
@@ -25306,6 +25641,29 @@ ${content}
           rl.prompt();
           return;
         }
+        case "/mcp": {
+          console.log();
+          console.log(source_default.bold("  MCP servers:"));
+          console.log(formatMcpStatus());
+          console.log();
+          rl.prompt();
+          return;
+        }
+        case "/agents": {
+          console.log();
+          console.log(source_default.bold("  Sub-agent types (used by the `task` tool):"));
+          console.log(formatAgentsList(workDir));
+          console.log();
+          console.log(source_default.dim("  Define your own in .nexrall/agents/<name>.md or ~/.nexrall/agents/<name>.md"));
+          console.log();
+          rl.prompt();
+          return;
+        }
+        case "/context": {
+          console.log(formatContextUsage(messages, modelAlias));
+          rl.prompt();
+          return;
+        }
         case "/skills":
         case "/commands": {
           skills = (0, import_code_core3.loadSkills)(workDir);
@@ -25383,6 +25741,7 @@ ${content}
     rl.prompt();
   });
   rl.on("close", () => {
+    uninstallPasteHandling();
     updateTitle();
     if (messages.length)
       saveSession(sessionId, sessionTitle || "Untitled", workDir, messages);
@@ -25596,7 +25955,7 @@ function pluginListCommand() {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.23");
+program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.27");
 program2.command("auth").description("Login to your Nexrall account").action(authCommand);
 program2.command("logout").description("Log out of your Nexrall account").action(logoutCommand);
 program2.command("update").description("Update nex to the latest version").option("-c, --check", "Check for updates without installing").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.23",
+  "version": "0.5.27",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",
@@ -37,7 +37,7 @@
     "ora": "^8.0.1",
     "prompts": "^2.4.2",
     "readline": "^1.3.0",
-    "@nexrall/code-core": "1.4.18"
+    "@nexrall/code-core": "1.4.21"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.600.0",
@@ -52,6 +52,7 @@
     "build": "node build.js",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
+    "test": "tsc --noEmit && tsc --noEmit -p test/tsconfig.json && node --import tsx --test test/*.test.ts test/*.test.mts",
     "release": "node build.js && node scripts/upload-release.js"
   }
 }