bashkit 0.3.0 → 0.3.2

package/dist/cloudflare/index.js

@@ -0,0 +1,1251 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+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__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
+
+// node_modules/.pnpm/@vscode+ripgrep@1.17.0/node_modules/@vscode/ripgrep/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var __dirname = "/Users/joshbreite/Desktop/dev/bashkit/node_modules/.pnpm/@vscode+ripgrep@1.17.0/node_modules/@vscode/ripgrep/lib";
+  var path = (init_path(), __toCommonJS(exports_path));
+  exports.rgPath = path.join(__dirname, `../bin/rg${process.platform === "win32" ? ".exe" : ""}`);
+});
+
+// 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 Promise.resolve().then(() => __toESM(require_lib(), 1));
+    return rgPath;
+  } catch {
+    return;
+  }
+}
+
+// src/sandbox/ensure-tools.ts
+var RIPGREP_VERSION = "14.1.0";
+var ARCH_MAP = {
+  x86_64: "x86_64-unknown-linux-musl",
+  aarch64: "aarch64-unknown-linux-gnu",
+  arm64: "aarch64-unknown-linux-gnu"
+};
+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";
+}
+
+// src/sandbox/e2b.ts
+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;
+}
+// src/tools/bash.ts
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+var bashInputSchema = z.object({
+  command: z.string().describe("The command to execute"),
+  timeout: z.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
+  description: z.string().optional().describe("Clear, concise description of what this command does in 5-10 words"),
+  run_in_background: z.boolean().optional().describe("Set to true to run this command in the background")
+});
+var 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\``;
+function createBashTool(sandbox, config) {
+  const maxOutputLength = config?.maxOutputLength ?? 30000;
+  const defaultTimeout = config?.timeout ?? 120000;
+  return tool({
+    description: BASH_DESCRIPTION,
+    inputSchema: zodSchema(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"
+        };
+      }
+    }
+  });
+}
+// src/tools/read.ts
+import { tool as tool2, zodSchema as zodSchema2 } from "ai";
+import { z as z2 } from "zod";
+var readInputSchema = z2.object({
+  file_path: z2.string().describe("Absolute path to file or directory"),
+  offset: z2.number().optional().describe("Line number to start reading from (1-indexed)"),
+  limit: z2.number().optional().describe("Maximum number of lines to read")
+});
+var 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`;
+function createReadTool(sandbox, config) {
+  return tool2({
+    description: READ_DESCRIPTION,
+    inputSchema: zodSchema2(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"
+        };
+      }
+    }
+  });
+}
+// src/tools/write.ts
+import { tool as tool3, zodSchema as zodSchema3 } from "ai";
+import { z as z3 } from "zod";
+var writeInputSchema = z3.object({
+  file_path: z3.string().describe("Path to the file to write"),
+  content: z3.string().describe("Content to write to the file")
+});
+var 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)`;
+function createWriteTool(sandbox, config) {
+  return tool3({
+    description: WRITE_DESCRIPTION,
+    inputSchema: zodSchema3(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"
+        };
+      }
+    }
+  });
+}
+// src/tools/edit.ts
+import { tool as tool4, zodSchema as zodSchema4 } from "ai";
+import { z as z4 } from "zod";
+var editInputSchema = z4.object({
+  file_path: z4.string().describe("The absolute path to the file to modify"),
+  old_string: z4.string().describe("The text to replace"),
+  new_string: z4.string().describe("The text to replace it with (must be different from old_string)"),
+  replace_all: z4.boolean().optional().describe("Replace all occurrences of old_string (default false)")
+});
+var 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`;
+function createEditTool(sandbox, config) {
+  return tool4({
+    description: EDIT_DESCRIPTION,
+    inputSchema: zodSchema4(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"
+        };
+      }
+    }
+  });
+}
+// src/tools/glob.ts
+import { tool as tool5, zodSchema as zodSchema5 } from "ai";
+import { z as z5 } from "zod";
+var 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)")
+});
+var 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
+`;
+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"
+        };
+      }
+    }
+  });
+}
+// src/tools/grep.ts
+import { tool as tool6, zodSchema as zodSchema6 } from "ai";
+import { z as z6 } from "zod";
+var 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.")
+});
+var 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`;
+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
+  };
+}
+export {
+  createWriteTool,
+  createReadTool,
+  createGrepTool,
+  createGlobTool,
+  createEditTool,
+  createE2BSandbox,
+  createBashTool
+};