@ai-ecoverse/slicc-kernel 1.36.0 → 1.37.0

package/README.md

@@ -143,6 +143,8 @@ A WASI preview1 or WASIX program (Zig, Rust, Go, wasi-libc or wasix-libc C) has
 
 Entries may also set `argv0`, `args` and `env`, and a package can set `slicc.env` for all of its commands. A WASI entry with `"preopenRoot": true` also gets `/` as a preopen (see [WASI programs](#wasi-programs)). An entry with `"argv0Path": true` gets the absolute path it was run by as `argv[0]` when that path is a link outside `/bin` and `/usr/bin` to the command, as a venv's `bin/python` is (the `#!` line of a script naming such a link included), so it can find what sits beside that link; other entries keep their `argv0`. In `env`, `${package}` is the package directory, `${cwd}` the process's working directory, and `${NAME}` the caller's `NAME` when the program starts (a default naming an unset variable is left out); a relative path that exists in the package (`lib/python3.14`, `./`) becomes that absolute path. The caller's environment wins over these defaults; a `null` value removes the variable for the command, after the caller's environment is applied (a host-networked program can drop the kernel's proxy settings that way), and a command entry can set a variable its package's `slicc.env` removes. The first package to define a name wins. `sh` runs bash as `sh` unless a package provides its own. The installed commands appear as executables in a virtual `/usr/bin` and `/bin`, so `PATH` lookups, `command -v` and `ls /usr/bin` work without writing anything to OPFS. A process can also run a program by the path of its glue when the `.wasm` sits next to it, a wasm module by its own path (as a WASI program), and a script through its `#!` line (including `#!/usr/bin/env name`). Executing any other file fails with `ENOEXEC`, so bash runs it as a shell script, as POSIX shells do. Commands also come from pnpm's global directory. Every process gets `PNPM_HOME=/home/.local/share/pnpm`, unless the embedder sets its own, and has `$PNPM_HOME/bin` on `PATH`. The kernel scans each of pnpm's global install groups (`$PNPM_HOME/global/*/<group>/node_modules`) after `/node_modules`, which wins when both provide a command. The catalog is re-read whenever anything under either changes, so `pnpm add -g @ai-ecoverse/wasi-ripgrep` makes `rg` work in the same shell, and `pnpm remove -g` removes it again.
 
+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 the first package to map a suffix wins, as for commands. A suffix starts with a dot and the command must be a name the catalog resolves when the file runs.
+
 ### WASI programs
 
 A WASI program runs in a process worker of its own like an Emscripten one, against the same kernel: its descriptors, pipes, terminals and job control are the kernel's, and its files are OPFS. **Preopens**, in order:

package/dist/kernel-worker.js

@@ -4733,6 +4733,35 @@ async function scanFilesystems(fs, modules) {
   }
   return found;
 }
+var SUFFIX = /^\.[A-Za-z0-9_+-][A-Za-z0-9._+-]*$/;
+async function scanBinfmts(fs, modules) {
+  const found = /* @__PURE__ */ new Map();
+  for (const pkg of await packagesIn(fs, modules)) {
+    let manifest;
+    try {
+      manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
+    } catch {
+      continue;
+    }
+    const declared = manifest.slicc?.binfmt;
+    if (!declared || typeof declared !== "object") continue;
+    for (const [suffix, command] of Object.entries(declared)) {
+      if (!SUFFIX.test(suffix) || typeof command !== "string" || !NAME.test(command)) continue;
+      if (!found.has(suffix)) found.set(suffix, command);
+    }
+  }
+  return found;
+}
+function binfmtOf(binfmts, path) {
+  const name2 = path.slice(path.lastIndexOf("/") + 1);
+  let best;
+  for (const suffix of binfmts.keys()) {
+    if (name2.length > suffix.length && name2.endsWith(suffix)) {
+      if (best === void 0 || suffix.length > best.length) best = suffix;
+    }
+  }
+  return best === void 0 ? void 0 : binfmts.get(best);
+}
 
 // src/fs/commands.ts
 var S_IFDIR2 = 16384;
@@ -10383,6 +10412,7 @@ var PACKAGE_ROOT = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//;
 var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 var WASM_MAGIC = [0, 97, 115, 109];
 var SHEBANG_MAX = 256;
+var MAX_INTERPRETERS = 4;
 var NOT_FOUND = 127;
 var DECIDE_MS = 100;
 var INIT_PID = 1;
@@ -10434,6 +10464,17 @@ function targetOf(command) {
     ...command.preopenRoot ? { preopenRoot: true } : {}
   };
 }
