sandboxedjs 0.1.12 → 0.1.14

package/dist/index.d.cts

@@ -1509,6 +1509,7 @@ declare class Container {
     private readonly hooks;
     private disposed;
     private defaultSession;
+    private readonly restoreNodeChildProcessBridge;
     private constructor();
     static create(opts?: ContainerOptions): Promise<Container>;
     /**

package/dist/index.d.ts

@@ -1509,6 +1509,7 @@ declare class Container {
     private readonly hooks;
     private disposed;
     private defaultSession;
+    private readonly restoreNodeChildProcessBridge;
     private constructor();
     static create(opts?: ContainerOptions): Promise<Container>;
     /**

package/dist/index.js

@@ -22542,7 +22542,13 @@ async function loadFactory() {
   const { createRequire } = await nodeBuiltin("module");
   const fs = await nodeBuiltin("fs/promises");
   const path = await nodeBuiltin("path");
-  const require2 = createRequire(path.join(process.cwd(), "index.js"));
+  const packageRequire = createRequire(import.meta.url);
+  let require2 = packageRequire;
+  try {
+    require2.resolve("@ffmpeg/core/wasm");
+  } catch {
+    require2 = createRequire(path.join(process.cwd(), "index.js"));
+  }
   const wasmPath = require2.resolve("@ffmpeg/core/wasm");
   const wasm = await fs.readFile(wasmPath);
   const module = await Promise.resolve().then(() => (init_ffmpeg_core(), ffmpeg_core_exports));
@@ -23670,6 +23676,146 @@ var Session = class {
   }
 };
 
+// src/runtime/node-child-process-bridge.ts
+var KernelChildProcess = class {
+  pid;
+  command;
+  args;
+  parentPid;
+  state = "running";
+  exitCode;
+  stdout = "";
+  stderr = "";
+  listeners = /* @__PURE__ */ new Map();
+  kernel;
+  cred;
+  cwd;
+  env;
+  stdin = new Pipe();
+  process;
+  started = false;
+  cancelled = false;
+  constructor(kernel, cred, config, pid) {
+    this.kernel = kernel;
+    this.cred = cred;
+    this.pid = pid;
+    this.command = config.command;
+    this.args = config.args?.slice() ?? [];
+    this.parentPid = config.parentPid;
+    this.cwd = config.cwd ?? "/";
+    this.env = { ...config.env };
+  }
+  on(event, listener) {
+    let listeners = this.listeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(event, listeners);
+    }
+    listeners.add(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    for (const listener of this.listeners.get(event) ?? []) listener(...args);
+  }
+  exec() {
+    if (this.started) return;
+    this.started = true;
+    queueMicrotask(() => {
+      if (this.cancelled) {
+        this.finish(143);
+        return;
+      }
+      const stdout = new ChildOutput(this, "stdout");
+      const stderr = new ChildOutput(this, "stderr");
+      try {
+        this.process = this.kernel.spawn([this.command, ...this.args], {
+          cwd: this.cwd,
+          env: this.env,
+          cred: this.cred,
+          stdin: this.stdin,
+          stdout,
+          stderr,
+          ppid: 1
+        });
+        void this.process.wait().then((code) => {
+          stdout.end();
+          stderr.end();
+          this.finish(code);
+        });
+      } catch (error) {
+        stderr.write(error instanceof Error ? error.message : String(error));
+        stderr.end();
+        stdout.end();
+        this.finish(1);
+      }
+    });
+  }
+  sendStdin(data) {
+    try {
+      this.stdin.write(data);
+    } catch {
+    }
+  }
+  kill(signal = "SIGTERM") {
+    if (this.process) {
+      this.process.deliver(signal);
+      return;
+    }
+    this.cancelled = true;
+  }
+  finish(code) {
+    if (this.state === "exited") return;
+    this.state = "exited";
+    this.exitCode = code;
+    this.emit("exit", code);
+  }
+  append(stream, text) {
+    this[stream] += text;
+    this.emit(stream, text);
+  }
+};
+var ChildOutput = class {
+  constructor(child, stream) {
+    this.child = child;
+    this.stream = stream;
+  }
+  child;
+  stream;
+  isTTY = false;
+  closedState = false;
+  decoder = new TextDecoder();
+  get closed() {
+    return this.closedState;
+  }
+  write(data) {
+    if (this.closedState) return;
+    const text = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
+    if (text) this.child.append(this.stream, text);
+  }
+  end() {
+    if (this.closedState) return;
+    this.closedState = true;
+    const tail2 = this.decoder.decode();
+    if (tail2) this.child.append(this.stream, tail2);
+  }
+};
+var nextBridgePid = 1073741824;
+function installNodeChildProcessBridge(pod, kernel, cred) {
+  const manager = pod.processManager;
+  const originalSpawn = manager.spawn;
+  manager.spawn = (config) => {
+    const resolved = kernel.resolveExecutable(config.command, config.cwd ?? "/", config.env ?? {}, cred);
+    if (resolved?.kind === "builtin" && resolved.command?.name !== "node" && resolved.command?.name !== "nodejs") {
+      return new KernelChildProcess(kernel, cred, config, nextBridgePid++);
+    }
+    return originalSpawn.call(manager, config);
+  };
+  return () => {
+    if (manager.spawn === originalSpawn) return;
+    manager.spawn = originalSpawn;
+  };
+}
+
 // src/container/container.ts
 var Container = class _Container {
   kernel;
@@ -23680,6 +23826,7 @@ var Container = class _Container {
   hooks;
   disposed = false;
   defaultSession = null;
+  restoreNodeChildProcessBridge;
   constructor(kernel, pod, opts) {
     this.kernel = kernel;
     this.pod = pod;
@@ -23708,6 +23855,7 @@ var Container = class _Container {
     };
     if (opts.timeoutMs !== void 0) this.defaults.timeoutMs = opts.timeoutMs;
     this.hooks = { onStdout: opts.onStdout, onStderr: opts.onStderr };
+    this.restoreNodeChildProcessBridge = installNodeChildProcessBridge(pod, kernel, cred);
   }
   // ── boot ──────────────────────────────────────────────────────────────────
   static async create(opts = {}) {
@@ -24118,6 +24266,7 @@ var Container = class _Container {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    this.restoreNodeChildProcessBridge();
     this.kernel.dispose();
     try {
       this.pod.teardown();