agent-web-os 0.1.15 → 0.1.17

package/dist/index.cjs

@@ -6028,6 +6028,7 @@ __export(index_exports, {
   createBrowserBashSession: () => createBrowserBashSession,
   defineCommand: () => Dx,
   executeBrowserBash: () => executeBrowserBash,
+  executeFd: () => executeFd,
   getServerBridge: () => getServerBridge2,
   resetServerBridge: () => resetServerBridge2
 });
@@ -43532,7 +43533,7 @@ function trackCall(method, path2) {
   }
 }
 function createFsShim(vfs2, getCwd) {
-  const resolvePath = (pathLike) => toPath(pathLike, getCwd);
+  const resolvePath2 = (pathLike) => toPath(pathLike, getCwd);
   const constants8 = {
     F_OK: 0,
     R_OK: 4,
@@ -43543,7 +43544,7 @@ function createFsShim(vfs2, getCwd) {
     readFile(pathLike, encodingOrOptions) {
       return new Promise((resolve5, reject) => {
         try {
-          const path2 = resolvePath(pathLike);
+          const path2 = resolvePath2(pathLike);
           let encoding;
           if (typeof encodingOrOptions === "string") {
             encoding = encodingOrOptions;
@@ -43563,7 +43564,7 @@ function createFsShim(vfs2, getCwd) {
     writeFile(pathLike, data2) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.writeFileSync(resolvePath(pathLike), data2);
+          vfs2.writeFileSync(resolvePath2(pathLike), data2);
           resolve5();
         } catch (err2) {
           reject(err2);
@@ -43573,7 +43574,7 @@ function createFsShim(vfs2, getCwd) {
     stat(pathLike) {
       return new Promise((resolve5, reject) => {
         try {
-          const path2 = typeof pathLike === "string" ? pathLike : resolvePath(pathLike);
+          const path2 = typeof pathLike === "string" ? pathLike : resolvePath2(pathLike);
           resolve5(vfs2.statSync(path2));
         } catch (err2) {
           reject(err2);
@@ -43581,12 +43582,12 @@ function createFsShim(vfs2, getCwd) {
       });
     },
     lstat(pathLike) {
-      return this.stat(resolvePath(pathLike));
+      return this.stat(resolvePath2(pathLike));
     },
     readdir(pathLike, options2) {
       return new Promise((resolve5, reject) => {
         try {
-          const path2 = resolvePath(pathLike);
+          const path2 = resolvePath2(pathLike);
           const entries = vfs2.readdirSync(path2);
           const opts = typeof options2 === "string" ? {} : options2;
           if (opts?.withFileTypes) {
@@ -43615,7 +43616,7 @@ function createFsShim(vfs2, getCwd) {
     mkdir(pathLike, options2) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.mkdirSync(resolvePath(pathLike), options2);
+          vfs2.mkdirSync(resolvePath2(pathLike), options2);
           resolve5();
         } catch (err2) {
           reject(err2);
@@ -43625,7 +43626,7 @@ function createFsShim(vfs2, getCwd) {
     unlink(pathLike) {
       return new Promise((resolve5, reject) => {
         try {
-          vfs2.unlinkSync(resolvePath(pathLike));
+          vfs2.unlinkSync(resolvePath2(pathLike));
           resolve5();
         } catch (err2) {
           reject(err2);
@@ -43684,7 +43685,7 @@ function createFsShim(vfs2, getCwd) {
   };
   return {
     readFileSync(pathLike, encodingOrOptions) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       let encoding;
       if (typeof encodingOrOptions === "string") {
         encoding = encodingOrOptions;
@@ -43712,18 +43713,18 @@ function createFsShim(vfs2, getCwd) {
         entry.position = bytes.length;
         return;
       }
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       vfs2.writeFileSync(path2, data2);
     },
     existsSync(pathLike) {
-      return vfs2.existsSync(resolvePath(pathLike));
+      return vfs2.existsSync(resolvePath2(pathLike));
     },
     mkdirSync(pathLike, options2) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       vfs2.mkdirSync(path2, options2);
     },
     readdirSync(pathLike, options2) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       trackCall("readdirSync", path2);
       const entries = vfs2.readdirSync(path2);
       const opts = typeof options2 === "string" ? { encoding: options2 } : options2;
@@ -43753,7 +43754,7 @@ function createFsShim(vfs2, getCwd) {
     },
     statSync(pathLike) {
       const origPath = typeof pathLike === "string" ? pathLike : String(pathLike);
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       trackCall("statSync", path2);
       const result = vfs2.statSync(path2);
       if (path2.includes("_generated")) {
@@ -43763,7 +43764,7 @@ function createFsShim(vfs2, getCwd) {
       return result;
     },
     lstatSync(pathLike) {
-      return vfs2.lstatSync(resolvePath(pathLike));
+      return vfs2.lstatSync(resolvePath2(pathLike));
     },
     fstatSync(fd2) {
       const entry = fdMap.get(fd2);
@@ -43776,7 +43777,7 @@ function createFsShim(vfs2, getCwd) {
       return vfs2.statSync(entry.path);
     },
     openSync(pathLike, flags, _mode) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       const flagStr = typeof flags === "number" ? "r" : flags;
       const exists = vfs2.existsSync(path2);
       const isWriteMode = flagStr.includes("w") || flagStr.includes("a");
@@ -43896,12 +43897,12 @@ function createFsShim(vfs2, getCwd) {
     mkdtempSync(prefix) {
       const suffix = Math.random().toString(36).slice(2, 8);
       const tempDir = `${prefix}${suffix}`;
-      const resolvedPath2 = resolvePath(tempDir);
+      const resolvedPath2 = resolvePath2(tempDir);
       vfs2.mkdirSync(resolvedPath2, { recursive: true });
       return resolvedPath2;
     },
     rmSync(pathLike, options2) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       if (!vfs2.existsSync(path2)) {
         if (options2?.force) return;
         throw createNodeError("ENOENT", "rm", path2);
@@ -43923,54 +43924,54 @@ function createFsShim(vfs2, getCwd) {
       }
     },
     unlinkSync(pathLike) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       if (path2.includes("_generated")) {
         console.log(`[fs] unlinkSync(${path2})`);
       }
       vfs2.unlinkSync(path2);
     },
     rmdirSync(pathLike) {
-      vfs2.rmdirSync(resolvePath(pathLike));
+      vfs2.rmdirSync(resolvePath2(pathLike));
     },
     renameSync(oldPathLike, newPathLike) {
-      vfs2.renameSync(resolvePath(oldPathLike), resolvePath(newPathLike));
+      vfs2.renameSync(resolvePath2(oldPathLike), resolvePath2(newPathLike));
     },
     realpathSync: Object.assign(
       function realpathSync(pathLike) {
-        return vfs2.realpathSync(resolvePath(pathLike));
+        return vfs2.realpathSync(resolvePath2(pathLike));
       },
       {
         native(pathLike) {
-          return vfs2.realpathSync(resolvePath(pathLike));
+          return vfs2.realpathSync(resolvePath2(pathLike));
         }
       }
     ),
     accessSync(pathLike, _mode) {
-      vfs2.accessSync(resolvePath(pathLike));
+      vfs2.accessSync(resolvePath2(pathLike));
     },
     copyFileSync(srcLike, destLike) {
-      const src = resolvePath(srcLike);
-      const dest = resolvePath(destLike);
+      const src = resolvePath2(srcLike);
+      const dest = resolvePath2(destLike);
       const data2 = vfs2.readFileSync(src);
       vfs2.writeFileSync(dest, data2);
     },
     watch(pathLike, optionsOrListener, listener) {
-      return vfs2.watch(resolvePath(pathLike), optionsOrListener, listener);
+      return vfs2.watch(resolvePath2(pathLike), optionsOrListener, listener);
     },
     readFile(pathLike, optionsOrCallback, callback) {
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       vfs2.readFile(path2, optionsOrCallback, callback);
     },
     stat(pathLike, callback) {
-      vfs2.stat(resolvePath(pathLike), callback);
+      vfs2.stat(resolvePath2(pathLike), callback);
     },
     lstat(pathLike, callback) {
-      vfs2.lstat(resolvePath(pathLike), callback);
+      vfs2.lstat(resolvePath2(pathLike), callback);
     },
     readdir(pathLike, optionsOrCallback, callback) {
       const cb2 = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
       const opts = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-      const path2 = resolvePath(pathLike);
+      const path2 = resolvePath2(pathLike);
       try {
         const entries = vfs2.readdirSync(path2);
         if (opts?.withFileTypes) {
@@ -43996,16 +43997,16 @@ function createFsShim(vfs2, getCwd) {
       }
     },
     realpath(pathLike, callback) {
-      vfs2.realpath(resolvePath(pathLike), callback);
+      vfs2.realpath(resolvePath2(pathLike), callback);
     },
     access(pathLike, modeOrCallback, callback) {
-      vfs2.access(resolvePath(pathLike), modeOrCallback, callback);
+      vfs2.access(resolvePath2(pathLike), modeOrCallback, callback);
     },
     createReadStream(pathLike) {
-      return vfs2.createReadStream(resolvePath(pathLike));
+      return vfs2.createReadStream(resolvePath2(pathLike));
     },
     createWriteStream(pathLike) {
-      return vfs2.createWriteStream(resolvePath(pathLike));
+      return vfs2.createWriteStream(resolvePath2(pathLike));
     },
     promises: promises4,
     constants: constants8
@@ -62153,6 +62154,7 @@ ${packages.map(([name, version4]) => `+-- ${name}@${version4}`).join("\n")}
         runtime.runFile(invocation.scriptPath);
       }
       syncExecution = false;
+      await new Promise((r10) => setTimeout(r10, 0));
       const isInteractive = process4.stdin && (process4.stdin.listenerCount("data") > 0 || process4.stdin.listenerCount("keypress") > 0);
       const asyncExitCode = isInteractive ? await exitPromise : await Promise.race([
         exitPromise,
@@ -62348,6 +62350,384 @@ function createAlmostNodeSession(fs) {
   return new AlmostNodeSession(fs);
 }
 
+// src/fd-command.ts
+function parseFdArgs(args) {
+  const opts = {
+    glob: false,
+    fixedStrings: false,
+    hidden: false,
+    noIgnore: false,
+    typeFilter: null,
+    extensions: [],
+    excludes: [],
+    maxDepth: Infinity,
+    maxResults: Infinity,
+    ignoreFiles: [],
+    absolutePath: false,
+    fullPath: false,
+    pattern: "",
+    searchPaths: []
+  };
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--glob" || arg === "-g") {
+      opts.glob = true;
+      i++;
+      continue;
+    }
+    if (arg === "--fixed-strings" || arg === "-F") {
+      opts.fixedStrings = true;
+      i++;
+      continue;
+    }
+    if (arg === "--hidden" || arg === "-H") {
+      opts.hidden = true;
+      i++;
+      continue;
+    }
+    if (arg === "--no-ignore" || arg === "-I") {
+      opts.noIgnore = true;
+      i++;
+      continue;
+    }
+    if (arg === "--absolute-path" || arg === "-a") {
+      opts.absolutePath = true;
+      i++;
+      continue;
+    }
+    if (arg === "--full-path" || arg === "-p") {
+      opts.fullPath = true;
+      i++;
+      continue;
+    }
+    if (arg === "-1") {
+      opts.maxResults = 1;
+      i++;
+      continue;
+    }
+    if (arg === "--type" || arg === "-t") {
+      const val = args[++i];
+      if (val === "f" || val === "file") opts.typeFilter = "f";
+      else if (val === "d" || val === "dir" || val === "directory") opts.typeFilter = "d";
+      i++;
+      continue;
+    }
+    if (arg === "--extension" || arg === "-e") {
+      const ext2 = args[++i];
+      if (ext2) opts.extensions.push(ext2.startsWith(".") ? ext2.slice(1) : ext2);
+      i++;
+      continue;
+    }
+    if (arg === "--exclude" || arg === "-E") {
+      const pat = args[++i];
+      if (pat) opts.excludes.push(pat);
+      i++;
+      continue;
+    }
+    if (arg === "--max-depth" || arg === "-d") {
+      const n10 = Number.parseInt(args[++i] ?? "", 10);
+      if (!Number.isNaN(n10)) opts.maxDepth = n10;
+      i++;
+      continue;
+    }
+    if (arg === "--max-results") {
+      const n10 = Number.parseInt(args[++i] ?? "", 10);
+      if (!Number.isNaN(n10)) opts.maxResults = n10;
+      i++;
+      continue;
+    }
+    if (arg === "--ignore-file") {
+      const p = args[++i];
+      if (p) opts.ignoreFiles.push(p);
+      i++;
+      continue;
+    }
+    if (arg === "--color" || arg === "--colour") {
+      i += 2;
+      continue;
+    }
+    if (arg.startsWith("--color=") || arg.startsWith("--colour=")) {
+      i++;
+      continue;
+    }
+    if (arg === "-L" || arg === "--follow") {
+      i++;
+      continue;
+    }
+    if (arg === "-s" || arg === "--case-sensitive") {
+      i++;
+      continue;
+    }
+    if (arg === "-i" || arg === "--ignore-case") {
+      i++;
+      continue;
+    }
+    if (arg === "-S" || arg === "--smart-case") {
+      i++;
+      continue;
+    }
+    if (arg === "--version" || arg === "-V") {
+      return { error: "__version__" };
+    }
+    if (arg === "--help" || arg === "-h") {
+      return { error: "__help__" };
+    }
+    if (arg.startsWith("-")) {
+      return { error: `Unknown flag: ${arg}` };
+    }
+    positional.push(arg);
+    i++;
+  }
+  if (positional.length > 0) {
+    opts.pattern = positional[0];
+    opts.searchPaths = positional.slice(1);
+  }
+  return { options: opts };
+}
+function globToRegex(pattern) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch2 = pattern[i];
+    if (ch2 === "*") {
+      if (pattern[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (pattern[i] === "/") i++;
+        continue;
+      }
+      regex += "[^/]*";
+    } else if (ch2 === "?") {
+      regex += "[^/]";
+    } else if (ch2 === "[") {
+      const close2 = pattern.indexOf("]", i + 1);
+      if (close2 !== -1) {
+        regex += pattern.slice(i, close2 + 1);
+        i = close2 + 1;
+        continue;
+      }
+      regex += "\\[";
+    } else if (ch2 === "{") {
+      const close2 = pattern.indexOf("}", i + 1);
+      if (close2 !== -1) {
+        const alternatives = pattern.slice(i + 1, close2).split(",").map((a) => a.trim());
+        regex += `(?:${alternatives.map(escapeRegex).join("|")})`;
+        i = close2 + 1;
+        continue;
+      }
+      regex += "\\{";
+    } else if (".+^$|()\\".includes(ch2)) {
+      regex += `\\${ch2}`;
+    } else {
+      regex += ch2;
+    }
+    i++;
+  }
+  return new RegExp(`^${regex}$`, "i");
+}
+function escapeRegex(s10) {
+  return s10.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseIgnorePatterns(content) {
+  const matchers = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("!")) continue;
+    let pattern = line;
+    const dirOnly = pattern.endsWith("/");
+    if (dirOnly) pattern = pattern.slice(0, -1);
+    const re = globToRegex(pattern);
+    matchers.push((relPath, isDir) => {
+      if (dirOnly && !isDir) return false;
+      const basename3 = relPath.split("/").pop() ?? relPath;
+      return re.test(basename3) || re.test(relPath);
+    });
+  }
+  return matchers;
+}
+async function loadIgnoreFile(fs, filePath) {
+  try {
+    const content = await fs.readFile(filePath);
+    return parseIgnorePatterns(content);
+  } catch {
+    return [];
+  }
+}
+function resolvePath(base, rel) {
+  if (rel.startsWith("/")) return normalizePath2(rel);
+  return normalizePath2(`${base}/${rel}`);
+}
+function normalizePath2(p) {
+  const parts = p.split("/").filter(Boolean);
+  const result = [];
+  for (const part of parts) {
+    if (part === "..") result.pop();
+    else if (part !== ".") result.push(part);
+  }
+  return `/${result.join("/")}`;
+}
+async function executeFd(args, ctx) {
+  const parsed = parseFdArgs(args);
+  if ("error" in parsed) {
+    if (parsed.error === "__version__") {
+      return { stdout: "fd 10.2.0 (just-bash)\n", stderr: "", exitCode: 0 };
+    }
+    if (parsed.error === "__help__") {
+      return {
+        stdout: [
+          "Usage: fd [OPTIONS] [pattern] [path...]",
+          "",
+          "Options:",
+          "  -H, --hidden           Include hidden files/directories",
+          "  -I, --no-ignore        Don't respect .gitignore",
+          "  -g, --glob             Glob-based search",
+          "  -F, --fixed-strings    Literal string search",
+          "  -t, --type <type>      Filter by type: f(ile), d(irectory)",
+          "  -e, --extension <ext>  Filter by extension",
+          "  -E, --exclude <pat>    Exclude pattern",
+          "  -d, --max-depth <n>    Maximum search depth",
+          "      --max-results <n>  Maximum number of results",
+          "  -a, --absolute-path    Show absolute paths",
+          "  -p, --full-path        Match against full path",
+          "      --ignore-file <f>  Additional ignore file",
+          "      --color <when>     (always off in browser)",
+          "  -1                     Stop after first result",
+          ""
+        ].join("\n"),
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    return { stdout: "", stderr: `error: ${parsed.error}
+`, exitCode: 1 };
+  }
+  const opts = parsed.options;
+  const fs = ctx.fs;
+  const cwd = ctx.cwd ?? "/";
+  const searchRoots = opts.searchPaths.length > 0 ? opts.searchPaths.map((p) => resolvePath(cwd, p)) : [cwd];
+  let matchRegex = null;
+  if (opts.pattern) {
+    if (opts.fixedStrings) {
+      matchRegex = new RegExp(escapeRegex(opts.pattern), "i");
+    } else if (opts.glob) {
+      matchRegex = globToRegex(opts.pattern);
+    } else {
+      try {
+        matchRegex = new RegExp(opts.pattern, "i");
+      } catch {
+        return { stdout: "", stderr: `error: invalid regex: ${opts.pattern}
+`, exitCode: 1 };
+      }
+    }
+  }
+  const excludeMatchers = opts.excludes.map((p) => globToRegex(p));
+  const ignoreMatchers = [];
+  if (!opts.noIgnore) {
+    for (const root2 of searchRoots) {
+      const gitignorePath = `${root2}/.gitignore`;
+      const loaded = await loadIgnoreFile(fs, gitignorePath);
+      ignoreMatchers.push(...loaded);
+    }
+  }
+  for (const ignoreFile of opts.ignoreFiles) {
+    const absPath = resolvePath(cwd, ignoreFile);
+    const loaded = await loadIgnoreFile(fs, absPath);
+    ignoreMatchers.push(...loaded);
+  }
+  const results = [];
+  let limitReached = false;
+  async function walk(dirPath, rootPath, depth) {
+    if (limitReached) return;
+    if (depth > opts.maxDepth) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dirPath);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (limitReached) return;
+      if (!opts.hidden && entry.startsWith(".")) continue;
+      const fullPath = `${dirPath}/${entry}`;
+      let isDir = false;
+      let isFile = false;
+      try {
+        const st2 = await fs.stat(fullPath);
+        isDir = st2.isDirectory;
+        isFile = st2.isFile;
+      } catch {
+        continue;
+      }
+      const relPath = fullPath.slice(rootPath.length + 1) || entry;
+      if (!opts.noIgnore && ignoreMatchers.some((m) => m(relPath, isDir))) continue;
+      const basename3 = entry;
+      if (excludeMatchers.some((re) => re.test(basename3) || re.test(relPath))) continue;
+      if (opts.typeFilter === "f" && !isFile) {
+        if (isDir) await walk(fullPath, rootPath, depth + 1);
+        continue;
+      }
+      if (opts.typeFilter === "d" && !isDir) continue;
+      if (opts.extensions.length > 0) {
+        const dotIdx = entry.lastIndexOf(".");
+        const ext2 = dotIdx >= 0 ? entry.slice(dotIdx + 1) : "";
+        if (!opts.extensions.some((e10) => e10.toLowerCase() === ext2.toLowerCase())) {
+          if (isDir) await walk(fullPath, rootPath, depth + 1);
+          continue;
+        }
+      }
+      if (matchRegex) {
+        const target = opts.fullPath ? relPath : basename3;
+        if (!matchRegex.test(target)) {
+          if (isDir) await walk(fullPath, rootPath, depth + 1);
+          continue;
+        }
+      }
+      const output = opts.absolutePath ? fullPath : relPath;
+      results.push(output);
+      if (results.length >= opts.maxResults) {
+        limitReached = true;
+        return;
+      }
+      if (isDir) {
+        await walk(fullPath, rootPath, depth + 1);
+      }
+    }
+  }
+  for (const root2 of searchRoots) {
+    if (limitReached) break;
+    try {
+      const st2 = await fs.stat(root2);
+      if (!st2.isDirectory) {
+        return { stdout: "", stderr: `error: '${root2}' is not a directory
+`, exitCode: 1 };
+      }
+    } catch {
+      return { stdout: "", stderr: `error: '${root2}': No such file or directory
+`, exitCode: 1 };
+    }
+    if (!opts.noIgnore) {
+      const rootGitignore = `${root2}/.gitignore`;
+      const loaded = await loadIgnoreFile(fs, rootGitignore);
+      if (loaded.length > 0) {
+        ignoreMatchers.push(...loaded);
+      }
+    }
+    await walk(root2, root2, 1);
+  }
+  results.sort();
+  if (results.length === 0) {
+    return { stdout: "", stderr: "", exitCode: 1 };
+  }
+  return { stdout: results.join("\n") + "\n", stderr: "", exitCode: 0 };
+}
+
 // src/browser-bash-session.ts
 var DEFAULT_BASH_SHELL_ENV = {
   LANG: "C.UTF-8",
@@ -62401,6 +62781,7 @@ function createBrowserBashSession(options2 = {}) {
     customCommands: [
       Dx("node", async (args, ctx) => almostNodeSession.executeNode(args, ctx)),
       Dx("npm", async (args, ctx) => almostNodeSession.executeNpm(args, ctx)),
+      Dx("fd", async (args, ctx) => executeFd(args, ctx)),
       ...options2.customCommands ?? []
     ]
   });
@@ -62488,7 +62869,7 @@ async function executeBrowserBash(session, command, options2 = {}) {
 }
 
 // src/index.ts
-var AGENT_WEB_OS_VERSION = "0.1.15";
+var AGENT_WEB_OS_VERSION = "0.1.17";
 console.log(`[agent-web-os] v${AGENT_WEB_OS_VERSION}`);
 var getServerBridge2 = getServerBridge;
 var resetServerBridge2 = resetServerBridge;