+function withScriptEnv(target, command) {
+  if (!command) return target;
+  return {
+    ...target,
+    env: { ...target.env, ...command.env },
+    unset: [
+      ...(target.unset ?? []).filter((key) => !Object.hasOwn(command.env ?? {}, key)),
+      ...command.unset ?? []
+    ]
+  };
+}
 function childHandle(handle) {
   return {
     pid: handle.pid,
@@ -10458,6 +10499,7 @@ var Launcher = class {
   modulesDir;
   env;
   catalog;
+  binfmts;
   compiled = /* @__PURE__ */ new Map();
   processes = /* @__PURE__ */ new Map();
   zombies = /* @__PURE__ */ new Set();
@@ -10539,6 +10581,7 @@ var Launcher = class {
     this.fs = keepingOpen(fs, this.nodes);
     this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
       this.catalog = void 0;
+      this.binfmts = void 0;
     });
   }
   setRoutes(table) {
@@ -10548,6 +10591,10 @@ var Launcher = class {
     this.catalog ??= this.roots().then((roots) => scanCommands(this.base, roots));
     return this.catalog;
   }
+  interpreters() {
+    this.binfmts ??= this.roots().then((roots) => scanBinfmts(this.base, roots));
+    return this.binfmts;
+  }
   async roots() {
     return [this.modulesDir, ...await pnpmGlobalRoots(this.base, this.pnpmHome)];
   }
@@ -10593,30 +10640,28 @@ var Launcher = class {
     const command = (await this.commands()).get(name2);
     return command?.script ? command : void 0;
   }
-  async interpreted(file, argv, cwd) {
+  async interpreted(file, argv, cwd, depth = 0) {
     const command = await this.scriptCommand(file);
     const script = command?.script ?? this.fs.resolvePath(cwd, file);
-    const words = shebang(await this.head(script) ?? new Uint8Array());
+    const head = await this.head(script);
+    if (!head) return void 0;
+    const binfmt = isWasm(head) ? void 0 : binfmtOf(await this.interpreters(), script);
+    const words = shebang(head) ?? (binfmt ? [binfmt] : void 0);
     if (!words) return void 0;
     if (baseName(words[0]) === "env") words.shift();
     const [interp, ...rest] = words;
-    const found = interp ? await this.resolve(interp, interp, cwd) : void 0;
-    if (!found) return void 0;
-    const target = command ? {
-      ...found,
-      env: { ...found.env, ...command.env },
-      unset: [...found.unset ?? [], ...command.unset ?? []]
-    } : found;
     const arg = rest.join(" ");
-    return {
-      target,
-      args: [
-        ...target.prefix ?? [],
-        ...arg ? [arg] : [],
-        command ? script : file,
-        ...argv.slice(1)
-      ]
-    };
+    const passed = [...arg ? [arg] : [], command ? script : file, ...argv.slice(1)];
+    const found = interp ? await this.resolve(interp, interp, cwd) : void 0;
+    if (!found) {
+      if (!interp || depth >= MAX_INTERPRETERS || !await this.scriptCommand(interp)) {
+        return void 0;
+      }
+      const inner = await this.interpreted(interp, [interp, ...passed], cwd, depth + 1);
+      return inner && { ...inner, target: withScriptEnv(inner.target, command) };
+    }
+    const target = withScriptEnv(found, command);
+    return { target, args: [...target.prefix ?? [], ...passed] };
   }
   async plan(file, argv, cwd) {
     const direct = await this.resolve(file, argv[0] ?? file, cwd);
@@ -10624,8 +10669,10 @@ var Launcher = class {
     return this.interpreted(file, argv, cwd);
   }
   async unrunnable(file, cwd) {
-    const head = await this.base.readFileBuffer(this.fs.resolvePath(cwd, file)).catch(() => null);
-    return head && !(head[0] === 35 && head[1] === 33) ? "ENOEXEC" : "ENOENT";
+    const path = this.fs.resolvePath(cwd, file);
+    const head = await this.base.readFileBuffer(path).catch(() => null);
+    if (!head || head[0] === 35 && head[1] === 33) return "ENOENT";
+    return binfmtOf(await this.interpreters(), path) ? "ENOENT" : "ENOEXEC";
   }
   module(path) {
     return this.base.stat(path).then((st) => {
@@ -11085,6 +11132,7 @@ var Launcher = class {
   }
   async starting(argv, dir) {
     this.catalog = void 0;
+    this.binfmts = void 0;
     const cwd = this.fs.resolvePath("/", dir ?? "/");
     const [file = ""] = argv;
     await this.base.mkdir(cwd, { recursive: true });