nolo-cli 0.1.48 → 0.1.50

package/index.js

@@ -1576,6 +1576,26 @@ function formatToolMessageContent(args2) {
 [tool metadata]
 ${JSON.stringify(args2.metadata)}`;
 }
+function buildUserAction(args2) {
+  const rawAction = args2.metadata?.requiresUserAction;
+  if (!rawAction || typeof rawAction !== "object" || Array.isArray(rawAction)) return null;
+  const action = rawAction;
+  if (action.type !== "terminal_command") return null;
+  if (!Array.isArray(action.argv)) return null;
+  const argv = action.argv.flatMap(
+    (item) => typeof item === "string" && item.trim() ? [item.trim()] : []
+  );
+  if (argv.length === 0) return null;
+  return {
+    type: "terminal_command",
+    toolName: args2.toolName,
+    toolCallId: args2.toolCallId,
+    argv,
+    ...typeof action.displayCommand === "string" ? { displayCommand: action.displayCommand } : {},
+    ...typeof action.reason === "string" ? { reason: action.reason, message: action.reason } : {},
+    ...typeof action.resumeHint === "string" ? { resumeHint: action.resumeHint } : {}
+  };
+}
 function summarizeHistoricalToolContent(content) {
   if (typeof content !== "string") return content;
   if (content.length <= MAX_HISTORICAL_TOOL_CONTENT_CHARS) return content;
@@ -1677,6 +1697,17 @@ async function runLocalAgentTurn(input2) {
           arguments: toolCall.function.arguments,
           ...userInputText ? { userInput: userInputText } : {}
         });
+        const userAction = buildUserAction({
+          toolName,
+          toolCallId: toolCall.id,
+          metadata: toolResult.metadata
+        });
+        if (userAction && input2.onUserAction) {
+          const replacement = await input2.onUserAction(userAction);
+          if (replacement) {
+            toolResult = replacement;
+          }
+        }
         emitToolEvent(input2, {
           type: "tool-result",
           round,
@@ -3436,6 +3467,35 @@ function accumulateToolCallDelta(accumulated, deltas) {
 function finalizeAccumulatedToolCalls(accumulated) {
   return Object.keys(accumulated).map((key2) => accumulated[Number(key2)]).filter((call) => call?.function?.name);
 }
+function processOpenAiCompatibleSseEvent(event, state) {
+  for (const line of event.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    if (parsed?.usage && typeof parsed.usage === "object") {
+      state.usage = parsed.usage;
+    }
+    const delta = parsed?.choices?.[0]?.delta;
+    if (!delta || typeof delta !== "object") continue;
+    const reasoningChunk = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
+    if (reasoningChunk) state.reasoning += reasoningChunk;
+    if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+      accumulateToolCallDelta(state.accumulatedToolCalls, delta.tool_calls);
+    }
+    const textChunk = typeof delta.content === "string" ? delta.content : "";
+    if (textChunk) {
+      state.content += textChunk;
+      state.onTextDelta?.(textChunk);
+    }
+  }
+}
 async function readOpenAiCompatibleSseCompletion(args2) {
   const reader = args2.response.body?.getReader();
   if (!reader) {
@@ -3443,10 +3503,13 @@ async function readOpenAiCompatibleSseCompletion(args2) {
   }
   const decoder = new TextDecoder();
   let buffer = "";
-  let content = "";
-  let reasoning = "";
-  let usage2;
-  const accumulatedToolCalls = {};
+  const state = {
+    content: "",
+    reasoning: "",
+    usage: void 0,
+    accumulatedToolCalls: {},
+    onTextDelta: args2.onTextDelta
+  };
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
@@ -3456,41 +3519,19 @@ async function readOpenAiCompatibleSseCompletion(args2) {
       if (boundary === -1) break;
       const event = buffer.slice(0, boundary);
       buffer = buffer.slice(boundary + 2);
-      for (const line of event.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:")) continue;
-        const payload = trimmed.slice(5).trim();
-        if (!payload || payload === "[DONE]") continue;
-        let parsed;
-        try {
-          parsed = JSON.parse(payload);
-        } catch {
-          continue;
-        }
-        if (parsed?.usage && typeof parsed.usage === "object") {
-          usage2 = parsed.usage;
-        }
-        const delta = parsed?.choices?.[0]?.delta;
-        if (!delta || typeof delta !== "object") continue;
-        const reasoningChunk = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
-        if (reasoningChunk) reasoning += reasoningChunk;
-        if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
-          accumulateToolCallDelta(accumulatedToolCalls, delta.tool_calls);
-        }
-        const textChunk = typeof delta.content === "string" ? delta.content : "";
-        if (textChunk) {
-          content += textChunk;
-          args2.onTextDelta?.(textChunk);
-        }
-      }
+      processOpenAiCompatibleSseEvent(event, state);
     }
   }
-  const tool_calls = finalizeAccumulatedToolCalls(accumulatedToolCalls);
+  buffer += decoder.decode();
+  if (buffer.trim()) {
+    processOpenAiCompatibleSseEvent(buffer, state);
+  }
+  const tool_calls = finalizeAccumulatedToolCalls(state.accumulatedToolCalls);
   return {
-    content,
-    ...reasoning ? { reasoning_content: reasoning } : {},
+    content: state.content,
+    ...state.reasoning ? { reasoning_content: state.reasoning } : {},
     ...tool_calls.length > 0 ? { tool_calls } : {},
-    ...usage2 ? { usage: usage2 } : {}
+    ...state.usage ? { usage: state.usage } : {}
   };
 }
 async function executeOpenAiCompatibleChatCompletion(args2) {
@@ -5121,6 +5162,81 @@ function readTrimmedString(value) {
 function readFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function resolveExecShellTimeoutMs(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return override;
+  }
+  const raw = process.env[EXEC_SHELL_TIMEOUT_ENV];
+  if (raw !== void 0) {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return void 0;
+}
+function tokenizeShellPrefix(command2) {
+  const tokens = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s"'|;&<>]+)/g;
+  let match;
+  while (match = pattern.exec(command2)) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+  }
+  return tokens;
+}
+function extractInteractiveGhAuthCommand(command2) {
+  const tokens = tokenizeShellPrefix(command2);
+  if (tokens[0] !== "gh" || tokens[1] !== "auth") return null;
+  const subcommand = tokens[2];
+  if (subcommand !== "login" && subcommand !== "refresh") return null;
+  if (tokens.includes("--help")) return null;
+  const result = ["gh", "auth", subcommand];
+  for (let index = 3; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-h" || token === "--hostname" || token === "-s" || token === "--scopes" || token === "--remove-scopes" || token === "-r") {
+      const value = tokens[index + 1];
+      if (value) {
+        result.push(token, value);
+        index += 1;
+      }
+      continue;
+    }
+    if (token === "--clipboard" || token === "-c" || token === "--insecure-storage" || token === "--reset-scopes") {
+      result.push(token);
+      continue;
+    }
+    if (token.startsWith("--hostname=") || token.startsWith("--scopes=") || token.startsWith("--remove-scopes=")) {
+      result.push(token);
+      continue;
+    }
+  }
+  return result.join(" ");
+}
+function splitShellWords(command2) {
+  return tokenizeShellPrefix(command2);
+}
+function buildInteractiveCommandBlockedResult(command2) {
+  const argv = splitShellWords(command2);
+  return {
+    content: [
+      "requires_user_action: terminal_command",
+      `command: ${command2}`,
+      "Run this in the current TUI terminal, then resume the agent turn.",
+      "exitCode: 130"
+    ].join("\n"),
+    metadata: {
+      exitCode: 130,
+      timedOut: false,
+      requiresUserAction: {
+        type: "terminal_command",
+        argv,
+        displayCommand: command2,
+        reason: "This command requires an interactive terminal.",
+        resumeHint: "Continue after the terminal command exits."
+      },
+      reason: "interactive-command-requires-terminal"
+    }
+  };
+}
 function extractActivityRefs(rawRefs) {
   if (!Array.isArray(rawRefs)) return void 0;
   const refs = rawRefs.flatMap((entry) => {
@@ -6792,6 +6908,18 @@ async function previewLifecycleTool(args2) {
 async function execShellTool(args2) {
   const parsed = parseWorkspaceToolArguments(args2.call.arguments);
   const command2 = requireShellCommand(parsed, args2.call.name);
+  const interactiveAuthCommand = extractInteractiveGhAuthCommand(command2);
+  if (interactiveAuthCommand) {
+    const activity2 = extractActivity(parsed);
+    const blocked = buildInteractiveCommandBlockedResult(interactiveAuthCommand);
+    return {
+      ...blocked,
+      metadata: {
+        ...blocked.metadata,
+        ...activity2 ? { activity: activity2 } : {}
+      }
+    };
+  }
   const result = await runWorkspaceCommand({
     workspaceRoot: args2.workspaceRoot,
     command: buildWorkspaceShellCommand({
@@ -6799,7 +6927,7 @@ async function execShellTool(args2) {
       command: command2,
       shell: parsed.shell
     }),
-    timeoutMs: args2.commandTimeoutMs,
+    timeoutMs: resolveExecShellTimeoutMs(args2.commandTimeoutMs),
     outputLimit: args2.commandOutputLimit,
     commandPrefix: args2.commandPrefix
   });
@@ -6877,11 +7005,12 @@ function createLocalWorkspaceToolExecutors(args2) {
     })
   };
 }
-var WORKSPACE_TOOL_NAMES, DEFAULT_LOCAL_CODING_TOOL_NAMES, SHELL_TOOL_NAMES, WORKSPACE_TOOL_NAME_SET, REMOVED_WORKSPACE_TOOL_NAMES;
+var EXEC_SHELL_TIMEOUT_ENV, WORKSPACE_TOOL_NAMES, DEFAULT_LOCAL_CODING_TOOL_NAMES, SHELL_TOOL_NAMES, WORKSPACE_TOOL_NAME_SET, REMOVED_WORKSPACE_TOOL_NAMES;
 var init_localWorkspaceTools = __esm({
   "packages/agent-runtime/localWorkspaceTools.ts"() {
     "use strict";
     init_runtimeCompat();
+    EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
     WORKSPACE_TOOL_NAMES = [
       "listFiles",
       "readFile",
@@ -7688,6 +7817,7 @@ function spawnProcess(options) {
   } catch {
     return {
       exited: Promise.resolve(127),
+      stdin: null,
       stdout: null,
       stderr: null
     };
@@ -7698,6 +7828,7 @@ function spawnProcess(options) {
   });
   return {
     exited,
+    stdin: child.stdin,
     stdout: child.stdout,
     stderr: child.stderr
   };
@@ -64754,7 +64885,9 @@ function createCliLocalRuntimeAdapter(deps) {
                 const data2 = parsePlatformChatCompletionData(raw2);
                 throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data2)}`);
               }
