bashkit 0.3.0 → 0.3.2

package/dist/workflow.js

@@ -0,0 +1,1051 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/read.ts
+var exports_read = {};
+__export(exports_read, {
+  readInputSchema: () => readInputSchema,
+  createReadTool: () => createReadTool,
+  READ_DESCRIPTION: () => READ_DESCRIPTION
+});
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+function createReadTool(sandbox, config) {
+  return tool({
+    description: READ_DESCRIPTION,
+    inputSchema: zodSchema(readInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      offset,
+      limit
+    }) => {
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `Path not found: ${file_path}` };
+        }
+        const isDir = await sandbox.isDirectory(file_path);
+        if (isDir) {
+          const entries = await sandbox.readDir(file_path);
+          return {
+            type: "directory",
+            entries,
+            count: entries.length
+          };
+        }
+        const content = await sandbox.readFile(file_path);
+        const nullByteIndex = content.indexOf("\x00");
+        if (nullByteIndex !== -1 && nullByteIndex < 1000) {
+          const ext = file_path.split(".").pop()?.toLowerCase();
+          const binaryExtensions = [
+            "pdf",
+            "png",
+            "jpg",
+            "jpeg",
+            "gif",
+            "zip",
+            "tar",
+            "gz",
+            "exe",
+            "bin",
+            "so",
+            "dylib"
+          ];
+          if (binaryExtensions.includes(ext || "")) {
+            return {
+              error: `Cannot read binary file: ${file_path} (file exists, ${content.length} bytes). Use appropriate tools to process ${ext?.toUpperCase()} files (e.g., Python scripts for PDFs).`
+            };
+          }
+        }
+        const allLines = content.split(`
+`);
+        const totalLines = allLines.length;
+        const maxLinesWithoutLimit = config?.maxFileSize || 500;
+        if (!limit && totalLines > maxLinesWithoutLimit) {
+          return {
+            error: `File is large (${totalLines} lines). Use 'offset' and 'limit' to read in chunks. Example: offset=1, limit=100 for first 100 lines.`
+          };
+        }
+        const startLine = offset ? offset - 1 : 0;
+        const endLine = limit ? startLine + limit : allLines.length;
+        const selectedLines = allLines.slice(startLine, endLine);
+        const lines = selectedLines.map((line, i) => ({
+          line_number: startLine + i + 1,
+          content: line
+        }));
+        return {
+          type: "text",
+          content: selectedLines.join(`
+`),
+          lines,
+          total_lines: totalLines
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var readInputSchema, READ_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 500 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files)
+- Results are returned with line numbers starting at 1
+- This tool can only read text files, not binary files (images, PDFs, etc.)
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- It is always better to speculatively read multiple potentially useful files in parallel
+- If you read a file that exists but has empty contents you will receive a warning in place of file contents`;
+var init_read = __esm(() => {
+  readInputSchema = z.object({
+    file_path: z.string().describe("Absolute path to file or directory"),
+    offset: z.number().optional().describe("Line number to start reading from (1-indexed)"),
+    limit: z.number().optional().describe("Maximum number of lines to read")
+  });
+});
+
+// src/tools/write.ts
+var exports_write = {};
+__export(exports_write, {
+  writeInputSchema: () => writeInputSchema,
+  createWriteTool: () => createWriteTool,
+  WRITE_DESCRIPTION: () => WRITE_DESCRIPTION
+});
+import { tool as tool2, zodSchema as zodSchema2 } from "ai";
+import { z as z2 } from "zod";
+function createWriteTool(sandbox, config) {
+  return tool2({
+    description: WRITE_DESCRIPTION,
+    inputSchema: zodSchema2(writeInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      content
+    }) => {
+      const byteLength = Buffer.byteLength(content, "utf-8");
+      if (config?.maxFileSize && byteLength > config.maxFileSize) {
+        return {
+          error: `File content exceeds maximum size of ${config.maxFileSize} bytes (got ${byteLength})`
+        };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        await sandbox.writeFile(file_path, content);
+        return {
+          message: `Successfully wrote to ${file_path}`,
+          bytes_written: byteLength,
+          file_path
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var writeInputSchema, WRITE_DESCRIPTION = `Writes content to a file on the filesystem.
+
+**Important guidelines:**
+- This tool will overwrite existing files at the provided path
+- If modifying an existing file, you MUST use the Read tool first to read the file's contents
+- ALWAYS prefer editing existing files over creating new ones
+- NEVER proactively create documentation files (*.md) or README files unless explicitly requested
+- The file_path must be an absolute path, not relative
+
+**When to use Write vs Edit:**
+- Use Write for creating new files or completely replacing file contents
+- Use Edit for making targeted changes to existing files (preferred for modifications)`;
+var init_write = __esm(() => {
+  writeInputSchema = z2.object({
+    file_path: z2.string().describe("Path to the file to write"),
+    content: z2.string().describe("Content to write to the file")
+  });
+});
+
+// src/tools/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  editInputSchema: () => editInputSchema,
+  createEditTool: () => createEditTool,
+  EDIT_DESCRIPTION: () => EDIT_DESCRIPTION
+});
+import { tool as tool3, zodSchema as zodSchema3 } from "ai";
+import { z as z3 } from "zod";
+function createEditTool(sandbox, config) {
+  return tool3({
+    description: EDIT_DESCRIPTION,
+    inputSchema: zodSchema3(editInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      old_string,
+      new_string,
+      replace_all = false
+    }) => {
+      if (old_string === new_string) {
+        return { error: "old_string and new_string must be different" };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `File not found: ${file_path}` };
+        }
+        const content = await sandbox.readFile(file_path);
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return { error: `String not found in file: "${old_string}"` };
+        }
+        if (!replace_all && occurrences > 1) {
+          return {
+            error: `String appears ${occurrences} times in file. Use replace_all=true to replace all, or provide a more unique string.`
+          };
+        }
+        let newContent;
+        let replacements;
+        if (replace_all) {
+          newContent = content.split(old_string).join(new_string);
+          replacements = occurrences;
+        } else {
+          newContent = content.replace(old_string, new_string);
+          replacements = 1;
+        }
+        await sandbox.writeFile(file_path, newContent);
+        return {
+          message: `Successfully edited ${file_path}`,
+          file_path,
+          replacements
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var editInputSchema, EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+**Important guidelines:**
+- You MUST use the Read tool first before editing any file
+- Preserve exact indentation (tabs/spaces) when replacing text
+- The old_string must be unique in the file, or the edit will fail
+- If old_string appears multiple times, either provide more context to make it unique, or use replace_all=true
+
+**Parameters:**
+- old_string: The exact text to find and replace (must match exactly, including whitespace)
+- new_string: The replacement text (must be different from old_string)
+- replace_all: Set to true to replace all occurrences (useful for renaming variables)
+
+**When to use:**
+- Making targeted changes to existing files
+- Renaming variables or functions (with replace_all=true)
+- Updating specific sections`;
+var init_edit = __esm(() => {
+  editInputSchema = z3.object({
+    file_path: z3.string().describe("The absolute path to the file to modify"),
+    old_string: z3.string().describe("The text to replace"),
+    new_string: z3.string().describe("The text to replace it with (must be different from old_string)"),
+    replace_all: z3.boolean().optional().describe("Replace all occurrences of old_string (default false)")
+  });
+});
+
+// src/tools/bash.ts
+var exports_bash = {};
+__export(exports_bash, {
+  createBashTool: () => createBashTool,
+  bashInputSchema: () => bashInputSchema,
+  BASH_DESCRIPTION: () => BASH_DESCRIPTION
+});
+import { tool as tool4, zodSchema as zodSchema4 } from "ai";
+import { z as z4 } from "zod";
+function createBashTool(sandbox, config) {
+  const maxOutputLength = config?.maxOutputLength ?? 30000;
+  const defaultTimeout = config?.timeout ?? 120000;
+  return tool4({
+    description: BASH_DESCRIPTION,
+    inputSchema: zodSchema4(bashInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      command,
+      timeout,
+      description: _description,
+      run_in_background: _run_in_background
+    }) => {
+      if (config?.blockedCommands) {
+        for (const blocked of config.blockedCommands) {
+          if (command.includes(blocked)) {
+            return {
+              error: `Command blocked: contains '${blocked}'`
+            };
+          }
+        }
+      }
+      try {
+        const effectiveTimeout = Math.min(timeout ?? defaultTimeout, 600000);
+        const result = await sandbox.exec(command, {
+          timeout: effectiveTimeout
+        });
+        let stdout = result.stdout;
+        let stderr = result.stderr;
+        if (stdout.length > maxOutputLength) {
+          stdout = stdout.slice(0, maxOutputLength) + `
+[output truncated, ${stdout.length - maxOutputLength} chars omitted]`;
+        }
+        if (stderr.length > maxOutputLength) {
+          stderr = stderr.slice(0, maxOutputLength) + `
+[output truncated, ${stderr.length - maxOutputLength} chars omitted]`;
+        }
+        return {
+          stdout,
+          stderr,
+          exit_code: result.exitCode,
+          interrupted: result.interrupted,
+          duration_ms: result.durationMs
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var bashInputSchema, BASH_DESCRIPTION = `Executes a bash command in a persistent shell session with optional timeout.
+
+IMPORTANT: For file operations (reading, writing, editing, searching, finding files) - use the specialized tools instead of bash commands.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use \`ls\` to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use \`ls foo\` to check that "foo" exists
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., cd "/path/with spaces")
+   - Examples of proper quoting:
+     - cd "/Users/name/My Documents" (correct)
+     - cd /Users/name/My Documents (incorrect - will fail)
+   - After ensuring proper quoting, execute the command
+
+Usage notes:
+  - The command argument is required
+  - You can specify an optional timeout in milliseconds (max 600000ms / 10 minutes). Default is 120000ms (2 minutes).
+  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words
+  - If the output exceeds 30000 characters, output will be truncated
+  - Avoid using \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands. Instead, use dedicated tools:
+    - File search: Use Glob (NOT find or ls)
+    - Content search: Use Grep (NOT grep or rg)
+    - Read files: Use Read (NOT cat/head/tail)
+    - Edit files: Use Edit (NOT sed/awk)
+    - Write files: Use Write (NOT echo >/cat <<EOF)
+  - When issuing multiple commands:
+    - If commands are independent, make multiple Bash tool calls in parallel
+    - If commands depend on each other, use '&&' to chain them (e.g., \`git add . && git commit -m "message"\`)
+    - Use ';' only when you need sequential execution but don't care if earlier commands fail
+    - DO NOT use newlines to separate commands
+  - Try to maintain your current working directory by using absolute paths and avoiding \`cd\``;
+var init_bash = __esm(() => {
+  bashInputSchema = z4.object({
+    command: z4.string().describe("The command to execute"),
+    timeout: z4.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
+    description: z4.string().optional().describe("Clear, concise description of what this command does in 5-10 words"),
+    run_in_background: z4.boolean().optional().describe("Set to true to run this command in the background")
+  });
+});
+
+// src/tools/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  globInputSchema: () => globInputSchema,
+  createGlobTool: () => createGlobTool,
+  GLOB_DESCRIPTION: () => GLOB_DESCRIPTION
+});
+import { tool as tool5, zodSchema as zodSchema5 } from "ai";
+import { z as z5 } from "zod";
+function createGlobTool(sandbox, config) {
+  return tool5({
+    description: GLOB_DESCRIPTION,
+    inputSchema: zodSchema5(globInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      pattern,
+      path
+    }) => {
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        const result = await sandbox.exec(`find ${searchPath} -type f -name "${pattern}" 2>/dev/null | head -1000`, { timeout: config?.timeout });
+        if (result.exitCode !== 0 && result.stderr) {
+          return { error: result.stderr };
+        }
+        const matches = result.stdout.split(`
+`).filter(Boolean).map((p) => p.trim());
+        return {
+          matches,
+          count: matches.length,
+          search_path: searchPath
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var globInputSchema, GLOB_DESCRIPTION = `
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- It is always better to speculatively perform multiple searches in parallel if they are potentially useful
+`;
+var init_glob = __esm(() => {
+  globInputSchema = z5.object({
+    pattern: z5.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js", "*.md")'),
+    path: z5.string().optional().describe("Directory to search in (defaults to working directory)")
+  });
+});
+
+// src/tools/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  grepInputSchema: () => grepInputSchema,
+  createGrepTool: () => createGrepTool,
+  GREP_DESCRIPTION: () => GREP_DESCRIPTION
+});
+import { tool as tool6, zodSchema as zodSchema6 } from "ai";
+import { z as z6 } from "zod";
+function createGrepTool(sandbox, config) {
+  return tool6({
+    description: GREP_DESCRIPTION,
+    inputSchema: zodSchema6(grepInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async (input) => {
+      const {
+        pattern,
+        path,
+        glob,
+        type,
+        output_mode = "files_with_matches",
+        "-i": caseInsensitive,
+        "-B": beforeContext,
+        "-A": afterContext,
+        "-C": context,
+        head_limit,
+        offset = 0,
+        multiline
+      } = input;
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        if (!sandbox.rgPath) {
+          return {
+            error: "Ripgrep not available. Call ensureSandboxTools(sandbox) before using Grep with remote sandboxes."
+          };
+        }
+        const cmd = buildRipgrepCommand({
+          rgPath: sandbox.rgPath,
+          pattern,
+          searchPath,
+          output_mode,
+          caseInsensitive,
+          beforeContext,
+          afterContext,
+          context,
+          glob,
+          type,
+          multiline
+        });
+        const result = await sandbox.exec(cmd, { timeout: config?.timeout });
+        if (output_mode === "files_with_matches") {
+          return parseFilesOutput(result.stdout);
+        } else if (output_mode === "count") {
+          return parseCountOutput(result.stdout);
+        } else {
+          return parseContentOutput(result.stdout, head_limit, offset);
+        }
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+function buildRipgrepCommand(opts) {
+  const flags = ["--json"];
+  if (opts.caseInsensitive)
+    flags.push("-i");
+  if (opts.multiline)
+    flags.push("-U", "--multiline-dotall");
+  if (opts.output_mode === "content") {
+    if (opts.context) {
+      flags.push(`-C ${opts.context}`);
+    } else {
+      if (opts.beforeContext)
+        flags.push(`-B ${opts.beforeContext}`);
+      if (opts.afterContext)
+        flags.push(`-A ${opts.afterContext}`);
+    }
+  }
+  if (opts.glob)
+    flags.push(`-g "${opts.glob}"`);
+  if (opts.type)
+    flags.push(`-t ${opts.type}`);
+  const flagStr = flags.join(" ");
+  return `${opts.rgPath} ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null`;
+}
+function parseFilesOutput(stdout) {
+  const files = new Set;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        files.add(data.path.text);
+      }
+    } catch {}
+  }
+  return {
+    files: Array.from(files),
+    count: files.size
+  };
+}
+function parseCountOutput(stdout) {
+  const counts = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "end") {
+        const data = msg.data;
+        counts.set(data.path.text, data.stats.matches);
+      }
+    } catch {}
+  }
+  const countsArray = Array.from(counts.entries()).map(([file, count]) => ({
+    file,
+    count
+  }));
+  const total = countsArray.reduce((sum, c) => sum + c.count, 0);
+  return {
+    counts: countsArray,
+    total
+  };
+}
+function parseContentOutput(stdout, head_limit, offset = 0) {
+  const fileData = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        fileData.set(data.path.text, { matches: [], contexts: [] });
+      } else if (msg.type === "context") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.contexts.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      } else if (msg.type === "match") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.matches.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      }
+    } catch {}
+  }
+  const allMatches = [];
+  for (const [file, { matches, contexts }] of fileData) {
+    matches.sort((a, b) => a.line_number - b.line_number);
+    contexts.sort((a, b) => a.line_number - b.line_number);
+    const matchContexts = new Map;
+    for (const match of matches) {
+      matchContexts.set(match.line_number, { before: [], after: [] });
+    }
+    for (const ctx of contexts) {
+      let bestMatch = null;
+      let bestDistance = Infinity;
+      let isBefore = false;
+      for (const match of matches) {
+        const distance = Math.abs(ctx.line_number - match.line_number);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestMatch = match;
+          isBefore = ctx.line_number < match.line_number;
+        }
+      }
+      if (bestMatch) {
+        const mc = matchContexts.get(bestMatch.line_number);
+        if (mc) {
+          if (isBefore) {
+            mc.before.push(ctx.text);
+          } else {
+            mc.after.push(ctx.text);
+          }
+        }
+      }
+    }
+    for (const match of matches) {
+      const mc = matchContexts.get(match.line_number);
+      allMatches.push({
+        file,
+        line_number: match.line_number,
+        line: match.text,
+        before_context: mc?.before ?? [],
+        after_context: mc?.after ?? []
+      });
+    }
+  }
+  const grepMatches = allMatches.map((m) => ({
+    file: m.file,
+    line_number: m.line_number,
+    line: m.line,
+    before_context: m.before_context.length > 0 ? m.before_context : undefined,
+    after_context: m.after_context.length > 0 ? m.after_context : undefined
+  }));
+  let result = grepMatches;
+  if (offset > 0) {
+    result = result.slice(offset);
+  }
+  if (head_limit && head_limit > 0) {
+    result = result.slice(0, head_limit);
+  }
+  return {
+    matches: result,
+    total_matches: result.length
+  };
+}
+var grepInputSchema, GREP_DESCRIPTION = `A powerful content search tool built on ripgrep with regex support.
+
+**Usage:**
+- ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+
+**Output modes:**
+- "content": Shows matching lines with optional context
+- "files_with_matches": Shows only file paths (default)
+- "count": Shows match counts per file
+
+**Context options (content mode only):**
+- -B: Lines to show before each match
+- -A: Lines to show after each match
+- -C: Lines to show before and after each match
+
+**Pagination:**
+- Use offset to skip results (useful for pagination)
+- Use head_limit to limit total results returned`;
+var init_grep = __esm(() => {
+  grepInputSchema = z6.object({
+    pattern: z6.string().describe("The regular expression pattern to search for in file contents"),
+    path: z6.string().optional().describe("File or directory to search in (defaults to cwd)"),
+    glob: z6.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+    type: z6.string().optional().describe('File type to search (e.g. "js", "py", "rust")'),
+    output_mode: z6.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths (default), "count" shows match counts'),
+    "-i": z6.boolean().optional().describe("Case insensitive search"),
+    "-n": z6.boolean().optional().describe("Show line numbers in output. Requires output_mode: 'content'. Defaults to true."),
+    "-B": z6.number().optional().describe("Number of lines to show before each match. Requires output_mode: 'content'."),
+    "-A": z6.number().optional().describe("Number of lines to show after each match. Requires output_mode: 'content'."),
+    "-C": z6.number().optional().describe("Number of lines to show before and after each match. Requires output_mode: 'content'."),
+    head_limit: z6.number().optional().describe("Limit output to first N lines/entries. Works across all output modes. Defaults to 0 (unlimited)."),
+    offset: z6.number().optional().describe("Skip first N lines/entries before applying head_limit. Works across all output modes. Defaults to 0."),
+    multiline: z6.boolean().optional().describe("Enable multiline mode where patterns can span lines. Default: false.")
+  });
+});
+
+// src/sandbox/lazy-singleton.ts
+function createLazySingleton(factory) {
+  let promise = null;
+  return {
+    get: () => {
+      if (!promise) {
+        promise = factory();
+      }
+      return promise;
+    },
+    reset: () => {
+      promise = null;
+    }
+  };
+}
+
+// src/sandbox/ripgrep.ts
+async function getBundledRgPath() {
+  try {
+    const { rgPath } = await import("@vscode/ripgrep");
+    return rgPath;
+  } catch {
+    return;
+  }
+}
+function getBundledRgPathSync() {
+  try {
+    const { rgPath } = __require("@vscode/ripgrep");
+    return rgPath;
+  } catch {
+    return;
+  }
+}
+
+// src/sandbox/ensure-tools.ts
+async function ensureSandboxTools(sandbox) {
+  const bundledRgPath = await getBundledRgPath();
+  if (bundledRgPath) {
+    const bundledCheck = await sandbox.exec(`test -x "${bundledRgPath}" && echo found`);
+    if (bundledCheck.stdout.includes("found")) {
+      sandbox.rgPath = bundledRgPath;
+      return;
+    }
+  }
+  const tmpCheck = await sandbox.exec("test -x /tmp/rg && echo found");
+  if (tmpCheck.stdout.includes("found")) {
+    sandbox.rgPath = "/tmp/rg";
+    return;
+  }
+  const systemCheck = await sandbox.exec("which rg 2>/dev/null");
+  if (systemCheck.exitCode === 0 && systemCheck.stdout.trim()) {
+    sandbox.rgPath = systemCheck.stdout.trim();
+    return;
+  }
+  const archResult = await sandbox.exec("uname -m");
+  const arch = archResult.stdout.trim();
+  const ripgrepArch = ARCH_MAP[arch];
+  if (!ripgrepArch) {
+    throw new Error(`Unsupported architecture: ${arch}. Supported: ${Object.keys(ARCH_MAP).join(", ")}`);
+  }
+  const ripgrepUrl = `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-${ripgrepArch}.tar.gz`;
+  const tarPath = `ripgrep-${RIPGREP_VERSION}-${ripgrepArch}/rg`;
+  const installResult = await sandbox.exec(`
+    curl -sL "${ripgrepUrl}" |
+    tar xzf - -C /tmp --strip-components=1 ${tarPath} &&
+    chmod +x /tmp/rg
+  `);
+  if (installResult.exitCode !== 0) {
+    throw new Error(`Failed to install ripgrep: ${installResult.stderr}`);
+  }
+  sandbox.rgPath = "/tmp/rg";
+}
+var RIPGREP_VERSION = "14.1.0", ARCH_MAP;
+var init_ensure_tools = __esm(() => {
+  ARCH_MAP = {
+    x86_64: "x86_64-unknown-linux-musl",
+    aarch64: "aarch64-unknown-linux-gnu",
+    arm64: "aarch64-unknown-linux-gnu"
+  };
+});
+
+// src/sandbox/e2b.ts
+var exports_e2b = {};
+__export(exports_e2b, {
+  createE2BSandbox: () => createE2BSandbox
+});
+async function createE2BSandbox(config = {}) {
+  let sandboxId = config.sandboxId;
+  const workingDirectory = config.cwd || "/home/user";
+  const timeout = config.timeout ?? 300000;
+  const sandbox = createLazySingleton(async () => {
+    let E2BSandboxSDK;
+    try {
+      const module = await import("@e2b/code-interpreter");
+      E2BSandboxSDK = module.Sandbox;
+    } catch {
+      throw new Error("E2BSandbox requires @e2b/code-interpreter. Install with: npm install @e2b/code-interpreter");
+    }
+    let sbx;
+    if (config.sandboxId) {
+      sbx = await E2BSandboxSDK.connect(config.sandboxId);
+    } else {
+      sbx = await E2BSandboxSDK.create({
+        apiKey: config.apiKey,
+        timeoutMs: timeout,
+        metadata: config.metadata
+      });
+      sandboxId = sbx.sandboxId;
+    }
+    return sbx;
+  });
+  const exec = async (command, options) => {
+    const sbx = await sandbox.get();
+    const startTime = performance.now();
+    try {
+      const result = await sbx.commands.run(command, {
+        cwd: options?.cwd || workingDirectory,
+        timeoutMs: options?.timeout
+      });
+      const durationMs = Math.round(performance.now() - startTime);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        durationMs,
+        interrupted: false
+      };
+    } catch (error) {
+      const durationMs = Math.round(performance.now() - startTime);
+      if (error instanceof Error && error.message.toLowerCase().includes("timeout")) {
+        return {
+          stdout: "",
+          stderr: "Command timed out",
+          exitCode: 124,
+          durationMs,
+          interrupted: true
+        };
+      }
+      if (error instanceof Error) {
+        const exitMatch = error.message.match(/exit status (\d+)/i);
+        const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : 1;
+        return {
+          stdout: "",
+          stderr: error.message,
+          exitCode,
+          durationMs,
+          interrupted: false
+        };
+      }
+      throw error;
+    }
+  };
+  let rgPath;
+  const sandboxObj = {
+    exec,
+    get id() {
+      return sandboxId;
+    },
+    get rgPath() {
+      return rgPath;
+    },
+    set rgPath(path) {
+      rgPath = path;
+    },
+    async readFile(path) {
+      const result = await exec(`cat "${path}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to read file: ${result.stderr}`);
+      }
+      return result.stdout;
+    },
+    async writeFile(path, content) {
+      const sbx = await sandbox.get();
+      await sbx.files.write(path, content);
+    },
+    async readDir(path) {
+      const result = await exec(`ls -1 "${path}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to read directory: ${result.stderr}`);
+      }
+      return result.stdout.split(`
+`).filter(Boolean);
+    },
+    async fileExists(path) {
+      const result = await exec(`test -e "${path}"`);
+      return result.exitCode === 0;
+    },
+    async isDirectory(path) {
+      const result = await exec(`test -d "${path}"`);
+      return result.exitCode === 0;
+    },
+    async destroy() {
+      try {
+        const sbx = await sandbox.get();
+        await sbx.kill();
+      } catch {}
+      sandbox.reset();
+    }
+  };
+  if (config.ensureTools !== false) {
+    await ensureSandboxTools(sandboxObj);
+  }
+  return sandboxObj;
+}
+var init_e2b = __esm(() => {
+  init_ensure_tools();
+});
+
+// src/workflow.ts
+init_read();
+init_write();
+init_edit();
+init_bash();
+init_glob();
+init_grep();
+import { tool as tool7, zodSchema as zodSchema7 } from "ai";
+function createDurableAgentTools(sandboxId, config) {
+  const toolsConfig = config?.tools || {};
+  const _sandboxId = sandboxId;
+  const _apiKey = config?.apiKey;
+  const _readConfig = toolsConfig.Read;
+  const _bashConfig = toolsConfig.Bash;
+  const tools = {
+    Read: tool7({
+      description: READ_DESCRIPTION,
+      inputSchema: zodSchema7(readInputSchema),
+      execute: async function readFile(params, options) {
+        "use step";
+        const { createReadTool: createReadTool2 } = await Promise.resolve().then(() => (init_read(), exports_read));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const readTool = createReadTool2(sandbox, _readConfig);
+        if (!readTool.execute)
+          throw new Error("Read tool missing execute");
+        return readTool.execute(params, options);
+      }
+    }),
+    Write: tool7({
+      description: WRITE_DESCRIPTION,
+      inputSchema: zodSchema7(writeInputSchema),
+      execute: async function writeFile(params, options) {
+        "use step";
+        const { createWriteTool: createWriteTool2 } = await Promise.resolve().then(() => (init_write(), exports_write));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const writeTool = createWriteTool2(sandbox);
+        if (!writeTool.execute)
+          throw new Error("Write tool missing execute");
+        return writeTool.execute(params, options);
+      }
+    }),
+    Edit: tool7({
+      description: EDIT_DESCRIPTION,
+      inputSchema: zodSchema7(editInputSchema),
+      execute: async function editFile(params, options) {
+        "use step";
+        const { createEditTool: createEditTool2 } = await Promise.resolve().then(() => (init_edit(), exports_edit));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const editTool = createEditTool2(sandbox);
+        if (!editTool.execute)
+          throw new Error("Edit tool missing execute");
+        return editTool.execute(params, options);
+      }
+    }),
+    Bash: tool7({
+      description: BASH_DESCRIPTION,
+      inputSchema: zodSchema7(bashInputSchema),
+      execute: async function runBash(params, options) {
+        "use step";
+        const { createBashTool: createBashTool2 } = await Promise.resolve().then(() => (init_bash(), exports_bash));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const bashTool = createBashTool2(sandbox, _bashConfig);
+        if (!bashTool.execute)
+          throw new Error("Bash tool missing execute");
+        return bashTool.execute(params, options);
+      }
+    }),
+    Glob: tool7({
+      description: GLOB_DESCRIPTION,
+      inputSchema: zodSchema7(globInputSchema),
+      execute: async function globFiles(params, options) {
+        "use step";
+        const { createGlobTool: createGlobTool2 } = await Promise.resolve().then(() => (init_glob(), exports_glob));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const globTool = createGlobTool2(sandbox);
+        if (!globTool.execute)
+          throw new Error("Glob tool missing execute");
+        return globTool.execute(params, options);
+      }
+    }),
+    Grep: tool7({
+      description: GREP_DESCRIPTION,
+      inputSchema: zodSchema7(grepInputSchema),
+      execute: async function grepSearch(params, options) {
+        "use step";
+        const { createGrepTool: createGrepTool2 } = await Promise.resolve().then(() => (init_grep(), exports_grep));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const grepTool = createGrepTool2(sandbox);
+        if (!grepTool.execute)
+          throw new Error("Grep tool missing execute");
+        return grepTool.execute(params, options);
+      }
+    })
+  };
+  return { tools };
+}
+export {
+  createDurableAgentTools
+};