sandboxedjs 0.1.72 → 0.1.73

package/README.md

@@ -22,6 +22,27 @@ await box.exec("python3 -c 'print(2**64)'"); // → 18446744073709551616
 box.dispose();
 ```
 
+## Python packages with compiled extensions
+
+`pip install` works for packages with C, Cython, Rust or Meson extensions. A
+wheel built for this runtime is used when one exists; otherwise one is built
+from source, from a recipe generated out of what PyPI and the package already
+state.
+
+```js
+configurePython({ buildFromSource: true });                          // build here (Node)
+configurePython({ buildFromSource: "http://localhost:4180/build" }); // ask a builder
+```
+
+Browsers have no compiler, so they ask a machine that does:
+
+```bash
+npx sandboxedjs-build-wheels 4180
+```
+
+See `docs/python/build-on-miss.md`, and `docs/python/compatibility.md` for what
+has been built and tested.
+
 ## Why
 
 Sometimes you need to run untrusted or generated code, give an AI agent a shell, build a

package/bin/sandboxedjs-build-wheels.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * A wheel index that builds what it does not have.
+ *
+ * A browser cannot compile a C extension and never will, so "build it from
+ * source" there can only mean "ask a machine that can". This is that machine,
+ * reduced to the smallest thing that works: it serves the wheel index over
+ * HTTP, and it builds a package on request using the same pipeline and the
+ * same ABI contract as everything else.
+ *
+ *   sandboxedjs-build-wheels [port=4180]
+ *
+ * Point a host at it:
+ *
+ *   configurePython({
+ *     wheelIndex: "http://localhost:4180",
+ *     buildFromSource: "http://localhost:4180/build",
+ *   });
+ *
+ * It binds loopback only. Building runs a package's own build system, which is
+ * arbitrary code execution by design, so exposing this to a network would be
+ * handing that to whoever can reach it.
+ */
+
+import { createServer } from "node:http";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../python-runtime");
+const wheels = join(root, "out/wheels");
+
+if (!existsSync(join(root, "scripts/build_extension.py"))) {
+  console.error("sandboxedjs-build-wheels: the build pipeline is only present in a checkout");
+  process.exit(1);
+}
+
+const port = Number(process.argv[2] ?? 4180);
+const building = new Map();
+const finished = new Map();
+
+const run = (args) => new Promise((done) => {
+  const child = spawn("python3", args, { cwd: root });
+  let stdout = "", stderr = "";
+  child.stdout.on("data", (c) => { stdout += String(c); });
+  child.stderr.on("data", (c) => { stderr += String(c); });
+  child.on("error", (e) => done({ code: -1, stdout, stderr: String(e) }));
+  child.on("close", (code) => done({ code: code ?? -1, stdout, stderr }));
+});
+
+async function build(requirement) {
+  const recipe = await run(["scripts/auto_recipe.py", requirement]);
+  if (recipe.code !== 0) {
+    let reported = {};
+    try { reported = JSON.parse(recipe.stdout.trim().split("\n").at(-1) ?? "{}"); } catch {}
+    return {
+      built: false,
+      classification: reported.classification ?? "blocked-toolchain",
+      reason: reported.reason ?? recipe.stderr.trim().slice(-400),
+    };
+  }
+  const path = recipe.stdout.trim().split("\n").at(-1);
+  const made = await run(["scripts/build_extension.py", path]);
+  if (made.code !== 0) {
+    return {
+      built: false, classification: "blocked-toolchain",
+      reason: `${made.stdout}\n${made.stderr}`.trim().split("\n").slice(-12).join("\n"),
+    };
+  }
+  const indexed = await run(["scripts/build_index.py"]);
+  if (indexed.code !== 0) {
+    return { built: false, classification: "blocked-toolchain", reason: indexed.stderr.slice(-300) };
+  }
+  return { built: true, classification: "supported-generic" };
+}
+
+const server = createServer(async (request, response) => {
+  const cors = {
+    "access-control-allow-origin": request.headers.origin ?? "*",
+    "access-control-allow-headers": "content-type",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+  };
+  if (request.method === "OPTIONS") { response.writeHead(204, cors).end(); return; }
+
+  const path = decodeURIComponent(new URL(request.url ?? "/", "http://localhost").pathname);
+
+  if (request.method === "POST" && path === "/build") {
+    const body = await new Promise((done) => {
+      let text = ""; request.on("data", (c) => { text += c; }); request.on("end", () => done(text));
+    });
+    let requirement = "";
+    try { requirement = String(JSON.parse(body || "{}").requirement ?? ""); } catch {}
+    /* Only a package name and optional pin. Anything else would be handed to a
+     * shell-adjacent build as an argument. */
+    if (!/^[A-Za-z0-9._-]+(==[A-Za-z0-9._+-]+)?$/.test(requirement)) {
+      response.writeHead(400, { ...cors, "content-type": "application/json" })
+        .end(JSON.stringify({ built: false, reason: "invalid requirement" }));
+      return;
+    }
+    /* Submit and poll, never one long request. A build takes minutes and an
+     * HTTP client -- especially one inside a sandboxed worker -- will drop a
+     * connection held open that long, which looks to the caller like the
+     * service being unreachable while it is in fact working. This is why the
+     * protocol in docs/python/build-on-miss.md has states rather than a single
+     * blocking call.
+     *
+     * One build per package: two identical requests are the same build. */
+    if (!building.has(requirement) && !finished.has(requirement)) {
+      console.log(`building ${requirement}`);
+      building.set(requirement, build(requirement).then((verdict) => {
+        console.log(`  ${requirement}: ${verdict.built ? "built" : verdict.classification}`);
+        finished.set(requirement, verdict);
+        building.delete(requirement);
+        return verdict;
+      }));
+    }
+    const done = finished.get(requirement);
+    const verdict = done
+      ? { ...done, state: done.built ? "published" : "failed" }
+      : { state: "building-wheel" };
+    response.writeHead(200, { ...cors, "content-type": "application/json" })
+      .end(JSON.stringify(verdict));
+    return;
+  }
+
+  const name = path === "/" ? "/index.json" : path;
+  const file = join(wheels, name);
+  if (!file.startsWith(wheels) || !existsSync(file)) {
+    response.writeHead(404, cors).end("not found");
+    return;
+  }
+  response.writeHead(200, {
+    ...cors,
+    "content-type": name.endsWith(".json") ? "application/json" : "application/octet-stream",
+  }).end(readFileSync(file));
+});
+
+server.listen(port, "127.0.0.1", () => {
+  console.log(`SandboxedJs wheel builder: http://127.0.0.1:${port}`);
+  console.log(`  index  http://127.0.0.1:${port}/index.json`);
+  console.log(`  build  POST http://127.0.0.1:${port}/build  {"requirement":"numpy"}`);
+});

