agent-web-os 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -42349,19 +42349,6 @@ function assertObservableInMemoryFs(value) {
   }
   return value;
 }
-function formatChangeEventForLog(event) {
-  const previousPathSuffix = event.previousPath ? ` (from ${event.previousPath})` : "";
-  return `[ObservableInMemoryFs] ${event.event} ${event.entryType} ${event.path}${previousPathSuffix}`;
-}
-function normalizeEntryType(stat) {
-  if (stat.isDirectory) {
-    return "directory";
-  }
-  if (stat.isSymbolicLink) {
-    return "symlink";
-  }
-  return "file";
-}
 async function readPathState(fs, path2) {
   const exists = await fs.exists(path2);
   if (!exists) {
@@ -42374,35 +42361,19 @@ async function readPathState(fs, path2) {
     };
   }
   const stat = await fs.lstat(path2);
+  const entryType = stat.isDirectory ? "directory" : stat.isSymbolicLink ? "symlink" : "file";
   return {
     exists: true,
-    entryType: normalizeEntryType(stat)
+    entryType
   };
 }
 function mapAddEvent(entryType) {
   return entryType === "directory" ? "addDir" : "add";
 }
-function mapUnlinkEvent(entryType) {
-  return entryType === "directory" ? "unlinkDir" : "unlink";
-}
 function normalizeFsPathForLogScope(fsPath) {
   const normalized = posixPath.normalize(fsPath);
   return normalized === "." ? "/" : normalized;
 }