-              if (stream && options?.onTextDelta) {
+              const contentType = res.headers.get("content-type") ?? "";
+              const shouldStream = Boolean(stream && options?.onTextDelta) && contentType.includes("text/event-stream");
+              if (shouldStream && options?.onTextDelta) {
                 const streamed = await readOpenAiCompatibleSseCompletion({
                   response: res,
                   onTextDelta: options.onTextDelta
@@ -68114,6 +68247,64 @@ function formatAssistantDisplay(text, mode = "rich") {
   }
   return polished.split("\n").map((line) => styleRichMarkdownLine(line)).join("\n");
 }
+function emitFormattedAssistantBlock(write2, text, renderMode, trailingNewline = false) {
+  if (!text) return;
+  write2(formatAssistantDisplay(text, renderMode));
+  if (trailingNewline) write2("\n");
+}
+function createRenderAwareStreamWriter(args2) {
+  let buffer = "";
+  const flushCompleteBlocks = () => {
+    if (args2.renderMode === "plain") {
+      if (!buffer) return;
+      args2.write(buffer);
+      buffer = "";
+      return;
+    }
+    while (buffer.includes("\n")) {
+      const lines = buffer.split("\n");
+      if (lines.length < 2) break;
+      if (isTableRow(lines[0] ?? "") && isTableSeparator(lines[1] ?? "")) {
+        let end = 2;
+        while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
+          end += 1;
+        }
+        const tableComplete = end < lines.length || buffer.endsWith("\n");
+        if (!tableComplete) break;
+        emitFormattedAssistantBlock(
+          args2.write,
+          lines.slice(0, end).join("\n"),
+          args2.renderMode,
+          true
+        );
+        buffer = lines.slice(end).join("\n");
+        continue;
+      }
+      emitFormattedAssistantBlock(args2.write, lines[0] ?? "", args2.renderMode, true);
+      buffer = lines.slice(1).join("\n");
+    }
+  };
+  return {
+    push(chunk) {
+      if (!chunk) return;
+      if (args2.renderMode === "plain") {
+        args2.write(chunk);
+        return;
+      }
+      buffer += chunk;
+      flushCompleteBlocks();
+    },
+    flush() {
+      if (!buffer) return;
+      if (args2.renderMode === "plain") {
+        args2.write(buffer);
+      } else {
+        emitFormattedAssistantBlock(args2.write, buffer, args2.renderMode);
+      }
+      buffer = "";
+    }
+  };
+}
 
 // packages/cli/client/thinkingOutput.ts
 var THINK_OPEN = /<think>/i;
@@ -68357,8 +68548,18 @@ function clip4(value, max = 72) {
   const compact2 = value.replace(/\s+/g, " ").trim();
   return compact2.length > max ? `${compact2.slice(0, max - 1)}\u2026` : compact2;
 }
-function compactResultHint(summary, toolName) {
+function compactResultHint(event, toolName) {
+  const rawAction = event.metadata?.requiresUserAction;
+  if (rawAction && typeof rawAction === "object" && !Array.isArray(rawAction)) {
+    const action = rawAction;
+    const command2 = typeof action.displayCommand === "string" ? action.displayCommand : Array.isArray(action.argv) ? action.argv.filter((item) => typeof item === "string").join(" ") : "";
+    return command2.trim() ? `needs terminal: ${clip4(command2, 120)}` : "needs terminal";
+  }
+  if (event.metadata?.timedOut) return "timed out";
+  const summary = event.summary;
   if (!summary) return "";
+  const exitMatch = summary.match(/exit=(\d+)/);
+  if (exitMatch && exitMatch[1] !== "0") return `exit ${exitMatch[1]}`;
   const linesMatch = summary.match(/(\d+)\s+lines?/);
   if (linesMatch) {
     if (toolName === "readFile" || toolName === "listFiles" || toolName === "globFiles") {
@@ -68368,10 +68569,13 @@ function compactResultHint(summary, toolName) {
       return `${linesMatch[1]} lines`;
     }
   }
-  const exitMatch = summary.match(/exit=(\d+)/);
-  if (exitMatch && exitMatch[1] !== "0") return `exit ${exitMatch[1]}`;
   return "";
 }
+function isFailedToolResult(event) {
+  const exitCode2 = event.metadata?.exitCode;
+  if (typeof exitCode2 === "number" && exitCode2 !== 0) return true;
+  return Boolean(event.metadata?.timedOut || event.metadata?.requiresUserAction);
+}
 function formatToolTraceLine(text, colorEnabled, accent = "none") {
   if (!colorEnabled) return `${text}
 `;
@@ -68413,10 +68617,12 @@ function formatCompactToolLine(event, pending, colorEnabled) {
     const timing2 = ms ? ` \xB7 ${ms}` : "";
     return formatToolTraceLine(`  \u25B8 ${label}  \u2717 ${message}${timing2}`, colorEnabled, "error");
   }
-  const hint = compactResultHint(event.summary, toolName);
+  const hint = compactResultHint(event, toolName);
   const timing = ms ? ` ${ms}` : "";
   const suffix = hint ? ` \xB7 ${hint}` : "";
-  return formatToolTraceLine(`  \u25B8 ${label}  \u2713${timing}${suffix}`, colorEnabled);
+  const marker = isFailedToolResult(event) ? "\u2717" : "\u2713";
+  const accent = isFailedToolResult(event) ? "error" : "none";
+  return formatToolTraceLine(`  \u25B8 ${label}  ${marker}${timing}${suffix}`, colorEnabled, accent);
 }
 function createToolEventFormatter(mode, colorEnabled = resolveCliColorEnabled()) {
   const pending = /* @__PURE__ */ new Map();
@@ -68920,12 +69126,16 @@ async function runLocalAgentTurnForCli(options, settings) {
     const traceLocalTools = shouldEmitToolEvents(toolDisplayMode);
     const formatToolEvent = createToolEventFormatter(toolDisplayMode);
     const eventMode = resolveAgentEventMode(options);
-    let wroteToolTrace = false;
     let streamedAssistantText = false;
     let printedAssistantLabel = false;
     const thinkingMode = resolveThinkingDisplayMode(options.env);
+    const renderMode = resolveRenderDisplayMode(options.env);
+    const renderWriter = createRenderAwareStreamWriter({
+      write: (chunk) => options.output.write(chunk),
+      renderMode
+    });
     const thinkingFilter = createThinkingAwareStreamFilter(
-      (chunk) => options.output.write(chunk),
+      (chunk) => renderWriter.push(chunk),
       thinkingMode
     );
     const subjectRefs = buildSubjectRefs(options);
@@ -68954,12 +69164,12 @@ async function runLocalAgentTurnForCli(options, settings) {
         }
       } : {},
       ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
+      ...options.userActionHandler ? { onUserAction: options.userActionHandler } : {},
       ...traceLocalTools ? {
         onToolEvent: (event) => {
           spinner.stop();
           const chunk = eventMode === "jsonl" ? formatToolJsonEvent(event) : formatToolEvent(event);
           if (chunk) {
-            wroteToolTrace = true;
             options.output.write(chunk);
           }
         }
@@ -68980,6 +69190,7 @@ ${options.agentName} > `);
     spinner.stop();
     if (streamedAssistantText) {
       thinkingFilter.flush();
+      renderWriter.flush();
       options.output.write("\n");
     } else {
       const content = formatAssistantResponseForCli(result.content.trim(), options);
@@ -69017,8 +69228,13 @@ async function readStreamingAgentRun(options, res) {
   }
   const decoder = new TextDecoder();
   const thinkingMode = resolveThinkingDisplayMode(options.env);
+  const renderMode = resolveRenderDisplayMode(options.env);
+  const renderWriter = createRenderAwareStreamWriter({
+    write: (chunk) => options.output.write(chunk),
+    renderMode
+  });
   const writer = createStreamingTextWriter({
-    write: (chunk) => options.output.write(chunk)
+    write: (chunk) => renderWriter.push(chunk)
   });
   const thinkingFilter = createThinkingAwareStreamFilter(
     (chunk) => writer.push(chunk),
@@ -69091,6 +69307,7 @@ ${options.agentName} > `);
   } finally {
     writer.flushAll();
     thinkingFilter.flush();
+    renderWriter.flush();
   }
   if (!content) {
     options.output.write(`
@@ -74970,7 +75187,7 @@ ${renderTuiHelp()}`
 }
 
 // packages/cli/tui/readlineWorkspace.ts
-async function runAgentChat(scriptDir, state, message, env, output2, agentRunner = runAgentTurn) {
+async function runAgentChat(scriptDir, state, message, env, output2, agentRunner = runAgentTurn, userActionHandler) {
   const result = await agentRunner({
     agentName: state.agentName,
     agentKey: state.agentKey,
@@ -74986,10 +75203,52 @@ async function runAgentChat(scriptDir, state, message, env, output2, agentRunner
       NOLO_CLI_TOOLS: state.toolDisplay,
       NOLO_CLI_RENDER: state.renderDisplay
     },
-    output: output2
+    output: output2,
+    ...userActionHandler ? { userActionHandler } : {}
   });
   return result;
 }
+function waitForManualUserAction(rl, input2, output2, action, spawnRunner) {
+  const displayCommand = action.displayCommand ?? action.argv.join(" ");
+  output2.write("\n[nolo] Action needed in your terminal\n");
+  if (action.reason) output2.write(`[nolo] ${action.reason}
+`);
+  output2.write(`  ${displayCommand}
+`);
+  output2.write("[nolo] Press Enter to run it now. Follow any prompts below, or Ctrl+C to cancel.\n");
+  return new Promise((resolve6) => {
+    rl.question("", async () => {
+      const rawInput = input2;
+      const restoreRawMode = Boolean(rawInput.isRaw);
+      rl.pause();
+      rawInput.setRawMode?.(false);
+      let exitCode2 = 1;
+      try {
+        const proc = spawnRunner({
+          cmd: action.argv,
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit"
+        });
+        exitCode2 = await proc.exited;
+      } finally {
+        if (restoreRawMode) rawInput.setRawMode?.(true);
+        rl.resume();
+      }
+      resolve6({
+        content: exitCode2 === 0 ? `user action completed: ${displayCommand}` : `user action failed with exit code ${exitCode2}: ${displayCommand}`,
+        metadata: {
+          exitCode: exitCode2,
+          userActionCompleted: exitCode2 === 0,
+          userActionFailed: exitCode2 !== 0,
+          requiresUserActionCompleted: true,
+          argv: action.argv,
+          displayCommand
+        }
+      });
+    });
+  });
+}
 async function pipeReadableToOutput(stream, output2) {
   const text = await readPipeText(stream);
   if (text) output2.write(text);
@@ -75030,6 +75289,7 @@ async function startTuiWorkspace(options) {
   const output2 = options.output ?? defaultOutput;
   const cliEntrypointPath = options.cliEntrypointPath ?? resolveDefaultCliEntrypoint(options.scriptDir);
   const cliCommandRunner = options.cliCommandRunner ?? runCliCommandInChildProcess;
+  const spawnRunner = options.spawnRunner ?? spawnProcess;
   const selfUpdater = options.selfUpdater ?? ((target) => runSelfUpdate({ output: target }));
   const rl = createInterface2({ input: input2, output: output2 });
   output2.write(renderWelcome(state));
@@ -75172,7 +75432,8 @@ async function startTuiWorkspace(options) {
           result.action.message,
           options.env ?? process.env,
           output2,
-          options.agentRunner
+          options.agentRunner,
+          (action) => waitForManualUserAction(rl, input2, output2, action, spawnRunner)
         );
         if (runResult.dialogId || runResult.turnTokens) {
           state = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {