sandboxedjs 0.1.31 → 0.1.32

package/dist/index.cjs

@@ -8858,7 +8858,7 @@ async function runShell(ctxName, ctx) {
   const args = ctx.args.slice();
   let command;
   let scriptPath;
-  let readStdin2 = false;
+  let readStdin = false;
   let interactive = false;
   let login = ctxName.startsWith("-");
   const options = {};
@@ -8871,7 +8871,7 @@ async function runShell(ctxName, ctx) {
       break;
     }
     if (arg === "-s") {
-      readStdin2 = true;
+      readStdin = true;
       continue;
     }
     if (arg === "-i") {
@@ -8908,7 +8908,7 @@ async function runShell(ctxName, ctx) {
     break;
   }
   const rest = args.slice(i);
-  if (command === void 0 && !readStdin2 && rest.length > 0) {
+  if (command === void 0 && !readStdin && rest.length > 0) {
     scriptPath = rest[0];
   }
   const positional = command !== void 0 ? rest.slice(1) : scriptPath !== void 0 ? rest.slice(1) : rest;
@@ -17803,6 +17803,143 @@ function mountContainerFs(FS, opts) {
   }
 }
 
+// src/runtime/python-syscalls.ts
+var EMPTY = new Uint8Array(0);
+function createStdinHost(ctx) {
+  let pending = EMPTY;
+  let eof = false;
+  const take = (size) => {
+    const n = Math.min(size, pending.length);
+    const out = pending.subarray(0, n);
+    pending = pending.subarray(n);
+    return out;
+  };
+  return {
+    /**
+     * Drain a non-interactive stdin up front.
+     *
+     * A pipe ends, so reading it eagerly costs nothing and leaves every read
+     * answerable without suspending — which is what keeps piped input working
+     * on hosts with no stack-switching. A terminal never ends, so priming one
+     * would hang before the program had printed its prompt.
+     */
+    async prime() {
+      if (ctx.stdin.isTTY || ctx.stdin.interactive) return;
+      try {
+        pending = await ctx.stdin.readAll();
+      } catch {
+        pending = EMPTY;
+      }
+      eof = true;
+    },
+    buffered(size) {
+      if (pending.length > 0) return take(size);
+      return eof ? EMPTY : void 0;
+    },
+    async read(size) {
+      if (pending.length > 0) return take(size);
+      if (eof) return EMPTY;
+      const chunk = await ctx.stdin.read(size);
+      if (chunk === null || chunk.length === 0) {
+        eof = true;
+        return EMPTY;
+      }
+      pending = chunk;
+      return take(size);
+    },
+    isatty() {
+      return Boolean(ctx.stdin.isTTY);
+    }
+  };
+}
+var BRIDGE_PY = `
+import builtins, io, sys
+import _sbx_host as _host
+from pyodide.ffi import can_run_sync, run_sync
+
+
+def _to_bytes(value):
+    if value is None:
+        return b""
+    to_bytes = getattr(value, "to_bytes", None)
+    if to_bytes is not None:
+        return to_bytes()
+    return bytes(value.to_py())
+
+
+class _SbxStdin(io.RawIOBase):
+    """The container's standard input, as a blocking raw stream."""
+
+    def readable(self):
+        return True
+
+    def fileno(self):
+        return 0
+
+    def isatty(self):
+        return bool(_host.isatty())
+
+    def readinto(self, target):
+        want = len(target)
+        if want == 0:
+            return 0
+        ready = _host.buffered(want)
+        if ready is None:
+            if not can_run_sync():
+                raise OSError(
+                    "this host cannot wait for interactive input: WebAssembly "
+                    "stack switching (JSPI) is unavailable. Pipe the input in, "
+                    "or use a browser or Node build that supports it."
+                )
+            ready = run_sync(_host.read(want))
+        data = _to_bytes(ready)
+        target[: len(data)] = data
+        return len(data)
+
+
+def _install():
+    stdin = io.TextIOWrapper(
+        io.BufferedReader(_SbxStdin()), encoding="utf-8", errors="replace", line_buffering=True
+    )
+    sys.stdin = stdin
+    sys.__stdin__ = stdin
+
+    def input(prompt=""):
+        # CPython writes the prompt to stdout and strips exactly one trailing
+        # newline; anything else changes what a program reads back.
+        if prompt != "":
+            sys.stdout.write(str(prompt))
+            sys.stdout.flush()
+        line = sys.stdin.readline()
+        if not line:
+            raise EOFError("EOF when reading a line")
+        if line.endswith("\\n"):
+            line = line[:-1]
+        if line.endswith("\\r"):
+            line = line[:-1]
+        return line
+
+    builtins.input = input
+
+
+_install()
+`;
+function installSyscallBridge(py) {
+  const slot = py.__sbxStdin ??= { active: null };
+  py.registerJsModule("_sbx_host", {
+    /* Not `?.` and `??`: `buffered` returns undefined to mean "you will have
+     * to wait", and a nullish default would quietly turn that into end-of-file —
+     * which is exactly the silent EOF this bridge exists to remove. */
+    buffered: (size) => slot.active ? slot.active.buffered(size) : EMPTY,
+    read: (size) => slot.active ? slot.active.read(size) : Promise.resolve(EMPTY),
+    isatty: () => slot.active?.isatty() ?? false
+  });
+  py.runPython(BRIDGE_PY);
+}
+function bindStdin(py, host2) {
+  py.__sbxStdin.active = host2;
+}
+
 // src/runtime/cpython.ts
 var RESERVED_FOR_INTERPRETER = /* @__PURE__ */ new Set(["lib", "dev", "proc"]);
 var pyodideModule = null;
@@ -17875,6 +18012,7 @@ async function interpreterFor(ctx) {
     });
     mountContainerDirs(py, ctx);
     installRunner(py);
+    installSyscallBridge(py);
     return py;
   })();
   interpreters.set(ctx.vfs, starting);
