nolo-cli 0.1.49 → 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,
@@ -5131,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) => {
@@ -6802,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({
@@ -6809,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
   });
@@ -6887,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",
@@ -7698,6 +7817,7 @@ function spawnProcess(options) {
   } catch {
     return {
       exited: Promise.resolve(127),
+      stdin: null,
       stdout: null,
       stderr: null
     };
@@ -7708,6 +7828,7 @@ function spawnProcess(options) {
   });
   return {
     exited,
+    stdin: child.stdin,
     stdout: child.stdout,
     stderr: child.stderr
   };
@@ -68427,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") {
@@ -68438,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}
 `;
@@ -68483,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();
@@ -69028,6 +69164,7 @@ async function runLocalAgentTurnForCli(options, settings) {
         }
       } : {},
       ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
+      ...options.userActionHandler ? { onUserAction: options.userActionHandler } : {},
       ...traceLocalTools ? {
         onToolEvent: (event) => {
           spinner.stop();
@@ -75050,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,
@@ -75066,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);
@@ -75110,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));
@@ -75252,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.49",
+  "version": "0.1.50",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {