@ai-ecoverse/slicc-jsh 0.2.1 → 0.3.1

package/dist/node.mjs

@@ -1585,7 +1585,7 @@ function assignProcessExitCode(value) {
 // package.json
 var package_default = {
   name: "@ai-ecoverse/slicc-jsh",
-  version: "0.2.1",
+  version: "0.3.1",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1639,7 +1639,7 @@ var package_default = {
   },
   scripts: {
     build: "node scripts/build.mjs && node scripts/build-host.mjs",
-    prepack: "npm run build",
+    prepack: "npm run build && node scripts/strip-own-scripts.mjs",
     prepare: "npm run build",
     lint: "node scripts/lint.mjs",
     test: "npm run test:golden && npm run test:jsh && npm run test:integration",
@@ -1655,7 +1655,7 @@ var package_default = {
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   devDependencies: {
-    "@ai-ecoverse/slicc-kernel": "1.59.0",
+    "@ai-ecoverse/slicc-kernel": "1.59.1",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     acorn: "8.19.0",
@@ -10793,6 +10793,415 @@ function createEvents() {
   });
 }
 
+// src/runtime/builtins/child-process.mjs
+var SIGNAL_NAMES = {
+  1: "SIGHUP",
+  2: "SIGINT",
+  3: "SIGQUIT",
+  6: "SIGABRT",
+  9: "SIGKILL",
+  10: "SIGUSR1",
+  12: "SIGUSR2",
+  13: "SIGPIPE",
+  14: "SIGALRM",
+  15: "SIGTERM",
+  17: "SIGCHLD",
+  18: "SIGCONT",
+  19: "SIGSTOP",
+  20: "SIGTSTP"
+};
+var SIGNAL_NUMBERS = Object.fromEntries(
+  Object.entries(SIGNAL_NAMES).map(([n, name]) => [name, Number(n)])
+);
+function notSupported(name) {
+  const err = new Error(`slicc-jsh: child_process.${name} is not supported yet`);
+  err.code = "ERR_NOT_SUPPORTED";
+  throw err;
+}
+function normalizeArgs(file, args, options, callback) {
+  if (typeof args === "function") {
+    return { args: [], options: {}, callback: args };
+  }
+  if (typeof options === "function") {
+    return { args: Array.isArray(args) ? args : [], options: {}, callback: options };
+  }
+  if (args != null && !Array.isArray(args) && typeof args === "object") {
+    return { args: [], options: args, callback: typeof options === "function" ? options : callback };
+  }
+  return {
+    args: Array.isArray(args) ? args.map(String) : [],
+    options: options && typeof options === "object" ? options : {},
+    callback: typeof callback === "function" ? callback : void 0
+  };
+}
+function normalizeStdio(stdio) {
+  if (stdio === void 0) return ["pipe", "pipe", "pipe"];
+  if (typeof stdio === "string") return [stdio, stdio, stdio];
+  if (Array.isArray(stdio)) {
+    return [stdio[0] ?? "pipe", stdio[1] ?? "pipe", stdio[2] ?? "pipe"];
+  }
+  return ["pipe", "pipe", "pipe"];
+}
+function toKernelStdio(mode) {
+  if (mode === "pipe" || mode === "overlapped") return "pipe";
+  if (mode === "ignore" || mode === null || mode === void 0 || mode === "null") return "null";
+  if (mode === "inherit") return "inherit";
+  if (typeof mode === "number") return mode;
+  const err = new Error(`The argument 'stdio' is invalid. Received ${String(mode)}`);
+  err.code = "ERR_INVALID_ARG_VALUE";
+  throw err;
+}
+function signalName(sig) {
+  if (sig == null) return null;
+  if (typeof sig === "string") return sig.startsWith("SIG") ? sig : `SIG${sig}`;
+  if (typeof sig === "number") return SIGNAL_NAMES[sig] ?? String(sig);
+  return null;
+}
+function spawnError(command, args, code, message) {
+  const err = new Error(message ?? `spawn ${command} ${code}`);
+  err.code = code;
+  err.errno = code === "ENOENT" ? -2 : void 0;
+  err.syscall = "spawn";
+  err.path = command;
+  err.spawnargs = args;
+  return err;
+}
+function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles, getStream }) {
+  class ChildProcess extends EventEmitter {
+    constructor() {
+      super();
+      this.stdin = null;
+      this.stdout = null;
+      this.stderr = null;
+      this.pid = void 0;
+      this.exitCode = null;
+      this.signalCode = null;
+      this.killed = false;
+      this.connected = false;
+      this.spawnfile = "";
+      this.spawnargs = [];
+      this.#kernel = null;
+      this.#handle = null;
+      this.#closing = false;
+    }
+    #kernel;
+    #handle;
+    #closing;
+    kill(signal = "SIGTERM") {
+      const name = signalName(signal) ?? "SIGTERM";
+      this.killed = true;
+      if (!this.#kernel) return false;
+      try {
+        const ret = this.#kernel.kill(name);
+        return ret !== false;
+      } catch {
+        return false;
+      }
+    }
+    ref() {
+      if (this.#handle) handles.add(this.#handle);
+      return this;
+    }
+    unref() {
+      if (this.#handle) handles.delete(this.#handle);
+      return this;
+    }
+    /** @internal */
+    _bindKernel(child) {
+      this.#kernel = child;
+      this.pid = child.pid;
+      this.#handle = { kind: "child", pid: child.pid };
+      handles.add(this.#handle);
+    }
+    /** @internal */
+    _release() {
+      if (this.#handle) {
+        handles.delete(this.#handle);
+        this.#handle = null;
+      }
+    }
+    /** @internal */
+    _markClosing() {
+      this.#closing = true;
+    }
+    get _closing() {
+      return this.#closing;
+    }
+  }
+  function createPipeReadable() {
+    const { Readable } = getStream();
+    const r = new Readable({ read() {
+    } });
+    r._sliccPump = async (webStream) => {
+      if (!webStream) {
+        r.push(null);
+        return;
+      }
+      try {
+        const reader = webStream.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunk = value instanceof Uint8Array ? Buffer2.from(value) : Buffer2.from(String(value));
+          r.push(chunk);
+        }
+        r.push(null);
+      } catch (err) {
+        r.destroy(err);
+      }
+    };
+    return r;
+  }
+  function createPipeWritable() {
+    const { Writable } = getStream();
+    let writer = null;
+    const pending = [];
+    let ended = false;
+    const w = new Writable({
+      write(chunk, _enc, cb) {
+        const bytes = typeof chunk === "string" ? Buffer2.from(chunk) : chunk;
+        if (!writer) {
+          pending.push({ bytes, cb });
+          return;
+        }
+        writer.write(bytes).then(() => cb(), cb);
+      },
+      final(cb) {
+        ended = true;
+        if (!writer) {
+          pending.push({ end: true, cb });
+          return;
+        }
+        writer.close().then(() => cb(), cb);
+      },
+      destroy(err, cb) {
+        if (writer) writer.abort(err).then(() => cb(err), () => cb(err));
+        else cb(err);
+      }
+    });
+    w._sliccAttach = (webStream) => {
+      if (!webStream) {
+        for (const p of pending) p.cb?.(new Error("stdin not available"));
+        pending.length = 0;
+        return;
+      }
+      writer = webStream.getWriter();
+      for (const p of pending) {
+        if (p.end) writer.close().then(() => p.cb(), p.cb);
+        else writer.write(p.bytes).then(() => p.cb(), p.cb);
+      }
+      pending.length = 0;
+      if (ended && pending.length === 0) {
+      }
+    };
+    return w;
+  }
+  function prepareStdio(child, stdio) {
+    const [inMode, outMode, errMode] = stdio;
+    if (toKernelStdio(inMode) === "pipe") child.stdin = createPipeWritable();
+    if (toKernelStdio(outMode) === "pipe") child.stdout = createPipeReadable();
+    if (toKernelStdio(errMode) === "pipe") child.stderr = createPipeReadable();
+  }
+  function connectStdio(child, kernelChild) {
+    child.stdin?._sliccAttach?.(kernelChild.stdin);
+    const pumps = [];
+    if (child.stdout?._sliccPump) pumps.push(child.stdout._sliccPump(kernelChild.stdout));
+    if (child.stderr?._sliccPump) pumps.push(child.stderr._sliccPump(kernelChild.stderr));
+    child._stdioPumps = Promise.all(pumps);
+  }
+  function finish(child, code, signal) {
+    if (child._closing) return;
+    child._markClosing();
+    child.exitCode = code;
+    child.signalCode = signal;
+    child.emit("exit", code, signal);
+    const after = child._stdioPumps ?? Promise.resolve();
+    trackPromise(handles, after);
+    after.finally(() => {
+      child.emit("close", code, signal);
+      child._release();
+      handles.notify?.();
+    });
+  }
+  function startSpawn(child, file, args, options, stdio) {
+    const cwd = options.cwd != null ? String(options.cwd) : process2.cwd();
+    const env = options.env ? { ...options.env } : { ...process2.env };
+    const argv = [file, ...args];
+    child.spawnfile = file;
+    child.spawnargs = argv;
+    const spawnPromise = ctx.spawn({
+      argv,
+      cwd,
+      env,
+      stdin: toKernelStdio(stdio[0]),
+      stdout: toKernelStdio(stdio[1]),
+      stderr: toKernelStdio(stdio[2])
+    });
+    trackPromise(handles, spawnPromise);
+    spawnPromise.then(
+      (kernelChild) => {
+        child._bindKernel(kernelChild);
+        connectStdio(child, kernelChild);
+        child.emit("spawn");
+        const waitP = kernelChild.wait();
+        trackPromise(handles, waitP);
+        waitP.then(
+          (status) => {
+            const sigNum = status?.signal;
+            if (sigNum != null && sigNum !== 0) {
+              const name = SIGNAL_NAMES[sigNum] ?? String(sigNum);
+              finish(child, null, name);
+            } else {
+              const code = typeof status?.status === "number" ? status.status : 0;
+              finish(child, code, null);
+            }
+          },
+          (err) => {
+            child.emit("error", err);
+            finish(child, 1, null);
+          }
+        );
+      },
+      (err) => {
+        const code = err?.code === "ENOENT" ? "ENOENT" : err?.code ?? "ERR_SPAWN_FAILED";
+        const error = code === "ENOENT" ? spawnError(file, args, "ENOENT", `spawn ${file} ENOENT`) : spawnError(file, args, code, err?.message ?? String(err));
+        try {
+          child.stdout?.push?.(null);
+        } catch {
+        }
+        try {
+          child.stderr?.push?.(null);
+        } catch {
+        }
+        process2.nextTick(() => {
+          child.emit("error", error);
+          if (code === "ENOENT") {
+            child.exitCode = -2;
+            child.emit("close", -2, null);
+          } else {
+            finish(child, 1, null);
+          }
+          child._release();
+          handles.notify?.();
+        });
+      }
+    );
+  }
+  function spawn(command, args, options) {
+    let file = command;
+    let argv = args;
+    let opts = options;
+    if (argv != null && !Array.isArray(argv) && typeof argv === "object") {
+      opts = argv;
+      argv = [];
+    }
+    argv = Array.isArray(argv) ? argv.map(String) : [];
+    opts = opts && typeof opts === "object" ? opts : {};
+    file = String(file);
+    if (opts.shell) {
+      const shell = typeof opts.shell === "string" ? opts.shell : "sh";
+      const line = argv.length ? [file, ...argv].join(" ") : file;
+      file = shell;
+      argv = ["-c", line];
+    }
+    const stdio = normalizeStdio(opts.stdio);
+    const child = new ChildProcess();
+    prepareStdio(child, stdio);
+    process2.nextTick(() => startSpawn(child, file, argv, opts, stdio));
+    return child;
+  }
+  function execFile(file, args, options, callback) {
+    const norm = normalizeArgs(file, args, options, callback);
+    const opts = { ...norm.options };
+    if (opts.stdio === void 0) opts.stdio = ["pipe", "pipe", "pipe"];
+    const child = spawn(String(file), norm.args, opts);
+    if (!norm.callback) return child;
+    const maxBuffer = opts.maxBuffer ?? 1024 * 1024;
+    let stdout = Buffer2.alloc(0);
+    let stderr = Buffer2.alloc(0);
+    let exited = false;
+    const done = (err) => {
+      if (exited) return;
+      exited = true;
+      const enc = opts.encoding;
+      const out = enc ? stdout.toString(enc) : stdout;
+      const errOut = enc ? stderr.toString(enc) : stderr;
+      norm.callback(err, out, errOut);
+    };
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        stdout = Buffer2.concat([stdout, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+        if (stdout.length > maxBuffer) {
+          child.kill();
+          const err = new Error("stdout maxBuffer exceeded");
+          err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+          done(err);
+        }
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr = Buffer2.concat([stderr, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+        if (stderr.length > maxBuffer) {
+          child.kill();
+          const err = new Error("stderr maxBuffer exceeded");
+          err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+          done(err);
+        }
+      });
+    }
+    child.on("error", (err) => done(err));
+    child.on("close", (code, signal) => {
+      if (exited) return;
+      if (code === 0 && !signal) {
+        done(null);
+        return;
+      }
+      const err = new Error(`Command failed: ${file} ${norm.args.join(" ")}`);
+      err.code = code;
+      err.killed = child.killed;
+      err.signal = signal;
+      err.cmd = `${file} ${norm.args.join(" ")}`.trim();
+      err.stdout = opts.encoding ? stdout.toString(opts.encoding) : stdout;
+      err.stderr = opts.encoding ? stderr.toString(opts.encoding) : stderr;
+      done(err);
+    });
+    return child;
+  }
+  function exec(command, options, callback) {
+    let opts = options;
+    let cb = callback;
+    if (typeof options === "function") {
+      cb = options;
+      opts = {};
+    }
+    opts = opts && typeof opts === "object" ? opts : {};
+    const shell = typeof opts.shell === "string" ? opts.shell : "sh";
+    return execFile(shell, ["-c", String(command)], { ...opts, shell: false }, cb);
+  }
+  return {
+    spawn,
+    execFile,
+    exec,
+    spawnSync() {
+      notSupported("spawnSync");
+    },
+    execSync() {
+      notSupported("execSync");
+    },
+    execFileSync() {
+      notSupported("execFileSync");
+    },
+    fork() {
+      notSupported("fork");
+    },
+    ChildProcess,
+    // Expose for tests / advanced callers
+    _SIGNAL_NAMES: SIGNAL_NAMES,
+    _SIGNAL_NUMBERS: SIGNAL_NUMBERS
+  };
+}
+
 // src/runtime/builtins/fs.mjs
 var encoder3 = new TextEncoder();
 var decoder3 = new TextDecoder();
@@ -11187,6 +11596,21 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         throw nodeFsError(err?.code || "ENOENT", "lstat", pathArg, err);
       }
     },
+    /**
+     * Resolve to a canonical absolute path. Symlink walk is not implemented;
+     * when the path exists we return the normalized absolute form (enough for
+     * pnpm's cmd shims, which only need dirname(realpathSync(argv[1]))).
+     */
+    realpathSync(p) {
+      const pathArg = p;
+      const target = abs(p);
+      try {
+        syncFs.stat(target);
+        return target;
+      } catch (err) {
+        throw nodeFsError(err?.code || "ENOENT", "realpath", pathArg, err);
+      }
+    },
     readdirSync,
     mkdirSync,
     rmdirSync(p, options = {}) {
@@ -11825,6 +12249,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     access: callbackify(syncApi.accessSync),
     stat: callbackify(syncApi.statSync),
     lstat: callbackify(syncApi.lstatSync),
+    realpath: callbackify(syncApi.realpathSync),
     readdir: callbackify(syncApi.readdirSync),
     mkdir: callbackify(syncApi.mkdirSync),
     rmdir: callbackify(syncApi.rmdirSync),
@@ -12685,7 +13110,7 @@ function createHttp2({ ctx, process: process2, Buffer: Buffer2, handles, getStre
 
 // src/runtime/builtins/https.mjs
 var TLS_CLIENT_OPTS = ["cert", "key", "pfx", "ca"];
-function notSupported(what) {
+function notSupported2(what) {
   const err = new Error(`slicc-jsh: '${what}' is not supported yet (no TLS on ctx.net)`);
   err.code = "ERR_NOT_SUPPORTED";
   return err;
@@ -12699,7 +13124,7 @@ function isManualRedirectUnsupported(err) {
 function rejectTlsOptions(options) {
   for (const name of TLS_CLIENT_OPTS) {
     if (options?.[name] != null) {
-      throw notSupported(`https.request option '${name}'`);
+      throw notSupported2(`https.request option '${name}'`);
     }
   }
 }
@@ -12733,7 +13158,7 @@ function createHttps({ ctx, Buffer: Buffer2, http, handles }) {
     }
   }
   function createServer() {
-    throw notSupported("https.createServer");
+    throw notSupported2("https.createServer");
   }
   class ClientRequest extends EventEmitter {
     #ended = false;
@@ -12824,7 +13249,7 @@ function createHttps({ ctx, Buffer: Buffer2, http, handles }) {
       if (this.#sent || this.#destroyed) return;
       this.#sent = true;
       try {
-        if (typeof ctx.fetch !== "function") throw notSupported("https.request");
+        if (typeof ctx.fetch !== "function") throw notSupported2("https.request");
         const opts = this.#opts;
         const method = (opts.method ?? "GET").toUpperCase();
         const host = opts.hostname ?? opts.host ?? "localhost";
@@ -13713,6 +14138,7 @@ var BUILTIN_LIST = [
   "assert",
   "assert/strict",
   "buffer",
+  "child_process",
   "console",
   "events",
   "fs",
@@ -13736,7 +14162,6 @@ var BUILTIN_LIST = [
   "util/types"
 ];
 var NOT_YET = [
-  "child_process",
   "http2",
   "crypto",
   "zlib",
@@ -13755,7 +14180,7 @@ var NOT_YET = [
   "v8",
   "was"
 ];
-function notSupported2(id) {
+function notSupported3(id) {
   const err = new Error(`slicc-jsh: '${id}' is not supported yet`);
   err.code = "ERR_NOT_SUPPORTED";
   throw err;
@@ -13801,6 +14226,13 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     if (!https) https = createHttps({ ctx, Buffer: Buffer2, http: getHttp(), handles });
     return https;
   };
+  let childProcess;
+  const getChildProcess = () => {
+    if (!childProcess) {
+      childProcess = createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles, getStream });
+    }
+    return childProcess;
+  };
   let ModuleExport = null;
   const implemented = {
     process: () => process2,
@@ -13826,7 +14258,8 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     "timers/promises": () => timersPromises,
     net: () => getNet(),
     http: () => getHttp(),
-    https: () => getHttps()
+    https: () => getHttps(),
+    child_process: () => getChildProcess()
   };
   return {
     installModule(Module) {
@@ -13840,7 +14273,7 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     },
     load(id) {
       const bare = id.startsWith("node:") ? id.slice(5) : id;
-      if (NOT_YET.includes(bare)) notSupported2(bare);
+      if (NOT_YET.includes(bare)) notSupported3(bare);
       const factory = implemented[bare];
       if (!factory) {
         const err = new Error(`No such built-in module: ${id}`);
@@ -15892,6 +16325,42 @@ var Process = class extends EventEmitter {
   cwd() {
     return this._cwd;
   }
+  /** Root (0) until credential plumbing is exposed on process. */
+  getuid() {
+    return 0;
+  }
+  geteuid() {
+    return 0;
+  }
+  getgid() {
+    return 0;
+  }
+  getegid() {
+    return 0;
+  }
+  getgroups() {
+    return [0];
+  }
+  /**
+   * Minimal process.kill: only this process (pid === this.pid). Used by pnpm
+   * cmd shims to re-raise a child's terminating signal. Unknown pids → ESRCH.
+   */
+  kill(pid, signal = "SIGTERM") {
+    const target = Number(pid);
+    if (target !== this.pid) {
+      const err = new Error(`kill ESRCH`);
+      err.code = "ESRCH";
+      err.errno = -3;
+      err.syscall = "kill";
+      throw err;
+    }
+    const name = typeof signal === "string" ? signal.startsWith("SIG") ? signal : `SIG${signal}` : "SIGTERM";
+    if (name === "SIGTERM" || name === "SIGINT" || name === "SIGHUP" || name === "SIGKILL") {
+      const codes = { SIGTERM: 143, SIGINT: 130, SIGHUP: 129, SIGKILL: 137 };
+      this.exit(codes[name] ?? 1);
+    }
+    return true;
+  }
   chdir(path) {
     if (typeof path !== "string") {
       const err = new TypeError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-jsh",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   "type": "module",
   "license": "Apache-2.0",
@@ -54,8 +54,6 @@
   },
   "scripts": {
     "build": "node scripts/build.mjs && node scripts/build-host.mjs",
-    "prepack": "npm run build",
-    "prepare": "npm run build",
     "lint": "node scripts/lint.mjs",
     "test": "npm run test:golden && npm run test:jsh && npm run test:integration",
     "test:golden": "node --max-old-space-size=512 scripts/golden.mjs check",
@@ -70,7 +68,7 @@
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   "devDependencies": {
-    "@ai-ecoverse/slicc-kernel": "1.59.0",
+    "@ai-ecoverse/slicc-kernel": "1.59.1",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     "acorn": "8.19.0",