@@ -17969,7 +18107,7 @@ function reportError(ctx, error) {
 `);
   return 1;
 }
-async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
+async function runCPythonProgram(ctx, source, argv, scriptDir = null) {
   let py;
   try {
     py = await interpreterFor(ctx);
@@ -17990,7 +18128,6 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
     });
   } catch {
   }
-  const encoder8 = new TextEncoder();
   const decoder8 = new TextDecoder();
   py.setStdout({
     write: (buffer) => {
@@ -18004,20 +18141,17 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
       return buffer.length;
     }
   });
-  if (stdinText !== null) {
-    const bytes2 = encoder8.encode(stdinText);
-    let offset = 0;
-    py.setStdin({
-      read: (buffer) => {
-        const take = Math.min(buffer.length, bytes2.length - offset);
-        buffer.set(bytes2.subarray(offset, offset + take));
-        offset += take;
-        return take;
-      }
-    });
-  } else {
-    py.setStdin({ read: () => 0 });
-  }
+  const stdinHost = createStdinHost(ctx);
+  await stdinHost.prime();
+  bindStdin(py, stdinHost);
+  py.setStdin({
+    read: (buffer) => {
+      const ready = stdinHost.buffered(buffer.length);
+      if (!ready || ready.length === 0) return 0;
+      buffer.set(ready);
+      return ready.length;
+    }
+  });
   try {
     bootstrap(py, ctx, argv, scriptDir);
   } catch (error) {
@@ -18150,11 +18284,6 @@ function configurePython(options = {}) {
   configureCPython({ indexURL: options.indexURL, moduleURL: options.pyodideURL });
 }
 var isPythonAvailable = isCPythonAvailable;
-async function readStdin(ctx) {
-  if (ctx.stdin.isTTY || ctx.stdin.interactive) return null;
-  const bytes2 = await ctx.stdin.readAll();
-  return bytes2.length ? new TextDecoder().decode(bytes2) : null;
-}
 var python = defineCommand({
   name: "python3",
   path: "/usr/bin/python3",
@@ -18203,7 +18332,7 @@ compatible packages can be installed with pip (micropip).`,
     }
     const rest = argv.slice(i);
     if (command !== void 0) {
-      return (await runCPythonProgram(ctx, command, ["-c", ...rest], null, await readStdin(ctx))).exitCode;
+      return (await runCPythonProgram(ctx, command, ["-c", ...rest], null)).exitCode;
     }
     if (moduleName !== void 0) {
       const program = `
@@ -18215,16 +18344,16 @@ except ImportError:
     print("/usr/bin/python3: No module named " + ${JSON.stringify(moduleName)}, file=sys.stderr)
     raise SystemExit(1)
 `;
-      return (await runCPythonProgram(ctx, program, [moduleName, ...rest], null, await readStdin(ctx))).exitCode;
+      return (await runCPythonProgram(ctx, program, [moduleName, ...rest], null)).exitCode;
     }
     if (script === void 0) {
       if (ctx.stdin.isTTY) return runCPythonRepl(ctx);
       const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return source2.trim() ? (await runCPythonProgram(ctx, source2, ["", ...rest], null, null)).exitCode : 0;
+      return source2.trim() ? (await runCPythonProgram(ctx, source2, ["", ...rest])).exitCode : 0;
     }
     if (script === "-") {
       const source2 = new TextDecoder().decode(await ctx.stdin.readAll());
-      return (await runCPythonProgram(ctx, source2, ["-", ...rest], null, null)).exitCode;
+      return (await runCPythonProgram(ctx, source2, ["-", ...rest])).exitCode;
     }
     const abs = ctx.path(script);
     let source;
@@ -18235,7 +18364,7 @@ except ImportError:
 `);
       return 2;
     }
-    return (await runCPythonProgram(ctx, source, [abs, ...rest], dirname(abs), await readStdin(ctx))).exitCode;
+    return (await runCPythonProgram(ctx, source, [abs, ...rest], dirname(abs))).exitCode;
   }
 });
 function printHelp2(ctx) {