~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
196 lines · 10.6 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

import { connect, frameSrcdoc, policyEngineStatus, probe, rewriteNodeImports, runInWorker } from "./policy_sandbox.js";

Deno.test("a throwing program prints no data: URL and none of its source", async () => {
  // review page-rc134 F1: the program is a data: URL of its whole source
  const r = await run(`const secret = "ghp_SECRET123"; JSON.parse("{bad");`);
  eq(r.exitCode, 1, "throws");
  eq(r.stderr.includes("data:"), false, `no data: URL in stderr: ${r.stderr.slice(0, 200)}`);
  eq(r.stderr.includes("SECRET123") || r.stderr.includes("ghp_"), false, "no source text in stderr");
  eq(r.stderr.includes("SyntaxError"), true, "the error itself is kept");
});

Deno.test("the scrub removes a whole data: URL, ( ) and ' included", async () => {
  // what an engine that ignores sourceURL would print
  const r = await run(`console.error("at data:text/javascript," + encodeURIComponent("f(x); g('ghp_SECRET123')") + ":1:2 next");`);
  eq(r.stderr, "at policy-program.js next\n", "scrubbed to the next space");
});

Deno.test("the node: rewrite stays linear and leaves spliced data alone", async () => {
  // review page-rc134 F2/F4: hostile spliced JSON must not stall the frame or match
  const hostile = "const data = " + JSON.stringify("import { ".repeat(40_000) + " x from 'node:crypto' import 'node:fs'") + ";";
  const t0 = performance.now();
  const out = rewriteNodeImports(hostile);
  const ms = performance.now() - t0;
  eq(ms < 200, true, `rewrite took ${ms.toFixed(0)} ms`);
  eq(out, hostile, "string data is not rewritten");
  // export forms (F3)
  const ex = rewriteNodeImports(`export { Buffer as B } from "node:buffer";\nexport * from "node:crypto";`);
  eq(ex.includes(`const { Buffer: B } = await import("data:text/javascript,`), true, "export named");
  eq(ex.includes("export { B };"), true, "re-export binding");
  eq(ex.includes(`is not supported in the browser policy sandbox`), true, "export * fails clearly");
});

function assert(cond, message) {
  if (!cond) throw new Error(message);
}
const eq = (a, b, what) => assert(JSON.stringify(a) === JSON.stringify(b), `${what}: ${JSON.stringify(a)} != ${JSON.stringify(b)}`);

const run = (source, extra = {}) => runInWorker({ source, env: {}, timeoutMs: 10_000, ...extra });

// The shape socialweb's expression evaluator generates (expression.go).
Deno.test("expression program prints its value on stdout", async () => {
  const r = await run(`console.log(String((() => {
const inputs = {"mode":"scope"};
return (inputs['mode'] === "scope");
})()))`);
  eq([r.exitCode, r.stdout, r.stderr, r.timedOut], [0, "true\n", "", false], "result");
});

// The parts of socialweb's action shim (action.go actionShim) that touch Deno.
Deno.test("action shim: env override, virtual files, exit, result marker", async () => {
  const r = await run(`const __pe_env = {"GITHUB_OUTPUT":"/gh/out","NAME":"x"};
const __pe_vfs = {};
const __pe_realExit = Deno.exit.bind(Deno);
const __pe_originalWriteTextFileSync = Deno.writeTextFileSync.bind(Deno);
Object.defineProperty(Deno, "env", { configurable: true, value: { get: (k) => __pe_env[k] } });
Deno.writeTextFileSync = (path, data) => {
  if (path === __pe_env.GITHUB_OUTPUT) { __pe_vfs[path] = data; return; }
  return __pe_originalWriteTextFileSync(path, data);
};
const enc = new TextEncoder();
for (const m of ["log", "error"]) console[m] = (...a) => Deno.stderr.writeSync(enc.encode(a.map((v) => typeof v === "string" ? v : Deno.inspect(v)).join(" ") + "\\n"));
class PeExit extends Error { constructor(code) { super("exit"); this.code = code; } }
Deno.exit = (code = 0) => { throw new PeExit(code); };
globalThis.addEventListener("unhandledrejection", (event) => {
  event.preventDefault();
  Deno.stdout.writeSync(enc.encode("__PE_RESULT__" + JSON.stringify({ code: event.reason.code, vfs: __pe_vfs }) + "\\n"));
  __pe_realExit(0);
});
await Promise.resolve();
Deno.writeTextFileSync("/gh/out", "allow=" + Deno.env.get("NAME"));
console.log({ seen: true });
await (async () => { Deno.exit(3); })();
`);
  eq(r.exitCode, 0, "exit");
  eq(r.stdout, `__PE_RESULT__{"code":3,"vfs":{"/gh/out":"allow=x"}}\n`, "stdout");
  eq(r.stderr, `{"seen":true}\n`, "stderr");
});