-function createWorkspacePathFilter(workspaceRoot) {
-  const normalizedWorkspaceRoot = normalizeFsPathForLogScope(workspaceRoot);
-  return (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("."));
-  };
-}
 var ObservableInMemoryFs = class extends Ir {
   listeners;
   lazyPaths = /* @__PURE__ */ new Set();
@@ -42414,7 +42385,18 @@ var ObservableInMemoryFs = class extends Ir {
   constructor(options2) {
     super();
     this.consoleLogChanges = options2?.consoleLogChanges ?? false;
-    this.isLoggableWorkspacePath = createWorkspacePathFilter(options2?.workspaceRoot ?? "/");
+    const normalizedWorkspaceRoot = normalizeFsPathForLogScope(options2?.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));
@@ -42486,7 +42468,7 @@ var ObservableInMemoryFs = class extends Ir {
   emit(event, options2) {
     const shouldConsoleLog = options2?.shouldConsoleLog ?? this.shouldConsoleLogChangeEvent(event);
     if (this.consoleLogChanges && shouldConsoleLog && !this.areConsoleLogsSuppressed()) {
-      console.log(formatChangeEventForLog(event));
+      console.log(`[ObservableInMemoryFs] ${event.event} ${event.entryType} ${event.path}${event.previousPath ? ` (from ${event.previousPath})` : ""}`);
     }
     if (!this.listeners) {
       return;
@@ -42563,7 +42545,7 @@ var ObservableInMemoryFs = class extends Ir {
       return;
     }
     this.emit({
-      event: mapUnlinkEvent(previous.entryType),
+      event: previous.entryType === "directory" ? "unlinkDir" : "unlink",
       path: path2,
       entryType: previous.entryType
     }, options2);
@@ -60304,6 +60286,7 @@ var ALMOSTNODE_INTERNAL_ROOT = "/.almostnode";
 var ALMOSTNODE_NODE_VERSION = "v20.0.0";
 var ALMOSTNODE_NPM_VERSION = "9.6.4";
 var NODE_EXEC_PATH = "/usr/local/bin/node";
+var GLOBAL_NODE_MODULES_ROOT = "/usr/local/lib/node_modules";
 var DEFAULT_PATH = "/usr/local/bin:/usr/bin:/bin:/node_modules/.bin";
 var NPM_USAGE = [
   "Usage: npm <command>",
@@ -60588,6 +60571,66 @@ var AlmostNodeSession = class {
   constructor(fs) {
     this.fs = fs;
     this._vfs.mkdirSync(ALMOSTNODE_INTERNAL_ROOT, { recursive: true });
+    this._vfs.mkdirSync("/node_modules/constants", { recursive: true });
+    this._vfs.writeFileSync("/node_modules/constants/package.json", JSON.stringify({
+      name: "constants",
+      version: "0.0.1",
+      main: "index.js"
+    }));
+    this._vfs.writeFileSync("/node_modules/constants/index.js", [
+      "// Node.js `constants` shim (os.constants + fs.constants)",
+      "var os = require('os');",
+      "var constants = {};",
+      "if (os.constants) {",
+      "  if (os.constants.signals) Object.assign(constants, os.constants.signals);",
+      "  if (os.constants.errno) Object.assign(constants, os.constants.errno);",
+      "  if (os.constants.priority) Object.assign(constants, os.constants.priority);",
+      "}",
+      "// Common fs.constants used by npm packages",
+      "constants.O_RDONLY = 0;",
+      "constants.O_WRONLY = 1;",
+      "constants.O_RDWR = 2;",
+      "constants.O_CREAT = 64;",
+      "constants.O_EXCL = 128;",
+      "constants.O_TRUNC = 512;",
+      "constants.O_APPEND = 1024;",
+      "constants.O_DIRECTORY = 65536;",
+      "constants.O_NOFOLLOW = 131072;",
+      "constants.O_SYNC = 1052672;",
+      "constants.O_SYMLINK = 2097152;",
+      "constants.O_NONBLOCK = 2048;",
+      "constants.S_IFMT = 61440;",
+      "constants.S_IFREG = 32768;",
+      "constants.S_IFDIR = 16384;",
+      "constants.S_IFCHR = 8192;",
+      "constants.S_IFBLK = 24576;",
+      "constants.S_IFIFO = 4096;",
+      "constants.S_IFLNK = 40960;",
+      "constants.S_IFSOCK = 49152;",
+      "constants.S_IRWXU = 448;",
+      "constants.S_IRUSR = 256;",
+      "constants.S_IWUSR = 128;",
+      "constants.S_IXUSR = 64;",
+      "constants.S_IRWXG = 56;",
+      "constants.S_IRGRP = 32;",
+      "constants.S_IWGRP = 16;",
+      "constants.S_IXGRP = 8;",
+      "constants.S_IRWXO = 7;",
+      "constants.S_IROTH = 4;",
+      "constants.S_IWOTH = 2;",
+      "constants.S_IXOTH = 1;",
+      "constants.F_OK = 0;",
+      "constants.R_OK = 4;",
+      "constants.W_OK = 2;",
+      "constants.X_OK = 1;",
+      "constants.COPYFILE_EXCL = 1;",
+      "constants.COPYFILE_FICLONE = 2;",
+      "constants.COPYFILE_FICLONE_FORCE = 4;",
+      "constants.UV_FS_COPYFILE_EXCL = 1;",
+      "constants.UV_FS_COPYFILE_FICLONE = 2;",
+      "constants.UV_FS_COPYFILE_FICLONE_FORCE = 4;",
+      "module.exports = constants;"
+    ].join("\n"));
     this.disposeObservableSubscription = this.fs.subscribe((event) => {
       void this.trackOperation((async () => {
         if (!this.initialized || this.suppressObservableMirrorCount > 0) {
@@ -60660,14 +60703,6 @@ var AlmostNodeSession = class {
    * package directory directly.
    */
   resolveBarePkgEntryCache = /* @__PURE__ */ new Map();
-  /**
-   * Packages whose imports are handled by the browser import map.
-   * These are NOT rewritten to /node_modules/... paths.
-   * Now empty: react/react-dom are served from node_modules via our
-   * CJS→ESM shim, which supports the actual installed version rather
-   * than the outdated esm.sh CDN pinned in almostnode's import map.
-   */
-  importMapPackages = /* @__PURE__ */ new Set();
   parseCachedPackageJson(packageJsonPath, raw) {
     const cached = this.parsedPackageJsonCache.get(packageJsonPath);
     if (cached && cached.raw === raw) {
@@ -60716,7 +60751,6 @@ var AlmostNodeSession = class {
         subPath = specifier.slice(slashIdx + 1);
       }
     }
-    if (this.importMapPackages.has(pkgName)) return null;
     const nodeModulesPath = `${root2}/node_modules/${pkgName}`;
     const pkgJsonPath = `${nodeModulesPath}/package.json`;
     let pkgJson = null;
@@ -60936,6 +60970,19 @@ var AlmostNodeSession = class {
     this.vitePreviewUrl = null;
     this.vitePreviewListener?.(null);
   }
+  resolveBinFromPackageJson(binName, packageName, pkgJson, pkgDir) {
+    if (typeof pkgJson.bin === "string") {
+      const inferredBinName = typeof pkgJson.name === "string" ? pkgJson.name.split("/").pop() ?? pkgJson.name : packageName.split("/").pop() ?? packageName;
+      if (binName === inferredBinName) {
+        return normalizePath(posixPath.join(pkgDir, pkgJson.bin));
+      }
+    }
+    if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && binName in pkgJson.bin) {
+      const namedBins = pkgJson.bin;
+      return normalizePath(posixPath.join(pkgDir, namedBins[binName]));
+    }
+    return null;
+  }
   async resolveNpmBinPath(binName, cwd) {
     const candidatePackageNames = [binName];
     const packageJsonResult = await this.readPackageJson(cwd);
@@ -60958,21 +61005,94 @@ var AlmostNodeSession = class {
           continue;
         }
         const pkgDir = normalizePath(posixPath.join(cwd, "node_modules", packageName));
-        if (typeof pkgJson.bin === "string") {
-          const inferredBinName = typeof pkgJson.name === "string" ? pkgJson.name.split("/").pop() ?? pkgJson.name : packageName.split("/").pop() ?? packageName;
-          if (binName === inferredBinName) {
-            return normalizePath(posixPath.join(pkgDir, pkgJson.bin));
+        const result = this.resolveBinFromPackageJson(binName, packageName, pkgJson, pkgDir);
+        if (result) return result;
+      } catch {
+      }
+    }
+    const globalResult = await this.resolveGlobalBinPath(binName);
+    if (globalResult) return globalResult;
+    return null;
+  }
+  async resolveGlobalBinPath(binName) {
+    try {
+      const globalModulesDir = GLOBAL_NODE_MODULES_ROOT;
+      if (!this._vfs.existsSync(globalModulesDir)) return null;
+      const globalPackages = this._vfs.readdirSync(globalModulesDir);
+      for (const entry of globalPackages) {
+        const packageName = entry;
+        const pkgJsonPath = normalizePath(posixPath.join(globalModulesDir, packageName, "package.json"));
+        if (!this._vfs.existsSync(pkgJsonPath)) {
+          if (entry.startsWith("@")) {
+            try {
+              const scopeDir = normalizePath(posixPath.join(globalModulesDir, entry));
+              const scopedPackages = this._vfs.readdirSync(scopeDir);
+              for (const scopedPkg of scopedPackages) {
+                const scopedName = `${entry}/${scopedPkg}`;
+                const scopedPkgJsonPath = normalizePath(posixPath.join(globalModulesDir, scopedName, "package.json"));
+                if (!this._vfs.existsSync(scopedPkgJsonPath)) continue;
+                const raw = this._vfs.readFileSync(scopedPkgJsonPath, "utf8");
+                const pkgJson = this.parseCachedPackageJson(scopedPkgJsonPath, raw);
+                if (!pkgJson) continue;
+                const pkgDir = normalizePath(posixPath.join(globalModulesDir, scopedName));
+                const result = this.resolveBinFromPackageJson(binName, scopedName, pkgJson, pkgDir);
+                if (result) return result;
+              }
+            } catch {
+            }
           }
+          continue;
         }
-        if (typeof pkgJson.bin === "object" && pkgJson.bin !== null && binName in pkgJson.bin) {
-          const namedBins = pkgJson.bin;
-          return normalizePath(posixPath.join(pkgDir, namedBins[binName]));
+        try {
+          const raw = this._vfs.readFileSync(pkgJsonPath, "utf8");
+          const pkgJson = this.parseCachedPackageJson(pkgJsonPath, raw);
+          if (!pkgJson) continue;
+          const pkgDir = normalizePath(posixPath.join(globalModulesDir, packageName));
+          const result = this.resolveBinFromPackageJson(binName, packageName, pkgJson, pkgDir);
+          if (result) return result;
+        } catch {
         }
-      } catch {
       }
+    } catch {
     }
     return null;
   }
+  async registerGlobalBinCommands(packageName) {
+    if (!this.binCommandRegistrar) return;
+    const pkgJsonPath = normalizePath(posixPath.join(GLOBAL_NODE_MODULES_ROOT, packageName, "package.json"));
+    if (!this._vfs.existsSync(pkgJsonPath)) return;
+    try {
+      const raw = this._vfs.readFileSync(pkgJsonPath, "utf8");
+      const pkgJson = this.parseCachedPackageJson(pkgJsonPath, raw);
+      if (!pkgJson) return;
+      let binNames;
+      if (typeof pkgJson.bin === "string") {
+        const name = typeof pkgJson.name === "string" ? pkgJson.name.split("/").pop() ?? "" : "";
+        binNames = name ? [name] : [];
+      } else if (typeof pkgJson.bin === "object" && pkgJson.bin !== null) {
+        binNames = Object.keys(pkgJson.bin);
+      } else {
+        binNames = [];
+      }
+      for (const binName of binNames) {
+        if (this.registeredBinCommands.has(binName)) continue;
+        this.registeredBinCommands.add(binName);
+        this.binCommandRegistrar(binName, async (args, ctx) => {
+          const resolvedPath2 = await this.resolveGlobalBinPath(binName) ?? await this.resolveNpmBinPath(binName, normalizePath(ctx.cwd));
+          if (!resolvedPath2) {
+            return {
+              stdout: "",
+              stderr: `bash: ${binName}: command not found
+`,
+              exitCode: 127
+            };
+          }
+          return this.executeNode([resolvedPath2, ...args], ctx);
+        });
+      }
+    } catch {
+    }
+  }
   async resolveAndRegisterBinCommands(command, cwd) {
     if (!this.binCommandRegistrar) {
       return;
@@ -61341,6 +61461,7 @@ var AlmostNodeSession = class {
       PATH: Array.from(/* @__PURE__ */ new Set([
         normalizePath(posixPath.join(cwd, "node_modules/.bin")),
         "/node_modules/.bin",
+        `${GLOBAL_NODE_MODULES_ROOT}/.bin`,
         ...(baseEnv.PATH?.trim() || DEFAULT_PATH).split(":").filter(Boolean)
       ])).join(":")
     };
@@ -61415,26 +61536,30 @@ var AlmostNodeSession = class {
       case "install":
       case "i":
       case "add": {
+        const isGlobal = args.includes("-g") || args.includes("--global");
         const packageSpecs = args.slice(1).filter((arg) => !arg.startsWith("-"));
         let stdout = "";
         try {
-          const packageJsonResult = await this.readPackageJson(cwd);
-          if ("error" in packageJsonResult) {
-            result = packageJsonResult.error;
-            break;
-          }
-          await ensureEsbuildWasm();
-          const packageManager = new PackageManager(this.vfs, { cwd });
-          if (packageSpecs.length === 0) {
-            const installResult = await packageManager.installFromPackageJson({
-              onProgress: (message) => {
-                stdout += `${message}
-`;
-              }
-            });
-            stdout += `added ${installResult.added.length} packages
-`;
-          } else {
+          if (isGlobal) {
+            if (packageSpecs.length === 0) {
+              result = { stdout: "", stderr: "npm ERR! npm install -g requires a package name\n", exitCode: 1 };
+              break;
+            }
+            await ensureEsbuildWasm();
+            this._vfs.mkdirSync(GLOBAL_NODE_MODULES_ROOT, { recursive: true });
+            await ensureObservableDirectory(this.fs, GLOBAL_NODE_MODULES_ROOT);
+            const globalPkgJsonPath = normalizePath(posixPath.join(GLOBAL_NODE_MODULES_ROOT, "..", "package.json"));
+            if (!this._vfs.existsSync(globalPkgJsonPath)) {
+              const minimalPkg = JSON.stringify({ name: "global", version: "0.0.0", private: true }, null, 2);
+              this._vfs.mkdirSync(posixPath.dirname(globalPkgJsonPath), { recursive: true });
+              this._vfs.writeFileSync(globalPkgJsonPath, minimalPkg);
+              await this.withSuppressedObservableMirroring(async () => {
+                await ensureObservableDirectory(this.fs, posixPath.dirname(globalPkgJsonPath));
+                await this.fs.writeFile(globalPkgJsonPath, minimalPkg);
+              });
+            }
+            const globalCwd = normalizePath(posixPath.join(GLOBAL_NODE_MODULES_ROOT, ".."));
+            const packageManager = new PackageManager(this.vfs, { cwd: globalCwd });
             for (const packageSpec of packageSpecs) {
               const installResult = await packageManager.install(packageSpec, {
                 save: true,
@@ -61445,9 +61570,48 @@ var AlmostNodeSession = class {
               });
               stdout += `added ${installResult.added.length} packages
 `;
+              const installedPkgName = packageSpec.replace(/@[^/]*$/, "") || packageSpec;
+              await this.registerGlobalBinCommands(installedPkgName);
+              for (const added of installResult.added) {
+                const addedName = typeof added === "string" ? String(added).replace(/@[^/]*$/, "") : added?.name;
+                if (addedName && addedName !== installedPkgName) {
+                  await this.registerGlobalBinCommands(addedName);
+                }
+              }
+            }
+            result = { stdout, stderr: "", exitCode: 0 };
+          } else {
+            const packageJsonResult = await this.readPackageJson(cwd);
+            if ("error" in packageJsonResult) {
+              result = packageJsonResult.error;
+              break;
+            }
+            await ensureEsbuildWasm();
+            const packageManager = new PackageManager(this.vfs, { cwd });
+            if (packageSpecs.length === 0) {
+              const installResult = await packageManager.installFromPackageJson({
+                onProgress: (message) => {
+                  stdout += `${message}
+`;
+                }
+              });
+              stdout += `added ${installResult.added.length} packages
+`;
+            } else {
+              for (const packageSpec of packageSpecs) {
+                const installResult = await packageManager.install(packageSpec, {
+                  save: true,
+                  onProgress: (message) => {
+                    stdout += `${message}
+`;
+                  }
+                });
+                stdout += `added ${installResult.added.length} packages
+`;
+              }
             }
+            result = { stdout, stderr: "", exitCode: 0 };
           }
-          result = { stdout, stderr: "", exitCode: 0 };
         } catch (error) {
           result = {
             stdout,