open-agents-ai 0.15.9 → 0.16.1

package/dist/index.js

@@ -1103,10 +1103,11 @@ var init_tool_executor = __esm({
 
 // packages/execution/dist/tools/shell.js
 import { spawn } from "node:child_process";
-var ShellTool;
+var PERMISSION_ERROR_RE, ShellTool;
 var init_shell = __esm({
   "packages/execution/dist/tools/shell.js"() {
     "use strict";
+    PERMISSION_ERROR_RE = /Permission denied|Operation not permitted|EACCES|EPERM|PermissionError|sudo:|not permitted|password is required|authentication failure/i;
     ShellTool = class {
       name = "shell";
       description = "Execute a shell command in the project working directory. Commands run non-interactively (CI=true). For commands that need input, use the stdin parameter or pass non-interactive flags (--yes, --no-input).";
@@ -1130,14 +1131,55 @@ var init_shell = __esm({
       };
       workingDir;
       defaultTimeout;
+      _sudoPassword = null;
       constructor(workingDir, defaultTimeout = 3e4) {
         this.workingDir = workingDir;
         this.defaultTimeout = defaultTimeout;
       }
+      /** Set a cached sudo password for the session. The shell tool will
+       *  automatically retry permission-denied commands with `sudo -S`. */
+      setSudoPassword(password) {
+        this._sudoPassword = password;
+      }
+      /** Check whether a sudo password is currently cached. */
+      hasSudoPassword() {
+        return this._sudoPassword !== null;
+      }
       async execute(args) {
         const command = args["command"];
         const timeout = args["timeout"] ?? this.defaultTimeout;
         const stdinInput = args["stdin"];
+        const result = await this.runCommand(command, timeout, stdinInput);
+        if (!result.success && this._sudoPassword && this.isPermissionError(result)) {
+          const sudoCmd = command.trimStart().startsWith("sudo ") ? command : `sudo -S ${command}`;
+          const sudoResult = await this.runCommand(sudoCmd, timeout, `${this._sudoPassword}
+${stdinInput ?? ""}`);
+          if (sudoResult.success) {
+            return sudoResult;
+          }
+          if (this.isPermissionError(sudoResult) || /incorrect password|Sorry, try again/i.test((sudoResult.error ?? "") + sudoResult.output)) {
+            this._sudoPassword = null;
+            return {
+              ...sudoResult,
+              error: (sudoResult.error ?? "") + "\n\n[SUDO_PASSWORD_INCORRECT] The cached sudo password was rejected. Ask the user for the correct password."
+            };
+          }
+          return sudoResult;
+        }
+        if (!result.success && this.isPermissionError(result) && !this._sudoPassword) {
+          return {
+            ...result,
+            error: (result.error ?? "") + "\n\n[PERMISSION_ERROR] This command requires elevated privileges. The user needs to provide their sudo password. Wait for the user to enter their password \u2014 the system is prompting them now."
+          };
+        }
+        return result;
+      }
+      /** Detect if a tool result is a permission / privilege error */
+      isPermissionError(result) {
+        const combined = (result.error ?? "") + result.output;
+        return PERMISSION_ERROR_RE.test(combined);
+      }
+      runCommand(command, timeout, stdinInput) {
         const start = performance.now();
         return new Promise((resolve16) => {
           const child = spawn("bash", ["-c", command], {
@@ -8014,19 +8056,22 @@ If you notice you're performing the SAME multi-step sequence for the 3rd time or
       handlers = [];
       pendingUserMessages = [];
       aborted = false;
+      _sudoPassword = null;
+      _sudoResolve = null;
       constructor(backend, options) {
         this.backend = backend;
         this.options = {
-          maxTurns: options?.maxTurns ?? 30,
+          maxTurns: options?.maxTurns ?? 60,
           maxTokens: options?.maxTokens ?? 16384,
           temperature: options?.temperature ?? 0,
           requestTimeoutMs: options?.requestTimeoutMs ?? 3e5,
-          taskTimeoutMs: options?.taskTimeoutMs ?? 12e5,
+          taskTimeoutMs: options?.taskTimeoutMs ?? 36e5,
+          // 60 min
           compactionThreshold: options?.compactionThreshold ?? 4e4,
           dynamicContext: options?.dynamicContext ?? "",
           streamEnabled: options?.streamEnabled ?? false,
-          bruteForce: options?.bruteForce ?? false,
-          bruteForceMaxCycles: options?.bruteForceMaxCycles ?? 3
+          bruteForce: options?.bruteForce ?? true,
+          bruteForceMaxCycles: options?.bruteForceMaxCycles ?? 100
         };
       }
       /** Register a tool for the agent to use */
@@ -8264,6 +8309,21 @@ Integrate this guidance into your current approach. Continue working on the task
                   result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
                 }
               }
+              if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
+                this.emit({
+                  type: "sudo_request",
+                  content: `Command requires elevated privileges: ${tc.arguments.command?.slice(0, 100) ?? ""}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                const pw = await this.waitForSudoPassword(12e4);
+                if (pw) {
+                  try {
+                    result = await tool.execute(tc.arguments);
+                  } catch (err) {
+                    result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
+                  }
+                }
+              }
               const maxLen = 8e3;
               const output = result.success ? result.output.length > maxLen ? result.output.slice(0, maxLen) + `
 ...(truncated)` : result.output : `Error: ${result.error || "unknown error"}
@@ -8337,27 +8397,28 @@ ${result.output}`;
             });
           }
         }
-        if (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < hardDeadline) {
+        while (!completed && !this.aborted && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles && Date.now() < hardDeadline) {
           bruteForceCycle++;
           const totalTurns = messages.filter((m) => m.role === "assistant").length;
           this.emit({
             type: "compaction",
-            content: `Brute-force cycle ${bruteForceCycle}/${this.options.bruteForceMaxCycles} \u2014 re-engaging agent`,
+            content: `Re-engaging \u2014 cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} tool calls so far)`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           messages.push({
             role: "user",
-            content: `[BRUTE-FORCE RE-ENGAGEMENT \u2014 Cycle ${bruteForceCycle}/${this.options.bruteForceMaxCycles}]
+            content: `[CONTINUATION \u2014 Cycle ${bruteForceCycle}]
 
-You have used ${totalTurns} turns and ${toolCallCount} tool calls without completing the task. DO NOT give up. Reassess your approach:
+You have used ${totalTurns} turns and ${toolCallCount} tool calls so far. The task is NOT yet complete. DO NOT give up \u2014 re-evaluate and continue:
 
-1. DIAGNOSE: What exactly is blocking progress? Read error messages carefully.
-2. PIVOT: If the current approach isn't working, try a completely different strategy.
-3. INVESTIGATE: Use grep_search, find_files, and web_search to find solutions.
-4. SIMPLIFY: Break the problem into smaller steps. Fix one thing at a time.
-5. VERIFY: Run tests/build after EVERY change \u2014 don't batch multiple changes.
+1. ASSESS: What have you accomplished so far? What specific part remains?
+2. DIAGNOSE: If stuck, what exactly is blocking? Read error output carefully.
+3. PIVOT: If the current approach failed, try a different strategy.
+4. INVESTIGATE: Use grep_search, find_files, web_search to find answers.
+5. SIMPLIFY: Break remaining work into the smallest possible steps.
+6. VERIFY: Run tests/build after EVERY change.
 
-You have ${this.options.maxTurns} more turns. Be creative and investigative. If a file is confusing, re-read it. If a test fails, read the FULL error. Call task_complete when done.`
+You have ${this.options.maxTurns} more turns. Continue making progress. Call task_complete when the task is fully done.`
           });
           const compacted = this.compactMessages(messages);
           if (compacted !== messages) {
@@ -8463,6 +8524,17 @@ Integrate this guidance into your current approach. Continue working on the task
                     result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
                   }
                 }
+                if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
+                  this.emit({ type: "sudo_request", content: `Command requires elevated privileges: ${tc.arguments.command?.slice(0, 100) ?? ""}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                  const pw = await this.waitForSudoPassword(12e4);
+                  if (pw && tool) {
+                    try {
+                      result = await tool.execute(tc.arguments);
+                    } catch (err) {
+                      result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
+                    }
+                  }
+                }
                 const maxLen = 8e3;
                 const output = result.success ? result.output.length > maxLen ? result.output.slice(0, maxLen) + `
 ...(truncated)` : result.output : `Error: ${result.error || "unknown error"}
@@ -8501,6 +8573,37 @@ ${result.output}`;
         return { completed, turns: messages.filter((m) => m.role === "assistant").length, toolCalls: toolCallCount, totalTokens, promptTokens, completionTokens, estimatedTokens, summary, durationMs };
       }
       // -------------------------------------------------------------------------
+      // Sudo / privilege escalation support
+      // -------------------------------------------------------------------------
+      /** Provide the sudo password — resolves any pending sudo_request wait. */
+      setSudoPassword(password) {
+        this._sudoPassword = password;
+        for (const tool of this.tools.values()) {
+          if (typeof tool.setSudoPassword === "function") {
+            tool.setSudoPassword(password);
+          }
+        }
+        if (this._sudoResolve) {
+          this._sudoResolve(password);
+          this._sudoResolve = null;
+        }
+      }
+      /** Wait for the user to provide a sudo password (with timeout). */
+      waitForSudoPassword(timeoutMs = 12e4) {
+        if (this._sudoPassword)
+          return Promise.resolve(this._sudoPassword);
+        return new Promise((resolve16) => {
+          const timer = setTimeout(() => {
+            this._sudoResolve = null;
+            resolve16(null);
+          }, timeoutMs);
+          this._sudoResolve = (pw) => {
+            clearTimeout(timer);
+            resolve16(pw);
+          };
+        });
+      }
+      // -------------------------------------------------------------------------
       // Image / multimodal support
       // -------------------------------------------------------------------------
       /** Inject an image into the running conversation (for drag-drop / paste) */
@@ -15200,20 +15303,23 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
     }
   };
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback) {
   const projectCtx = buildProjectContext(repoRoot, taskStores?.contextStores);
   const dynamicContext = formatContextForPrompt(projectCtx);
   const backend = new OllamaAgenticBackend(config.backendUrl.replace(/\/$/, ""), config.model);
   const runner = new AgenticRunner(backend, {
-    maxTurns: 30,
+    maxTurns: 60,
     maxTokens: 16384,
     temperature: 0,
     requestTimeoutMs: config.timeoutMs,
-    taskTimeoutMs: config.timeoutMs * 4,
+    taskTimeoutMs: 36e5,
+    // 60 minutes — never give up prematurely
     compactionThreshold: 4e4,
     dynamicContext,
     streamEnabled: stream?.enabled ?? false,
-    bruteForce: bruteForce ?? false
+    bruteForce: bruteForce ?? true,
+    bruteForceMaxCycles: 100
+    // effectively unlimited — hard timeout is the real bound
   });
   runner.registerTools(buildTools(repoRoot, config));
   const filesTouched = /* @__PURE__ */ new Set();
@@ -15306,6 +15412,12 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
           statusBar.updateMetrics(event.tokenUsage);
         }
         break;
+      case "sudo_request":
+        contentWrite(() => renderWarning(`Sudo required: ${event.content ?? "elevated privileges needed"}`));
+        contentWrite(() => renderInfo("Enter your password at the prompt below to continue."));
+        if (sudoCallback)
+          sudoCallback(event.content ?? "");
+        break;
       case "complete":
         break;
     }
@@ -15413,7 +15525,7 @@ async function startInteractive(config, repoPath) {
   if (savedSettings.dbPath)
     config = { ...config, dbPath: savedSettings.dbPath };
   let streamEnabled = savedSettings.stream ?? false;
-  let bruteForceEnabled = savedSettings.bruteforce ?? false;
+  let bruteForceEnabled = savedSettings.bruteforce ?? true;
   if (savedSettings.emojis !== void 0)
     setEmojisEnabled(savedSettings.emojis);
   if (savedSettings.colors !== void 0)
@@ -15500,8 +15612,10 @@ async function startInteractive(config, repoPath) {
   let lastSubmittedPrompt = "";
   let sessionFilesTouched = [];
   let sessionToolCallCount = 0;
-  const idlePrompt = `${c2.bold(c2.blue("> "))}`;
-  const activePrompt = `${c2.dim(c2.cyan("+ "))}`;
+  let sessionSudoPassword = null;
+  let sudoPromptPending = false;
+  const idlePrompt = `${c2.bold(c2.white("\u{1F896} "))}`;
+  const activePrompt = `${c2.bold(c2.white("+ "))}`;
   const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -15552,6 +15666,17 @@ async function startInteractive(config, repoPath) {
       fn();
     }
   }
+  function handleSudoRequest(_command) {
+    if (sudoPromptPending)
+      return;
+    if (sessionSudoPassword && activeTask) {
+      activeTask.runner.setSudoPassword(sessionSudoPassword);
+      return;
+    }
+    sudoPromptPending = true;
+    const sudoPromptStr = `  ${c2.bold(c2.yellow("\u{1F511} Password:"))} `;
+    process.stdout.write(sudoPromptStr);
+  }
   const commandCtx = {
     get config() {
       return currentConfig;
@@ -15787,6 +15912,15 @@ async function startInteractive(config, repoPath) {
     }, 50);
   });
   async function processLine(input) {
+    if (sudoPromptPending && activeTask) {
+      sudoPromptPending = false;
+      sessionSudoPassword = input;
+      activeTask.runner.setSudoPassword(input);
+      process.stdout.write(`\r\x1B[K  ${c2.dim("\u{1F511} Password received")}
+`);
+      showPrompt();
+      return;
+    }
     if (input.startsWith("/")) {
       if (statusBar.isActive)
         statusBar.beginContentWrite();
@@ -15836,7 +15970,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
             taskMemoryStore: taskMemoryStore ?? void 0,
             failureStore: failureStore ?? void 0,
             toolPatternStore: toolPatternStore ?? void 0
-          }, bruteForceEnabled, statusBar);
+          }, bruteForceEnabled, statusBar, handleSudoRequest);
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -15934,7 +16068,7 @@ Summarize or analyze this transcription as appropriate.`;
         taskMemoryStore: taskMemoryStore ?? void 0,
         failureStore: failureStore ?? void 0,
         toolPatternStore: toolPatternStore ?? void 0
-      }, bruteForceEnabled, statusBar);
+      }, bruteForceEnabled, statusBar, handleSudoRequest);
       activeTask = task;
       showPrompt();
       await task.promise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.15.9",
+  "version": "0.16.1",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",