sandboxedjs 0.1.11 → 0.1.13

package/README.md

@@ -620,6 +620,20 @@ Two ways in, both byte-exact:
 await box.fs.writeFile("/workspace/uploads/clip.mp4", bytes);   // creates missing directories
 ```
 
+The `File` returned by a browser picker can be passed directly too. It is read
+as bytes and written at the exact container path, including an application-
+generated temporary path:
+
+```js
+const picked = input.files[0];
+const sourcePath = "/tmp/transcribe-quran-52fjch/source-1786307713702-baleela.f32le";
+await box.fs.writeFile(sourcePath, picked);
+```
+
+Do not pass `picked.path` (or any other host path) to a command in the
+container. Browser file pickers provide file data, not a path the sandbox can
+see.
+
 ```js
 // 2. Through a server running inside the container — a picker in the previewed
 //    app posting to its own backend. Publish the port and upload normally.

package/dist/index.cjs

@@ -23480,6 +23480,14 @@ function installUserland(kernel) {
 
 // src/container/fs.ts
 init_path();
+async function bytesFor(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return new Uint8Array(await data.arrayBuffer());
+}
 var ContainerFs = class {
   constructor(kernel) {
     this.kernel = kernel;
@@ -23496,10 +23504,12 @@ var ContainerFs = class {
     const abs = clean(path);
     const parent = dirname(abs);
     if (!this.vfs.lexists(parent)) this.vfs.mkdir(parent, { recursive: true, mode: 493 });
-    this.vfs.writeFile(abs, data, { privileged: true, mode: opts.mode ?? 420 });
+    const content = typeof data === "string" ? data : await bytesFor(data);
+    this.vfs.writeFile(abs, content, { privileged: true, mode: opts.mode ?? 420 });
   }
   async appendFile(path, data) {
-    this.vfs.appendFile(clean(path), data, { privileged: true });
+    const content = typeof data === "string" ? data : await bytesFor(data);
+    this.vfs.appendFile(clean(path), content, { privileged: true });
   }
   async readdir(path, opts) {
     if (opts?.withFileTypes) return this.vfs.readdirWithTypes(clean(path));
@@ -23665,6 +23675,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;
@@ -23675,6 +23825,7 @@ var Container = class _Container {
   hooks;
   disposed = false;
   defaultSession = null;
+  restoreNodeChildProcessBridge;
   constructor(kernel, pod, opts) {
     this.kernel = kernel;
     this.pod = pod;
@@ -23703,6 +23854,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 = {}) {
@@ -24113,6 +24265,7 @@ var Container = class _Container {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    this.restoreNodeChildProcessBridge();
     this.kernel.dispose();
     try {
       this.pod.teardown();