package/dist/agent.d.cts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-BwXE2J26.cjs';
+import { C as Container } from './container-BxEoVOmX.cjs';
 import './contracts-CVgctitO.cjs';
 
 /**

package/dist/agent.d.ts

@@ -1,4 +1,4 @@
-import { C as Container } from './container-WPf_A76-.js';
+import { C as Container } from './container-B5X6stfx.js';
 import './contracts-CVgctitO.js';
 
 /**

package/dist/{container-WPf_A76-.d.ts → container-B5X6stfx.d.ts}

@@ -1238,6 +1238,14 @@ interface PythonOptions {
      * no published wheel targets wasm32-emscripten.
      */
     wheelIndex?: WheelIndex | string | null;
+    /**
+     * Build a missing wheel instead of reporting it.
+     *
+     * `true` builds locally, which needs Node and the build pipeline. A URL asks
+     * a build service -- which is how a browser gets a wheel built, having no
+     * compiler of its own. See docs/python/build-on-miss.md.
+     */
+    buildFromSource?: boolean | string;
 }
 declare function configurePython(options?: PythonOptions): void;
 declare const isPythonAvailable: typeof isCPythonAvailable;

package/dist/{container-BwXE2J26.d.cts → container-BxEoVOmX.d.cts}

@@ -1238,6 +1238,14 @@ interface PythonOptions {
      * no published wheel targets wasm32-emscripten.
      */
     wheelIndex?: WheelIndex | string | null;
+    /**
+     * Build a missing wheel instead of reporting it.
+     *
+     * `true` builds locally, which needs Node and the build pipeline. A URL asks
+     * a build service -- which is how a browser gets a wheel built, having no
+     * compiler of its own. See docs/python/build-on-miss.md.
+     */
+    buildFromSource?: boolean | string;
 }
 declare function configurePython(options?: PythonOptions): void;
 declare const isPythonAvailable: typeof isCPythonAvailable;