Deno.test("no filesystem: read fails like deno without --allow-read", async () => {
  const r = await run(`try { Deno.readTextFileSync("/etc/hosts"); console.log("READ"); } catch (e) { console.log(e.name); }
await Deno.readTextFile("/etc/hosts");`);
  eq(r.exitCode, 1, "exit");
  eq(r.stdout, "NotCapable\n", "stdout");
  assert(r.stderr.includes("--allow-read"), r.stderr);
});

Deno.test("uncaught error exits 1 with output kept", async () => {
  const r = await run(`console.log("before"); throw new Error("boom");`);
  eq(r.exitCode, 1, "exit");
  assert(r.stderr.includes("boom"), r.stderr);
});

Deno.test("output is capped at 64 KiB per stream", async () => {
  const r = await run(`for (let i = 0; i < 2000; i++) console.log("x".repeat(100));`);
  eq(r.stdout.length, 64 << 10, "stdout length");
});

Deno.test("an endless program is killed at its deadline and the next run works", async () => {
  const r = await run("for (;;) {}", { timeoutMs: 300 });
  eq([r.exitCode, r.timedOut], [-1, true], "endless");
  const again = await run(`console.log("ok")`);
  eq(again.stdout, "ok\n", "again");
});

Deno.test("kill ends a run early", async () => {
  const pending = run("await new Promise(() => {});", { timeoutMs: 60_000 });
  pending.kill();
  eq((await pending).timedOut, true, "killed");
});

