agent-web-os 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -60304,6 +60304,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>",
@@ -60936,6 +60937,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 +60972,96 @@ 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;
   }
+  extractBinNames(pkgJson) {
+    if (typeof pkgJson.bin === "string") {
+      const name = typeof pkgJson.name === "string" ? pkgJson.name.split("/").pop() ?? "" : "";
+      return name ? [name] : [];
+    }
+    if (typeof pkgJson.bin === "object" && pkgJson.bin !== null) {
+      return Object.keys(pkgJson.bin);
+    }
+    return [];
+  }
+  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;
+      const binNames = this.extractBinNames(pkgJson);
+      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 +61430,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 +61505,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 +61539,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,