@ai-ecoverse/slicc-kernel 1.146.6 → 1.147.0

package/README.md

@@ -239,6 +239,8 @@ A command's name is any single path component without whitespace or control char
 
 **Variants by environment** ([homescoop#357](https://github.com/ai-ecoverse/homescoop/issues/357)): one package can carry more than one build of a wasm command and choose between them by the environment. `"variants": [{ "env": { "PYTHON_FORK": "true" }, "wasm": "bin/python-fork.wasm" }]` on a command entry (Emscripten or WASI) is matched in order against the environment the new process gets, at spawn and at exec. Every key must equal its value exactly, and the first match runs its `wasm`; no match runs the command's own `wasm`. This holds however the kernel reaches the entry: by name, by its path (`/usr/bin/python3`, as `sys.executable` gives it to `subprocess` and `multiprocessing`), or through a symlink to that path (a venv's `bin/python`). So `PYTHON_FORK=true python3`, `PYTHON_FORK=true exec /usr/bin/python3` and a child that inherits `PYTHON_FORK=true` all get the variant, and `PYTHON_FORK=1` doesn't. Commands of one package that share a build (`python`, `python3`, `pip`, `pip3`) each carry the same `variants`. A variant replaces only the module: the `abi`, the glue, `env`, `argv0`, `argv0Path` and the `/usr/bin` entry stay the command's. For an Emscripten command that means a variant swaps only the `.wasm` and keeps the command's JS glue, so it must be built against that same glue; a WASI or WASIX command has no glue, so there's no such constraint. Only the chosen module is read, checked and compiled, and compiled modules are cached by its path. A read or `stat` of `/usr/bin/<name>` still shows the default `wasm`. A `variants` that isn't an array, or has an entry without an `env` object of strings and a `wasm` inside the package, is ignored as a whole, with one warning per command, and the command runs its `wasm`. An older kernel ignores the field.
 
+**A pnpm bin of a kernel command** ([#1453](https://github.com/ai-ecoverse/slicc-kernel/issues/1453)): a `#!/usr/bin/env node` (or `#!/usr/bin/node`) script run by its path, whose package lists the same name in `slicc.commands`, runs that kernel command, even when a `node` command exists. This is the bin shim `pnpm add -g` writes into `$PNPM_HOME/bin`, which names its target in a `// pnpm-wasm-shim={"target":…}` line; a script without that line is run as a script, so a same-named file in a package that differs from its glue still doesn't run as the command (#899). The shim's target, with its links resolved, must lie in a package installed directly under one of the command roots, and the name must be the catalog's command from that same package, so a shim only ever runs a command the caller could run by name, with the same checks; with `integrity` on, the shim itself is verified as a source. So `pnpm add -g <pkg> && <cmd>` works in one line.
+
 A package can also name a command that runs files by their suffix, as `binfmt_misc` does: `"slicc": { "binfmt": { ".jsh": "jsh" } }`. Executing a file that has no `#!` line and is not a wasm module, whose name ends in a mapped suffix, runs that command with the file's path as invoked and the arguments after it, as a `#!` line naming the command would; a `#!` line still wins. The longest matching suffix wins, the whole name is never a suffix (`.jsh` alone is not one), and of two packages that map one suffix, the one whose name sorts first wins, as for commands; the kernel warns once (`console.warn`) when another package maps that suffix to a different command. A suffix starts with a dot and the command must be a name the catalog resolves when the file runs.
 
 ### WASI programs

package/dist/kernel-worker.js

@@ -3221,13 +3221,7 @@ var OpfsFs = class {
     }
   }
   async place(handle, dir, name2, copies) {
-    const move = handle.move;
-    if (move) this.others++;
-    const moved2 = await move?.call(handle, dir, name2).then(
-      () => true,
-      () => false
-    );
-    if (moved2) return true;
+    if (await this.moved(handle, dir, name2)) return true;
     const before = this.fileMoves;
     try {
       await this.copy(handle, dir, name2, copies);
@@ -3240,6 +3234,23 @@ var OpfsFs = class {
     return false;
   }
   fileMoves = 0;
+  async moved(handle, dir, name2) {
+    const move = handle.move;
+    if (!move) return false;
+    for (let attempt = 0; ; attempt++) {
+      this.others++;
+      const failed3 = await move.call(handle, dir, name2).then(
+        () => void 0,
+        (err) => ({ err })
+      );
+      if (!failed3) return true;
+      const error = failed3.err?.name;
+      if (handle.kind !== "file" || !LOCKED.has(error)) return false;
+      const delay = SYNC_BACKOFF_MS[attempt];
+      if (delay === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
   async copy(handle, dir, name2, copies, rest2 = "") {
     if (handle.kind === "file" && movable(handle)) {
       this.others++;
@@ -7774,7 +7785,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.146.6" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.147.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -28848,6 +28859,8 @@ function linksOf2(req) {
   return req.links === void 0 ? {} : { links: req.links };
 }
 var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
+var SHIM_MARKER = /^\/\/ pnpm-wasm-shim=(\{.*\})$/gm;
+var SHIM_MAX = 64 * 1024;
 var PACKAGE_ROOT = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//;
 var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 var WASM_MAGIC = [0, 97, 115, 109];
@@ -29539,7 +29552,10 @@ var Launcher = class {
       return { abi: "emscripten", glue, wasm, argv0: baseName2(argv0 || file), ...asked };
     }
     const owner = await this.glueOwner(glue, baseName2(file), scope);
-    if (!owner) return void 0;
+    if (!owner) {
+      const shim = await this.shimOwner(glue, baseName2(file), scope);
+      return shim && { ...targetOf(shim), ...asked, shim: glue };
+    }
     return { ...targetOf(owner), ...asked, ...owner.glue === glue ? {} : { copy: glue } };
   }
   async ownOrRefused(path, name2, scope) {
@@ -29575,6 +29591,43 @@ var Launcher = class {
     }
     return void 0;
   }
+  async shimOwner(script, name2, scope) {
+    const command = (await this.commands(scope)).get(name2);
+    if (!command || command.script || command.origin?.script) return void 0;
+    const target = await this.shimTarget(script);
+    if (target === void 0) return void 0;
+    const pkg = await this.installedPackage(await physicalPathAsync(this.base, target), scope);
+    if (!pkg) return void 0;
+    const glue = command.origin?.glue ?? command.glue;
+    const own = await physicalPathAsync(this.base, glue).catch(() => void 0);
+    return own?.startsWith(`${pkg}/`) ? command : void 0;
+  }
+  async shimTarget(script) {
+    const st = await this.base.stat(script).catch(() => void 0);
+    if (!st?.isFile || st.size > SHIM_MAX) return void 0;
+    const text = await this.base.readFile(script).catch(() => "");
+    const marker = [...text.matchAll(SHIM_MARKER)].at(-1)?.[1];
+    if (marker === void 0) return void 0;
+    let target;
+    try {
+      target = JSON.parse(marker).target;
+    } catch {
+      return void 0;
+    }
+    if (typeof target !== "string" || target === "") return void 0;
+    const dir = await physicalPathAsync(this.base, script.slice(0, script.lastIndexOf("/")) || "/");
+    return this.fs.resolvePath(dir, target);
+  }
+  async installedPackage(real, scope) {
+    for (const root of await this.roots(scope)) {
+      const top = await physicalPathAsync(this.base, root).catch(() => void 0);
+      if (!top || !real.startsWith(`${top}/`)) continue;
+      const [first = "", second] = real.slice(top.length + 1).split("/");
+      const pkg = first.startsWith("@") && second ? `${top}/${first}/${second}` : `${top}/${first}`;
+      if (pkg !== real && await this.base.exists(`${pkg}/package.json`)) return pkg;
+    }
+    return void 0;
+  }
   async glueOwner(glue, name2, scope) {
     const commands = [...(await this.commands(scope)).values()];
     const owners = commands.filter((c) => c.abi === "emscripten" && !c.script && c.glue === glue);
@@ -29670,7 +29723,10 @@ var Launcher = class {
     const found = await this.resolve(file, argv[0] ?? file, cwd, scope);
     const named = typeof argv0 === "string" && found && !found.fixed;
     const direct = named ? { ...found, argv0 } : found;
-    if (direct) return { target: direct, args: [...direct.prefix ?? [], ...argv.slice(1)] };
+    if (direct) {
+      const shim = direct.shim ? { sources: [direct.shim], asked: direct.asked ? { [direct.shim]: direct.asked } : {} } : {};
+      return { target: direct, args: [...direct.prefix ?? [], ...argv.slice(1)], ...shim };
+    }
     if (catalogOnly && !await this.scriptCommand(file, cwd, scope)) return void 0;
     const script = await this.interpreted(file, argv, cwd, scope);
     return script && { ...script, script: true };