Deno.test("node: imports of the bundled actions resolve to shims", async () => {
  // WebKit denies static data: imports in the Worker: every form becomes a top-level await
  const forms = rewriteNodeImports(`import x from "node:crypto";
import { a, b as c } from 'node:buffer';
import d, { e } from "node:crypto";
import * as ns from "node:dns/promises";
import "node:buffer";
const m = await import("node:crypto");
import { y } from "./not-node.js";`);
  eq(/\bimport\s[^(]*\bfrom\s*["']data:/.test(forms) || /\bimport\s*["']data:/.test(forms), false, "no static data: import left");
  eq(forms.includes(`const { default: x } = await import("data:text/javascript,`), true, "default");
  eq(forms.includes(`const { a, b: c } = await import("data:text/javascript,`), true, "named + as");
  eq(forms.includes(`const { default: d, e } = await import("data:text/javascript,`), true, "default + named");
  eq(forms.includes(`const ns = await import("data:text/javascript,`), true, "namespace");
  eq(/await import\("data:text\/javascript,[^"]*"\);\nconst m/.test(forms), true, "side effect");
  eq(forms.includes(`const m = await import("data:text/javascript,`), true, "dynamic");
  eq(forms.includes(`import { y } from "./not-node.js";`), true, "other specifiers untouched");
  // the bundled actions repeat aliased imports of one module (esbuild output)
  const repeated = await run(`import { Buffer as Buffer2 } from "node:buffer";
import { Buffer as Buffer3 } from "node:buffer";
import crypto from "node:crypto";
console.log(Buffer2 === Buffer3, Buffer2.from("hi").toString("utf8"), typeof crypto.randomBytes);`);
  eq([repeated.exitCode, repeated.stdout], [0, "true hi function\n"], "repeated aliased imports");
  const r = await run(`import { Buffer } from "node:buffer";
import crypto from "node:crypto";
import * as nc from "node:crypto";
import * as dns from "node:dns/promises";
const b = Buffer.concat([Buffer.from("ab"), Buffer.from(new Uint8Array([99]))]);
let txt = "resolved";
try { await dns.resolveTxt("_atproto.example.com"); } catch (e) { txt = e.code; }
console.log(b.toString("utf8"), b.length, "webcrypto" in nc, typeof crypto.createHash, crypto.randomBytes(4).length, txt);`);
  eq([r.exitCode, r.stdout], [0, "abc 3 true function 4 ENOTFOUND\n"], "shims");
  const missing = await run(`import fs from "node:fs"; console.log("loaded");`);
  eq(missing.exitCode, 1, "unknown node module fails");
});

Deno.test("frame srcdoc is a sandboxed relay with a CSP", () => {
  const html = frameSrcdoc();
  assert(html.includes(`http-equiv="Content-Security-Policy"`), "csp");
  assert(html.includes("relay(65536)"), "relay call");
  assert(!html.slice(0, -"</script>".length).includes("</script>"), "no early script end");
});

// connect + probe against an in-process frame (MessageChannel): Deno has one
// origin, so storage is visible here and the probe must fail closed.
Deno.test("sandbox-unfenced-deny: probe fails closed when the sandbox shares the page's storage", async () => {
  const { port1, port2 } = new MessageChannel();
  port2.onmessage = async ({ data }) => {
    if (data.frame) return port2.postMessage({ id: data.id, origin: "null", parentDocument: "blocked" });
    port2.postMessage({ id: data.id, ...(await runInWorker(data)) });
  };
  const bridge = connect(port1);
  const out = JSON.parse(await bridge.probe());
  port1.close();
  port2.close();
  eq(out.fenced, false, `fenced (${out.message})`);
  assert(/origin=\S+ /.test(out.message) && out.message.includes("timeout=killed") && out.message.includes("rerun=ok"), out.message);
});

Deno.test("probe passes on the facts of a fenced sandbox", async () => {
  const fenced = { origin: "null", shim: "ok", dom: "none", idb: "denied:SecurityError", cache: "denied:SecurityError", opfs: "denied:SecurityError" };
  const out = await probe({
    run: async ({ source, timeoutMs }) => {
      if (source.startsWith("for")) return { exitCode: -1, stdout: "", stderr: "", timedOut: timeoutMs > 0 };
      if (source.includes("console.log(\"ok\")")) return { exitCode: 0, stdout: "ok\n", stderr: "", timedOut: false };
      return { exitCode: 0, stdout: JSON.stringify(fenced) + "\n", stderr: "", timedOut: false };
    },
    frame: async () => ({ origin: "null", parentDocument: "blocked" }),
  });
  eq(out.fenced, true, `fenced (${out.message})`);
});

Deno.test("policy sandbox line: probing, fenced and ready, not fenced with a reason", () => {
  eq(policyEngineStatus(undefined), { text: "", className: "" }, "no engine");
  eq(policyEngineStatus({ name: "policy-engine", phase: "Pending" }),
    { text: "policy sandbox: probing...", className: "warn" }, "before the probe");
  eq(policyEngineStatus({ name: "policy-engine", fenced: "True", ready: true, message: "ProbePassed: origin=null" }),
    { text: "policy sandbox: fenced, ready (ProbePassed: origin=null)", className: "ok" }, "fenced and ready");
  eq(policyEngineStatus({ name: "policy-engine", fenced: "False", message: "ProbeFailed: program=exit=1" }),
    { text: "policy sandbox: not fenced (ProbeFailed: program=exit=1)", className: "warn" }, "not fenced");
  eq(policyEngineStatus({ name: "policy-engine", message: "CreateFailed: no bridge" }).text,
    "policy sandbox: not fenced (CreateFailed: no bridge)", "a reason without Fenced");
});