@cosmicstack/mercury-agent 0.2.4 → 0.2.6

package/dist/index.js

@@ -1706,16 +1706,16 @@ var CLIChannel = class extends BaseChannel {
     }
   }
   async prompt(question) {
-    return new Promise((resolve9) => {
-      this.rl?.question(question, (answer) => resolve9(answer.trim()));
+    return new Promise((resolve10) => {
+      this.rl?.question(question, (answer) => resolve10(answer.trim()));
     });
   }
   async askPermission(prompt) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       console.log("");
       console.log(chalk2.yellow(`  \u26A0 ${prompt}`));
       this.rl?.question(chalk2.yellow("  > "), (answer) => {
-        resolve9(answer.trim());
+        resolve10(answer.trim());
       });
     });
   }
@@ -1978,15 +1978,15 @@ var TelegramChannel = class extends BaseChannel {
         reply_markup: keyboard
       });
     }
-    return new Promise((resolve9) => {
-      this.pendingApprovals.set(`${id}:yes`, () => resolve9("yes"));
-      this.pendingApprovals.set(`${id}:always`, () => resolve9("always"));
-      this.pendingApprovals.set(`${id}:no`, () => resolve9("no"));
+    return new Promise((resolve10) => {
+      this.pendingApprovals.set(`${id}:yes`, () => resolve10("yes"));
+      this.pendingApprovals.set(`${id}:always`, () => resolve10("always"));
+      this.pendingApprovals.set(`${id}:no`, () => resolve10("no"));
       setTimeout(() => {
         this.pendingApprovals.delete(`${id}:yes`);
         this.pendingApprovals.delete(`${id}:always`);
         this.pendingApprovals.delete(`${id}:no`);
-        resolve9("no");
+        resolve10("no");
       }, 12e4);
     });
   }
@@ -2304,6 +2304,7 @@ var PermissionManager = class {
   elevatedCommands = /* @__PURE__ */ new Set();
   pendingApprovals = /* @__PURE__ */ new Set();
   currentChannelType = "cli";
+  tempScopes = [];
   constructor() {
     this.cwd = process.cwd();
     this.manifest = this.load();
@@ -2334,8 +2335,8 @@ var PermissionManager = class {
   clearElevation() {
     this.elevatedCommands.clear();
   }
-  isElevated(tool24) {
-    if (this.elevatedCommands.has(tool24)) return true;
+  isElevated(tool25) {
+    if (this.elevatedCommands.has(tool25)) return true;
     return false;
   }
   isShellElevated() {
@@ -2394,12 +2395,18 @@ var PermissionManager = class {
     }
     const resolved = resolve(path3);
     const scope = this.findScope(resolved);
+    const tempScope = this.findTempScope(resolved);
     if (scope) {
       if (mode === "read" && scope.read) return { allowed: true };
       if (mode === "write" && scope.write) return { allowed: true };
       return { allowed: false, reason: `Permission denied: ${mode} access to ${path3} (scope has ${mode}=false)` };
     }
-    return await this.requestScope(resolved, mode);
+    if (tempScope) {
+      if (mode === "read" && tempScope.read) return { allowed: true };
+      if (mode === "write" && tempScope.write) return { allowed: true };
+      return { allowed: false, reason: `Permission denied: ${mode} access to ${path3}` };
+    }
+    return { allowed: false, reason: `Permission denied for ${mode} access to ${path3}` };
   }
   async checkShellCommand(command) {
     if (this.autoApproveAll) {
@@ -2430,7 +2437,7 @@ var PermissionManager = class {
       if (hasPathTraversal) {
         const scopeCheck = await this.checkFsAccess(hasPathTraversal, "write");
         if (!scopeCheck.allowed) {
-          return { allowed: false, reason: scopeCheck.reason, needsApproval: true };
+          return { allowed: false, reason: `No permission to access ${hasPathTraversal}. Use approve_scope tool with path="${hasPathTraversal}" and mode="write" to request access.`, needsApproval: false };
         }
       }
     }
@@ -2501,22 +2508,39 @@ var PermissionManager = class {
     }
     return void 0;
   }
-  async requestScope(path3, mode) {
+  async requestScopeExternal(path3, mode) {
     if (!this.askHandler) {
-      return { allowed: false, reason: `No permission to ${mode} ${path3}. Add scope to ~/.mercury/permissions.yaml` };
+      return { allowed: false, reason: `Permission denied for ${mode} access to ${path3}` };
     }
-    const response = await this.askHandler(
-      `Mercury needs ${mode} access to ${path3}. Allow? (y/n/always): `
-    );
-    if (response.toLowerCase() === "always") {
+    const prompt = `Mercury needs ${mode} access to:
+${path3}
+
+Allow access?`;
+    const response = await this.askHandler(prompt);
+    if (response === "always") {
       this.addScope(path3, mode === "read", mode === "write");
       return { allowed: true };
     }
-    if (response.toLowerCase() === "y" || response.toLowerCase() === "yes") {
+    if (response === "yes") {
+      this.addTempScope(path3, mode === "read", mode === "write");
       return { allowed: true };
     }
     return { allowed: false, reason: `Permission denied for ${mode} access to ${path3}` };
   }
+  addTempScope(path3, read, write) {
+    const resolved = resolve(path3);
+    this.tempScopes.push({ path: resolved, read, write });
+    logger.info({ path: resolved, read, write }, "Temp permission scope added (session only)");
+  }
+  findTempScope(resolvedPath) {
+    for (const scope of this.tempScopes) {
+      const scopeResolved = resolve(scope.path.replace(/^~/, homedir2()));
+      if (resolvedPath === scopeResolved || resolvedPath.startsWith(scopeResolved + sep)) {
+        return scope;
+      }
+    }
+    return void 0;
+  }
   matchPattern(command, pattern) {
     const regexStr = "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
     try {
@@ -2583,7 +2607,8 @@ function createReadFileTool(permissions) {
       const resolved = resolve2(path3);
       const check = await permissions.checkFsAccess(resolved, "read");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        const parentDir = resolve2(resolved, "..");
+        return `Error: Permission denied for read access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="read" to request access from the user.`;
       }
       if (!existsSync7(resolved)) {
         return `Error: File not found: ${resolved}`;
@@ -2620,7 +2645,8 @@ function createWriteFileTool(permissions) {
       const resolved = resolve3(path3);
       const check = await permissions.checkFsAccess(resolved, "write");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        const parentDir = resolve3(resolved, "..");
+        return `Error: Permission denied for write access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="write" to request access from the user.`;
       }
       if (!existsSync8(resolved)) {
         return `Error: File not found: ${resolved}. Use create_file to create new files.`;
@@ -2651,7 +2677,8 @@ function createCreateFileTool(permissions) {
       const resolved = resolve4(path3);
       const check = await permissions.checkFsAccess(resolved, "write");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        const parentDir = resolve4(resolved, "..");
+        return `Error: Permission denied for write access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="write" to request access from the user.`;
       }
       if (existsSync9(resolved)) {
         return `Error: File already exists: ${resolved}. Use write_file to modify existing files.`;
@@ -2685,7 +2712,7 @@ function createListDirTool(permissions) {
       const resolved = resolve5(path3);
       const check = await permissions.checkFsAccess(resolved, "read");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        return `Error: Permission denied for read access to ${resolved}. Use the approve_scope tool with path="${resolved}" and mode="read" to request access from the user.`;
       }
       if (!existsSync10(resolved)) {
         return `Error: Directory not found: ${resolved}`;
@@ -2743,7 +2770,8 @@ function createDeleteFileTool(permissions) {
       const resolved = resolve6(path3);
       const check = await permissions.checkFsAccess(resolved, "write");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        const parentDir = resolve6(resolved, "..");
+        return `Error: Permission denied for write access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="write" to request access from the user.`;
       }
       if (!existsSync11(resolved)) {
         return `Error: File not found: ${resolved}`;
@@ -2779,7 +2807,8 @@ function createEditFileTool(permissions) {
       const resolved = resolve7(path3);
       const fsCheck = await permissions.checkFsAccess(resolved, "write");
       if (!fsCheck.allowed) {
-        return `Error: ${fsCheck.reason}`;
+        const parentDir = resolve7(resolved, "..");
+        return `Error: Permission denied for write access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="write" to request access from the user.`;
       }
       try {
         const content = readFileSync9(resolved, "utf-8");
@@ -2820,7 +2849,8 @@ function createSendFileTool(permissions, sendFile) {
       const resolved = resolve8(path3);
       const check = await permissions.checkFsAccess(resolved, "read");
       if (!check.allowed) {
-        return `Error: ${check.reason}`;
+        const parentDir = resolve8(resolved, "..");
+        return `Error: Permission denied for read access to ${resolved}. Use the approve_scope tool with path="${parentDir}" and mode="read" to request access from the user.`;
       }
       if (!existsSync12(resolved)) {
         return `Error: File not found: ${resolved}`;
@@ -2844,18 +2874,40 @@ function createSendFileTool(permissions, sendFile) {
   });
 }
 
-// src/capabilities/shell/run-command.ts
+// src/capabilities/filesystem/approve-scope.ts
 import { tool as tool8 } from "ai";
 import { z as z8 } from "zod";
+import { resolve as resolve9 } from "path";
+function createApproveScopeTool(permissions) {
+  return tool8({
+    description: 'Request user approval to access a directory outside current scopes. Use this when a file tool returns a permission denied error. The user gets an approval prompt (Allow/Always/Deny buttons on Telegram, yes/always/no on CLI). "Allow" grants session-only access. "Always" persists to disk. After approval, retry the original file operation.',
+    parameters: z8.object({
+      path: z8.string().describe("The directory path to request access to"),
+      mode: z8.enum(["read", "write"]).describe("The access mode needed")
+    }),
+    execute: async ({ path: path3, mode }) => {
+      const resolved = resolve9(path3);
+      const result = await permissions.requestScopeExternal(resolved, mode);
+      if (result.allowed) {
+        return `Access approved for ${mode} access to ${resolved}. You can now retry the file operation.`;
+      }
+      return `Access denied for ${mode} access to ${resolved}. The user did not approve scope access.`;
+    }
+  });
+}
+
+// src/capabilities/shell/run-command.ts
+import { tool as tool9 } from "ai";
+import { z as z9 } from "zod";
 import { execSync } from "child_process";
 function createRunCommandTool(permissions) {
-  return tool8({
+  return tool9({
     description: `Run a shell command. Commands run in the current working directory unless an absolute path is given.
 Blocked commands (sudo, rm -rf /, etc.) are never executed.
 Auto-approved commands (ls, cat, git status, curl, etc.) run without asking.
 Other commands require user approval \u2014 tell the user what command you want to run and ask for confirmation. If they say "yes", try again. If they say "always", use the approve_command tool.`,
-    parameters: z8.object({
-      command: z8.string().describe("The shell command to execute")
+    parameters: z9.object({
+      command: z9.string().describe("The shell command to execute")
     }),
     execute: async ({ command }) => {
       const check = await permissions.checkShellCommand(command);
@@ -2895,13 +2947,13 @@ Error: ${stderr}`;
 }
 
 // src/capabilities/shell/approve-command.ts
-import { tool as tool9 } from "ai";
-import { z as z9 } from "zod";
+import { tool as tool10 } from "ai";
+import { z as z10 } from "zod";
 function createApproveCommandTool(permissions) {
-  return tool9({
+  return tool10({
     description: 'Permanently approve a command type so it runs without asking in the future. Use this when the user says "always" or "always approve" for a command. For example, if the user says "always approve curl", call this with command="curl".',
-    parameters: z9.object({
-      command: z9.string().describe('The base command to permanently approve (e.g. "curl", "docker", "npm")')
+    parameters: z10.object({
+      command: z10.string().describe('The base command to permanently approve (e.g. "curl", "docker", "npm")')
     }),
     execute: async ({ command }) => {
       const baseCmd = command.trim().split(/\s+/)[0];
@@ -2912,15 +2964,15 @@ function createApproveCommandTool(permissions) {
 }
 
 // src/capabilities/skills/install-skill.ts
-import { tool as tool10 } from "ai";
-import { z as z10 } from "zod";
+import { tool as tool11 } from "ai";
+import { z as z11 } from "zod";
 import { parse as parseYaml4 } from "yaml";
 function createInstallSkillTool(skillLoader) {
-  return tool10({
+  return tool11({
     description: "Install a new skill by providing SKILL.md markdown content or a URL. The content must have YAML frontmatter (---) with at least name and description fields.",
-    parameters: z10.object({
-      content: z10.string().optional().describe("Raw SKILL.md markdown content with YAML frontmatter"),
-      url: z10.string().optional().describe("URL to fetch a SKILL.md from")
+    parameters: z11.object({
+      content: z11.string().optional().describe("Raw SKILL.md markdown content with YAML frontmatter"),
+      url: z11.string().optional().describe("URL to fetch a SKILL.md from")
     }),
     execute: async ({ content, url }) => {
       let skillContent;
@@ -2960,12 +3012,12 @@ function createInstallSkillTool(skillLoader) {
 }
 
 // src/capabilities/skills/list-skills.ts
-import { tool as tool11 } from "ai";
-import { z as z11 } from "zod";
+import { tool as tool12 } from "ai";
+import { z as z12 } from "zod";
 function createListSkillsTool(skillLoader) {
-  return tool11({
+  return tool12({
     description: "List all installed skills with their names and descriptions.",
-    parameters: z11.object({}),
+    parameters: z12.object({}),
     execute: async () => {
       const skills = skillLoader.getDiscovered();
       if (skills.length === 0) {
@@ -2977,13 +3029,13 @@ function createListSkillsTool(skillLoader) {
 }
 
 // src/capabilities/skills/use-skill.ts
-import { tool as tool12 } from "ai";
-import { z as z12 } from "zod";
+import { tool as tool13 } from "ai";
+import { z as z13 } from "zod";
 function createUseSkillTool(skillLoader, permissions) {
-  return tool12({
+  return tool13({
     description: "Load and invoke a skill by name. Returns the skill's full instructions which should be followed as guidance for the current task.",
-    parameters: z12.object({
-      name: z12.string().describe("Name of the skill to invoke")
+    parameters: z13.object({
+      name: z13.string().describe("Name of the skill to invoke")
     }),
     execute: async ({ name }) => {
       const skill = skillLoader.load(name);
@@ -3010,18 +3062,18 @@ Allowed tools: ${skill["allowed-tools"].join(", ")}`;
 }
 
 // src/capabilities/scheduler/schedule-task.ts
-import { tool as tool13 } from "ai";
-import { z as z13 } from "zod";
+import { tool as tool14 } from "ai";
+import { z as z14 } from "zod";
 import cron2 from "node-cron";
 function createScheduleTaskTool(scheduler, getContext) {
-  return tool13({
+  return tool14({
     description: 'Schedule a task. Use "cron" for recurring tasks (e.g. "0 9 * * *" for daily at 9am) or "delay_seconds" for one-shot delayed tasks (e.g. 15 for "remind me in 15 seconds"). Provide exactly one of cron or delay_seconds.',
-    parameters: z13.object({
-      cron: z13.string().optional().describe('Cron expression for recurring tasks (e.g. "0 9 * * *" for daily at 9am)'),
-      delay_seconds: z13.number().optional().describe('Delay in seconds for one-shot tasks (e.g. 15 for "remind me in 15 seconds")'),
-      description: z13.string().describe("Human-readable description of what this task does"),
-      prompt: z13.string().optional().describe("Prompt to send to the agent when the task fires"),
-      skill_name: z13.string().optional().describe("Name of a skill to invoke when the task fires")
+    parameters: z14.object({
+      cron: z14.string().optional().describe('Cron expression for recurring tasks (e.g. "0 9 * * *" for daily at 9am)'),
+      delay_seconds: z14.number().optional().describe('Delay in seconds for one-shot tasks (e.g. 15 for "remind me in 15 seconds")'),
+      description: z14.string().describe("Human-readable description of what this task does"),
+      prompt: z14.string().optional().describe("Prompt to send to the agent when the task fires"),
+      skill_name: z14.string().optional().describe("Name of a skill to invoke when the task fires")
     }),
     execute: async ({ cron: cronExpr, delay_seconds, description, prompt, skill_name }) => {
       if (!cronExpr && !delay_seconds) {
@@ -3074,12 +3126,12 @@ function createScheduleTaskTool(scheduler, getContext) {
 }
 
 // src/capabilities/scheduler/list-tasks.ts
-import { tool as tool14 } from "ai";
-import { z as z14 } from "zod";
+import { tool as tool15 } from "ai";
+import { z as z15 } from "zod";
 function createListTasksTool(scheduler) {
-  return tool14({
+  return tool15({
     description: "List all scheduled tasks with their cron expressions and descriptions.",
-    parameters: z14.object({}),
+    parameters: z15.object({}),
     execute: async () => {
       const manifests = scheduler.getManifests();
       if (manifests.length === 0) {
@@ -3094,13 +3146,13 @@ function createListTasksTool(scheduler) {
 }
 
 // src/capabilities/scheduler/cancel-task.ts
-import { tool as tool15 } from "ai";
-import { z as z15 } from "zod";
+import { tool as tool16 } from "ai";
+import { z as z16 } from "zod";
 function createCancelTaskTool(scheduler) {
-  return tool15({
+  return tool16({
     description: "Cancel and remove a scheduled task by its ID.",
-    parameters: z15.object({
-      id: z15.string().describe("ID of the scheduled task to cancel")
+    parameters: z16.object({
+      id: z16.string().describe("ID of the scheduled task to cancel")
     }),
     execute: async ({ id }) => {
       const manifests = scheduler.getManifests();
@@ -3116,12 +3168,12 @@ function createCancelTaskTool(scheduler) {
 }
 
 // src/capabilities/system/budget-status.ts
-import { tool as tool16 } from "ai";
-import { z as z16 } from "zod";
+import { tool as tool17 } from "ai";
+import { z as z17 } from "zod";
 function createBudgetStatusTool(tokenBudget) {
-  return tool16({
+  return tool17({
     description: "Check the current token budget status \u2014 how many tokens have been used today, how many remain, and what percentage is consumed.",
-    parameters: z16.object({}),
+    parameters: z17.object({}),
     execute: async () => {
       return tokenBudget.getStatusText();
     }
@@ -3129,14 +3181,14 @@ function createBudgetStatusTool(tokenBudget) {
 }
 
 // src/capabilities/git/git-status.ts
-import { tool as tool17 } from "ai";
-import { z as z17 } from "zod";
+import { tool as tool18 } from "ai";
+import { z as z18 } from "zod";
 import { execSync as execSync2 } from "child_process";
 function createGitStatusTool() {
-  return tool17({
+  return tool18({
     description: "Show the working tree status. Returns staged, unstaged, and untracked files.",
-    parameters: z17.object({
-      path: z17.string().optional().describe("Path to check (defaults to current directory)")
+    parameters: z18.object({
+      path: z18.string().optional().describe("Path to check (defaults to current directory)")
     }),
     execute: async ({ path: path3 }) => {
       try {
@@ -3152,15 +3204,15 @@ function createGitStatusTool() {
 }
 
 // src/capabilities/git/git-diff.ts
-import { tool as tool18 } from "ai";
-import { z as z18 } from "zod";
+import { tool as tool19 } from "ai";
+import { z as z19 } from "zod";
 import { execSync as execSync3 } from "child_process";
 function createGitDiffTool() {
-  return tool18({
+  return tool19({
     description: "Show changes between commits, commit and working tree, etc. Shows what has been modified.",
-    parameters: z18.object({
-      path: z18.string().optional().describe("File or directory to diff"),
-      staged: z18.boolean().optional().describe("Show staged changes (cached) instead of unstaged")
+    parameters: z19.object({
+      path: z19.string().optional().describe("File or directory to diff"),
+      staged: z19.boolean().optional().describe("Show staged changes (cached) instead of unstaged")
     }),
     execute: async ({ path: path3, staged }) => {
       try {
@@ -3179,15 +3231,15 @@ function createGitDiffTool() {
 }
 
 // src/capabilities/git/git-log.ts
-import { tool as tool19 } from "ai";
-import { z as z19 } from "zod";
+import { tool as tool20 } from "ai";
+import { z as z20 } from "zod";
 import { execSync as execSync4 } from "child_process";
 function createGitLogTool() {
-  return tool19({
+  return tool20({
     description: "Show commit logs. Returns recent commit history with hash, author, date, and message.",
-    parameters: z19.object({
-      count: z19.number().optional().describe("Number of commits to show (default 10)"),
-      path: z19.string().optional().describe("File or directory to show log for")
+    parameters: z20.object({
+      count: z20.number().optional().describe("Number of commits to show (default 10)"),
+      path: z20.string().optional().describe("File or directory to show log for")
     }),
     execute: async ({ count, path: path3 }) => {
       try {
@@ -3205,14 +3257,14 @@ function createGitLogTool() {
 }
 
 // src/capabilities/git/git-add.ts
-import { tool as tool20 } from "ai";
-import { z as z20 } from "zod";
+import { tool as tool21 } from "ai";
+import { z as z21 } from "zod";
 import { execSync as execSync5 } from "child_process";
 function createGitAddTool() {
-  return tool20({
+  return tool21({
     description: "Add file contents to the index (staging area). Prepares files for commit.",
-    parameters: z20.object({
-      paths: z20.array(z20.string()).describe("File paths to stage")
+    parameters: z21.object({
+      paths: z21.array(z21.string()).describe("File paths to stage")
     }),
     execute: async ({ paths }) => {
       try {
@@ -3227,14 +3279,14 @@ function createGitAddTool() {
 }
 
 // src/capabilities/git/git-commit.ts
-import { tool as tool21 } from "ai";
-import { z as z21 } from "zod";
+import { tool as tool22 } from "ai";
+import { z as z22 } from "zod";
 import { execSync as execSync6 } from "child_process";
 function createGitCommitTool() {
-  return tool21({
+  return tool22({
     description: "Record changes to the repository. Creates a new commit with staged changes.",
-    parameters: z21.object({
-      message: z21.string().describe("Commit message")
+    parameters: z22.object({
+      message: z22.string().describe("Commit message")
     }),
     execute: async ({ message }) => {
       try {
@@ -3253,15 +3305,15 @@ function createGitCommitTool() {
 }
 
 // src/capabilities/git/git-push.ts
-import { tool as tool22 } from "ai";
-import { z as z22 } from "zod";
+import { tool as tool23 } from "ai";
+import { z as z23 } from "zod";
 import { execSync as execSync7 } from "child_process";
 function createGitPushTool(permissions) {
-  return tool22({
+  return tool23({
     description: "Push commits to a remote repository. This modifies a remote and requires approval.",
-    parameters: z22.object({
-      remote: z22.string().optional().describe("Remote name (default: origin)"),
-      branch: z22.string().optional().describe("Branch name (default: current branch)")
+    parameters: z23.object({
+      remote: z23.string().optional().describe("Remote name (default: origin)"),
+      branch: z23.string().optional().describe("Branch name (default: current branch)")
     }),
     execute: async ({ remote, branch }) => {
       const cmd = `git push ${remote || "origin"} ${branch || ""}`.trim();
@@ -3286,8 +3338,8 @@ Ask the user for permission. If they approve, try again. If they say "always", u
 }
 
 // src/capabilities/web/fetch-url.ts
-import { tool as tool23 } from "ai";
-import { z as z23 } from "zod";
+import { tool as tool24 } from "ai";
+import { z as z24 } from "zod";
 var MAX_CONTENT_LENGTH = 15e3;
 function stripHtml(html) {
   let text = html;
@@ -3320,11 +3372,11 @@ function stripHtml(html) {
   return text;
 }
 function createFetchUrlTool() {
-  return tool23({
+  return tool24({
     description: "Fetch a URL and return its content as text. Strips HTML to readable markdown-like format. Useful for reading documentation, APIs, or web pages.",
-    parameters: z23.object({
-      url: z23.string().describe("The URL to fetch"),
-      format: z23.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
+    parameters: z24.object({
+      url: z24.string().describe("The URL to fetch"),
+      format: z24.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
     }),
     execute: async ({ url, format }) => {
       const outputFormat = format ?? "markdown";
@@ -3413,6 +3465,7 @@ var CapabilityRegistry = class {
       if (this.sendFileHandler) {
         this.tools.send_file = createSendFileTool(this.permissions, this.sendFileHandler);
       }
+      this.tools.approve_scope = createApproveScopeTool(this.permissions);
       logger.info("Filesystem tools registered");
     }
     if (manifest.capabilities.shell.enabled) {
@@ -4257,7 +4310,7 @@ async function runWithWatchdog(agentFn) {
   await attempt();
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/index.ts
@@ -4291,10 +4344,10 @@ function splashScreen() {
 }
 async function ask(prompt) {
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     rl.question(prompt, (answer) => {
       rl.close();
-      resolve9(answer.trim());
+      resolve10(answer.trim());
     });
   });
 }