agent-web-os 0.3.4 → 0.4.0-beta.0

package/dist/index.js

@@ -1,958 +1,19 @@
 import {
-  getServerBridge,
-  posixPath,
-  resetServerBridge
-} from "./chunk-FNHNA3XU.js";
+  DEFAULT_BASH_SHELL_ENV,
+  ObservableInMemoryFs,
+  assertObservableInMemoryFs,
+  createBrowserBashSession,
+  executeBrowserBash,
+  executeFd
+} from "./chunk-THD7G37K.js";
 import {
   Dx,
-  Ir,
   Ju
 } from "./chunk-JTZ3QUCT.js";
 import "./chunk-PR4QN5HX.js";
 
-// src/observable-in-memory-fs.ts
-function isObservableInMemoryFsLike(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.subscribe === "function" && typeof candidate.exists === "function" && typeof candidate.readFile === "function" && typeof candidate.readdir === "function" && typeof candidate.stat === "function";
-}
-function assertObservableInMemoryFs(value) {
-  if (!isObservableInMemoryFsLike(value)) {
-    throw new Error("Expected ObservableInMemoryFs-backed just-bash filesystem");
-  }
-  return value;
-}
-async function readPathState(fs, path) {
-  const exists = await fs.exists(path);
-  if (!exists) {
-    return { exists: false };
-  }
-  if (isObservableInMemoryFsLike(fs) && fs.isPathLazy(path)) {
-    return {
-      exists: true,
-      entryType: "file"
-    };
-  }
-  try {
-    const stat = await fs.lstat(path);
-    const entryType = stat.isDirectory ? "directory" : stat.isSymbolicLink ? "symlink" : "file";
-    return {
-      exists: true,
-      entryType
-    };
-  } catch {
-    return { exists: false };
-  }
-}
-function mapAddEvent(entryType) {
-  return entryType === "directory" ? "addDir" : "add";
-}
-function normalizeFsPathForLogScope(fsPath) {
-  const normalized = posixPath.normalize(fsPath);
-  return normalized === "." ? "/" : normalized;
-}
-var ObservableInMemoryFs = class extends Ir {
-  listeners;
-  lazyPaths = /* @__PURE__ */ new Set();
-  suppressSyncEventCount = 0;
-  suppressConsoleLogCount = 0;
-  suppressChangeEmissionCount = 0;
-  consoleLogChanges;
-  isLoggableWorkspacePath;
-  constructor(options) {
-    super();
-    this.consoleLogChanges = options?.consoleLogChanges ?? false;
-    const normalizedWorkspaceRoot = normalizeFsPathForLogScope(options?.workspaceRoot ?? "/");
-    this.isLoggableWorkspacePath = (fsPath) => {
-      const normalizedPath = normalizeFsPathForLogScope(fsPath);
-      if (normalizedPath !== normalizedWorkspaceRoot && !normalizedPath.startsWith(`${normalizedWorkspaceRoot}/`)) {
-        return false;
-      }
-      const relativePath = posixPath.relative(normalizedWorkspaceRoot, normalizedPath);
-      if (!relativePath || relativePath === ".") {
-        return true;
-      }
-      return relativePath.split("/").every((segment) => segment.length > 0 && !segment.startsWith("."));
-    };
-  }
-  isPathLazy(filePath) {
-    return this.lazyPaths.has(normalizeFsPathForLogScope(filePath));
-  }
-  clearLazyPath(filePath) {
-    this.lazyPaths.delete(normalizeFsPathForLogScope(filePath));
-  }
-  clearLazyPathsUnder(rootPath) {
-    const normalizedRootPath = normalizeFsPathForLogScope(rootPath);
-    for (const filePath of Array.from(this.lazyPaths)) {
-      if (filePath === normalizedRootPath || filePath.startsWith(`${normalizedRootPath}/`)) {
-        this.lazyPaths.delete(filePath);
-      }
-    }
-  }
-  subscribe(listener) {
-    const listeners = this.listeners ??= /* @__PURE__ */ new Set();
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-      if (listeners.size === 0 && this.listeners === listeners) {
-        this.listeners = void 0;
-      }
-    };
-  }
-  shouldEmitChanges() {
-    if (this.suppressChangeEmissionCount > 0) {
-      return false;
-    }
-    return this.consoleLogChanges || (this.listeners?.size ?? 0) > 0;
-  }
-  async suppressObservability(operation) {
-    this.suppressChangeEmissionCount += 1;
-    this.suppressSyncEventCount += 1;
-    this.suppressConsoleLogCount += 1;
-    try {
-      return await operation();
-    } finally {
-      this.suppressConsoleLogCount -= 1;
-      this.suppressSyncEventCount -= 1;
-      this.suppressChangeEmissionCount -= 1;
-    }
-  }
-  queueChangeEmission(emission) {
-    void emission.catch((error) => {
-      console.error("[ObservableInMemoryFs] Failed to emit change event", error);
-    });
-  }
-  areConsoleLogsSuppressed() {
-    return this.suppressConsoleLogCount > 0;
-  }
-  async runWithSuppressedConsoleLogs(operation) {
-    this.suppressConsoleLogCount += 1;
-    try {
-      return await operation();
-    } finally {
-      this.suppressConsoleLogCount -= 1;
-    }
-  }
-  shouldConsoleLogChangeEvent(event) {
-    if (!this.isLoggableWorkspacePath(event.path)) {
-      return false;
-    }
-    if (event.previousPath && !this.isLoggableWorkspacePath(event.previousPath)) {
-      return false;
-    }
-    return true;
-  }
-  emit(event, options) {
-    const shouldConsoleLog = options?.shouldConsoleLog ?? this.shouldConsoleLogChangeEvent(event);
-    if (this.consoleLogChanges && shouldConsoleLog && !this.areConsoleLogsSuppressed()) {
-      console.log(`[ObservableInMemoryFs] ${event.event} ${event.entryType} ${event.path}${event.previousPath ? ` (from ${event.previousPath})` : ""}`);
-    }
-    if (!this.listeners) {
-      return;
-    }
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch (error) {
-        console.error("[ObservableInMemoryFs] Change listener failed", error);
-      }
-    }
-  }
-  areSyncEventsSuppressed() {
-    return this.suppressSyncEventCount > 0;
-  }
-  async runWithSuppressedSyncEvents(operation) {
-    this.suppressSyncEventCount += 1;
-    try {
-      return await operation();
-    } finally {
-      this.suppressSyncEventCount -= 1;
-    }
-  }
-  writeFileSync(path, content, options, metadata) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path);
-    super.writeFileSync(path, content, options, metadata);
-    this.clearLazyPath(path);
-    if (!previous) {
-      return;
-    }
-    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path, state)));
-  }
-  writeFileLazy(path, lazy, metadata) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path);
-    super.writeFileLazy(path, lazy, metadata);
-    this.lazyPaths.add(normalizeFsPathForLogScope(path));
-    if (!previous) {
-      return;
-    }
-    this.queueChangeEmission(previous.then((state) => this.emitWriteEvent(path, state)));
-  }
-  async emitWriteEvent(path, previous) {
-    const current = await readPathState(this, path);
-    if (!current.exists || !current.entryType) {
-      return;
-    }
-    if (!previous.exists) {
-      this.emit({
-        event: mapAddEvent(current.entryType),
-        path,
-        entryType: current.entryType
-      });
-      return;
-    }
-    this.emit({
-      event: "change",
-      path,
-      entryType: current.entryType
-    });
-  }
-  async emitMkdirEvent(path, previous) {
-    const current = await readPathState(this, path);
-    if (!current.exists || current.entryType !== "directory" || previous.exists) {
-      return;
-    }
-    this.emit({
-      event: "addDir",
-      path,
-      entryType: "directory"
-    });
-  }
-  emitRemovalEvent(path, previous, options) {
-    if (!previous.exists || !previous.entryType) {
-      return;
-    }
-    this.emit({
-      event: previous.entryType === "directory" ? "unlinkDir" : "unlink",
-      path,
-      entryType: previous.entryType
-    }, options);
-  }
-  mkdirSync(path, options) {
-    const previous = this.areSyncEventsSuppressed() || !this.shouldEmitChanges() ? null : readPathState(this, path);
-    super.mkdirSync(path, options);
-    if (!previous) {
-      return;
-    }
-    this.queueChangeEmission(previous.then((state) => this.emitMkdirEvent(path, state)));
-  }
-  async readFileBuffer(path) {
-    const content = await super.readFileBuffer(path);
-    this.clearLazyPath(path);
-    return content;
-  }
-  async stat(path) {
-    const stat = await super.stat(path);
-    this.clearLazyPath(path);
-    return stat;
-  }
-  async lstat(path) {
-    const stat = await super.lstat(path);
-    this.clearLazyPath(path);
-    return stat;
-  }
-  async writeFile(path, content, options) {
-    if (!this.shouldEmitChanges()) {
-      await super.writeFile(path, content, options);
-      return;
-    }
-    const previous = await readPathState(this, path);
-    await this.runWithSuppressedSyncEvents(() => super.writeFile(path, content, options));
-    await this.emitWriteEvent(path, previous);
-  }
-  async appendFile(path, content, options) {
-    if (!this.shouldEmitChanges()) {
-      await super.appendFile(path, content, options);
-      return;
-    }
-    const previous = await readPathState(this, path);
-    await this.runWithSuppressedSyncEvents(() => super.appendFile(path, content, options));
-    await this.emitWriteEvent(path, previous);
-  }
-  async mkdir(path, options) {
-    if (!this.shouldEmitChanges()) {
-      await super.mkdir(path, options);
-      return;
-    }
-    const previous = await readPathState(this, path);
-    await this.runWithSuppressedSyncEvents(() => super.mkdir(path, options));
-    await this.emitMkdirEvent(path, previous);
-  }
-  async rm(path, options) {
-    if (!this.shouldEmitChanges()) {
-      await super.rm(path, options);
-      this.clearLazyPathsUnder(path);
-      return;
-    }
-    const previous = await readPathState(this, path);
-    await super.rm(path, options);
-    this.clearLazyPathsUnder(path);
-    this.emitRemovalEvent(path, previous);
-  }
-  async cp(src, dest, options) {
-    if (!this.shouldEmitChanges()) {
-      await super.cp(src, dest, options);
-      this.clearLazyPathsUnder(dest);
-      return;
-    }
-    const previous = await readPathState(this, dest);
-    await super.cp(src, dest, options);
-    this.clearLazyPathsUnder(dest);
-    const current = await readPathState(this, dest);
-    if (!current.exists || !current.entryType) {
-      return;
-    }
-    this.emit({
-      event: previous.exists ? "change" : mapAddEvent(current.entryType),
-      path: dest,
-      entryType: current.entryType
-    });
-  }
-  async mv(src, dest) {
-    if (!this.shouldEmitChanges()) {
-      await super.mv(src, dest);
-      const normalizedSourcePath2 = normalizeFsPathForLogScope(src);
-      const normalizedDestinationPath2 = normalizeFsPathForLogScope(dest);
-      this.clearLazyPathsUnder(normalizedDestinationPath2);
-      for (const filePath of Array.from(this.lazyPaths)) {
-        if (filePath === normalizedSourcePath2 || filePath.startsWith(`${normalizedSourcePath2}/`)) {
-          this.lazyPaths.delete(filePath);
-          this.lazyPaths.add(`${normalizedDestinationPath2}${filePath.slice(normalizedSourcePath2.length)}`);
-        }
-      }
-      return;
-    }
-    const sourceState = await readPathState(this, src);
-    const destinationState = await readPathState(this, dest);
-    const shouldConsoleLogMove = this.shouldConsoleLogChangeEvent({
-      event: destinationState.exists ? "change" : mapAddEvent(sourceState.entryType ?? "file"),
-      path: dest,
-      previousPath: src,
-      entryType: sourceState.entryType ?? "file"
-    });
-    if (shouldConsoleLogMove) {
-      await super.mv(src, dest);
-    } else {
-      await this.runWithSuppressedConsoleLogs(() => super.mv(src, dest));
-    }
-    const normalizedSourcePath = normalizeFsPathForLogScope(src);
-    const normalizedDestinationPath = normalizeFsPathForLogScope(dest);
-    this.clearLazyPathsUnder(normalizedDestinationPath);
-    for (const filePath of Array.from(this.lazyPaths)) {
-      if (filePath === normalizedSourcePath || filePath.startsWith(`${normalizedSourcePath}/`)) {
-        this.lazyPaths.delete(filePath);
-        this.lazyPaths.add(`${normalizedDestinationPath}${filePath.slice(normalizedSourcePath.length)}`);
-      }
-    }
-    this.emitRemovalEvent(src, sourceState, {
-      shouldConsoleLog: shouldConsoleLogMove
-    });
-    const currentDestinationState = await readPathState(this, dest);
-    if (!currentDestinationState.exists || !currentDestinationState.entryType) {
-      return;
-    }
-    this.emit({
-      event: destinationState.exists ? "change" : mapAddEvent(currentDestinationState.entryType),
-      path: dest,
-      previousPath: src,
-      entryType: currentDestinationState.entryType
-    }, {
-      shouldConsoleLog: shouldConsoleLogMove
-    });
-  }
-  async chmod(path, mode) {
-    if (!this.shouldEmitChanges()) {
-      await super.chmod(path, mode);
-      return;
-    }
-    await super.chmod(path, mode);
-    const current = await readPathState(this, path);
-    if (!current.exists || !current.entryType) {
-      return;
-    }
-    this.emit({
-      event: "change",
-      path,
-      entryType: current.entryType
-    });
-  }
-  async symlink(target, linkPath) {
-    if (!this.shouldEmitChanges()) {
-      await super.symlink(target, linkPath);
-      return;
-    }
-    const previous = await readPathState(this, linkPath);
-    await super.symlink(target, linkPath);
-    await this.emitWriteEvent(linkPath, previous);
-  }
-  async link(existingPath, newPath) {
-    if (!this.shouldEmitChanges()) {
-      await super.link(existingPath, newPath);
-      return;
-    }
-    const previous = await readPathState(this, newPath);
-    await super.link(existingPath, newPath);
-    await this.emitWriteEvent(newPath, previous);
-  }
-  async utimes(path, atime, mtime) {
-    if (!this.shouldEmitChanges()) {
-      await super.utimes(path, atime, mtime);
-      return;
-    }
-    await super.utimes(path, atime, mtime);
-    const current = await readPathState(this, path);
-    if (!current.exists || !current.entryType) {
-      return;
-    }
-    this.emit({
-      event: "change",
-      path,
-      entryType: current.entryType
-    });
-  }
-};
-
-// 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 ext = args[++i];
-      if (ext) opts.extensions.push(ext.startsWith(".") ? ext.slice(1) : ext);
-      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 n = Number.parseInt(args[++i] ?? "", 10);
-      if (!Number.isNaN(n)) opts.maxDepth = n;
-      i++;
-      continue;
-    }
-    if (arg === "--max-results") {
-      const n = Number.parseInt(args[++i] ?? "", 10);
-      if (!Number.isNaN(n)) opts.maxResults = n;
-      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 ch = pattern[i];
-    if (ch === "*") {
-      if (pattern[i + 1] === "*") {
-        regex += ".*";
-        i += 2;
-        if (pattern[i] === "/") i++;
-        continue;
-      }
-      regex += "[^/]*";
-    } else if (ch === "?") {
-      regex += "[^/]";
-    } else if (ch === "[") {
-      const close = pattern.indexOf("]", i + 1);
-      if (close !== -1) {
-        regex += pattern.slice(i, close + 1);
-        i = close + 1;
-        continue;
-      }
-      regex += "\\[";
-    } else if (ch === "{") {
-      const close = pattern.indexOf("}", i + 1);
-      if (close !== -1) {
-        const alternatives = pattern.slice(i + 1, close).split(",").map((a) => a.trim());
-        regex += `(?:${alternatives.map(escapeRegex).join("|")})`;
-        i = close + 1;
-        continue;
-      }
-      regex += "\\{";
-    } else if (".+^$|()\\".includes(ch)) {
-      regex += `\\${ch}`;
-    } else {
-      regex += ch;
-    }
-    i++;
-  }
-  return new RegExp(`^${regex}$`, "i");
-}
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function loadIgnoreFile(fs, filePath) {
-  let content;
-  try {
-    content = await fs.readFile(filePath);
-  } catch {
-    return [];
-  }
-  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 basename = relPath.split("/").pop() ?? relPath;
-      return re.test(basename) || re.test(relPath);
-    });
-  }
-  return matchers;
-}
-function resolvePath(base, rel) {
-  const p = rel.startsWith("/") ? rel : `${base}/${rel}`;
-  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 = [];
-  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 st = await fs.stat(fullPath);
-        isDir = st.isDirectory;
-        isFile = st.isFile;
-      } catch {
-        continue;
-      }
-      const relPath = fullPath.slice(rootPath.length + 1) || entry;
-      if (!opts.noIgnore && ignoreMatchers.some((m) => m(relPath, isDir))) continue;
-      const basename = entry;
-      if (excludeMatchers.some((re) => re.test(basename) || 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 ext = dotIdx >= 0 ? entry.slice(dotIdx + 1) : "";
-        if (!opts.extensions.some((e) => e.toLowerCase() === ext.toLowerCase())) {
-          if (isDir) await walk(fullPath, rootPath, depth + 1);
-          continue;
-        }
-      }
-      if (matchRegex) {
-        const target = opts.fullPath ? relPath : basename;
-        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 root of searchRoots) {
-    if (limitReached) break;
-    try {
-      const st = await fs.stat(root);
-      if (!st.isDirectory) {
-        return { stdout: "", stderr: `error: '${root}' is not a directory
-`, exitCode: 1 };
-      }
-    } catch {
-      return { stdout: "", stderr: `error: '${root}': No such file or directory
-`, exitCode: 1 };
-    }
-    if (!opts.noIgnore) {
-      const rootGitignore = `${root}/.gitignore`;
-      const loaded = await loadIgnoreFile(fs, rootGitignore);
-      ignoreMatchers.push(...loaded);
-    }
-    await walk(root, root, 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",
-  LC_ALL: "C.UTF-8",
-  PYTHONIOENCODING: "utf-8",
-  PYTHONUTF8: "1",
-  PI_OFFLINE: "1"
-};
-var DEFAULT_BASH_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
-var DEFAULT_BASH_OUTPUT_LIMIT = 1e4;
-function normalizeBashPath(input) {
-  const posixPath2 = input.trim().replace(/\\/g, "/") || "/";
-  const segments = [];
-  const isAbsolute = posixPath2.startsWith("/");
-  for (const segment of posixPath2.split("/")) {
-    if (segment === "..") {
-      segments.pop();
-    } else if (segment !== "." && segment !== "") {
-      segments.push(segment);
-    }
-  }
-  return (isAbsolute ? "/" : "") + segments.join("/") || "/";
-}
-function truncateBashOutput(output, limitBytes = DEFAULT_BASH_OUTPUT_LIMIT) {
-  if (!output || output.length <= limitBytes) {
-    return output;
-  }
-  const headBytes = Math.ceil(limitBytes * 0.3);
-  const tailBytes = limitBytes - headBytes;
-  const omittedBytes = output.length - headBytes - tailBytes;
-  return `${output.slice(0, headBytes)}
-
-... [${omittedBytes} bytes truncated] ...
-
-${output.slice(-tailBytes)}`;
-}
-function createBrowserBashSession(options = {}) {
-  const rootPath = normalizeBashPath(options.rootPath ?? "/workspace");
-  const env = options.env ?? { ...DEFAULT_BASH_SHELL_ENV };
-  const fs = new ObservableInMemoryFs(options.fsOptions);
-  fs.mkdirSync(rootPath, { recursive: true });
-  const piBinDir = "/home/user/.pi/agent/bin";
-  fs.mkdirSync(piBinDir, { recursive: true });
-  fs.writeFileSync(`${piBinDir}/rg`, '#!/bin/sh\nrg "$@"\n');
-  fs.writeFileSync(`${piBinDir}/fd`, '#!/bin/sh\nfd "$@"\n');
-  let almostNodeSession = null;
-  let almostNodeSessionPromise = null;
-  let pyodideSession = null;
-  let pyodideSessionPromise = null;
-  async function getAlmostNodeSession() {
-    if (almostNodeSession) return almostNodeSession;
-    if (almostNodeSessionPromise) return almostNodeSessionPromise;
-    almostNodeSessionPromise = import(["./almostnode", "-session-2FPETBKJ.js"].join("")).then((mod) => {
-      almostNodeSession = new mod.AlmostNodeSession(fs);
-      almostNodeSession.setBinCommandRegistrar((name, handler) => {
-        bash.registerCommand(Dx(name, handler));
-      });
-      if (currentStdoutWriter) almostNodeSession.setStdoutWriter(currentStdoutWriter);
-      return almostNodeSession;
-    });
-    return almostNodeSessionPromise;
-  }
-  async function getPyodideSession() {
-    if (pyodideSession) return pyodideSession;
-    if (pyodideSessionPromise) return pyodideSessionPromise;
-    pyodideSessionPromise = import("./pyodide-session-OEKAVNSL.js").then((mod) => {
-      pyodideSession = new mod.PyodideSession(fs);
-      if (currentStdoutWriter) pyodideSession.setStdoutWriter(currentStdoutWriter);
-      return pyodideSession;
-    });
-    return pyodideSessionPromise;
-  }
-  let currentStdoutWriter;
-  const runtimeCommands = [];
-  if (options.node) {
-    runtimeCommands.push(
-      Dx("node", async (args, ctx) => (await getAlmostNodeSession()).executeNode(args, ctx)),
-      Dx("npm", async (args, ctx) => (await getAlmostNodeSession()).executeNpm(args, ctx))
-    );
-  }
-  if (options.python) {
-    runtimeCommands.push(
-      Dx("python", async (args, ctx) => (await getPyodideSession()).executePython(args, ctx)),
-      Dx("python3", async (args, ctx) => (await getPyodideSession()).executePython(args, ctx)),
-      Dx("pip", async (args, ctx) => (await getPyodideSession()).executePip(args, ctx))
-    );
-  }
-  const bash = new Ju({
-    cwd: rootPath,
-    env: { ...env },
-    fs,
-    customCommands: [
-      ...runtimeCommands,
-      Dx("fd", async (args, ctx) => executeFd(args, ctx)),
-      ...options.customCommands ?? []
-    ]
-  });
-  return {
-    fs,
-    bash,
-    rootPath,
-    cwd: rootPath,
-    setStdoutWriter: (writer) => {
-      currentStdoutWriter = writer;
-      almostNodeSession?.setStdoutWriter(writer);
-      pyodideSession?.setStdoutWriter(writer);
-    },
-    writeStdin: (data) => almostNodeSession?.writeStdin(data),
-    setTerminalSize: (columns, rows) => almostNodeSession?.setTerminalSize(columns, rows),
-    dispose: () => {
-      almostNodeSession?.dispose();
-      pyodideSession?.dispose();
-    }
-  };
-}
-async function executeBrowserBash(session, command, options = {}) {
-  const trimmedCommand = command.trim();
-  if (!trimmedCommand) {
-    return { success: false, error: "Command is required", stderr: "Command is required", exit_code: 1, command: trimmedCommand, backend: "just-bash" };
-  }
-  const startedAt = Date.now();
-  const outputLimit = options.outputLimit ?? DEFAULT_BASH_OUTPUT_LIMIT;
-  const timeoutMs = options.commandTimeoutMs ?? DEFAULT_BASH_COMMAND_TIMEOUT_MS;
-  const timeoutController = new AbortController();
-  const combinedController = new AbortController();
-  const abort = (reason) => {
-    combinedController.abort(reason instanceof Error ? reason : new Error(String(reason ?? "Command aborted")));
-  };
-  if (options.signal) {
-    if (options.signal.aborted) {
-      abort(options.signal.reason);
-    } else {
-      options.signal.addEventListener("abort", () => abort(options.signal.reason), { once: true });
-    }
-  }
-  timeoutController.signal.addEventListener("abort", () => abort(timeoutController.signal.reason), { once: true });
-  const timeoutId = globalThis.setTimeout(() => {
-    timeoutController.abort(new Error(`Command timed out after ${timeoutMs}ms`));
-  }, timeoutMs);
-  try {
-    const result = await session.bash.exec(trimmedCommand, {
-      cwd: session.cwd,
-      env: {
-        ...DEFAULT_BASH_SHELL_ENV,
-        PWD: session.cwd
-      },
-      signal: combinedController.signal
-    });
-    const nextCwd = result.env?.PWD?.trim();
-    if (nextCwd) {
-      session.cwd = normalizeBashPath(nextCwd);
-    }
-    const stdout = options.truncateOutput === false ? result.stdout : truncateBashOutput(result.stdout, outputLimit);
-    const stderr = options.truncateOutput === false ? result.stderr : truncateBashOutput(result.stderr, outputLimit);
-    const error = result.exitCode === 0 ? void 0 : stderr || void 0;
-    return {
-      success: result.exitCode === 0,
-      command: trimmedCommand,
-      stdout,
-      stderr,
-      output: stdout,
-      exit_code: result.exitCode,
-      duration_ms: Date.now() - startedAt,
-      backend: "just-bash",
-      ...error ? { error } : {}
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, command: trimmedCommand, error: message, stderr: message, exit_code: 1, duration_ms: Date.now() - startedAt, backend: "just-bash" };
-  } finally {
-    globalThis.clearTimeout(timeoutId);
-  }
-}
-
 // src/index.ts
-var AGENT_WEB_OS_VERSION = "0.3.4";
+var AGENT_WEB_OS_VERSION = "0.4.0-beta.0";
 console.log(`[agent-web-os] v${AGENT_WEB_OS_VERSION}`);
 export {
   AGENT_WEB_OS_VERSION,
@@ -963,8 +24,6 @@ export {
   createBrowserBashSession,
   Dx as defineCommand,
   executeBrowserBash,
-  executeFd,
-  getServerBridge,
-  resetServerBridge
+  executeFd
 };
 //# sourceMappingURL=index.js.map