0sec-cli 0.21.4 → 0.22.1

package/chunks/chunk-WF5W75WY.js

@@ -1,1070 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __0CreateRequire } from "node:module";
-const require = __0CreateRequire(import.meta.url);
-import {
-  allowlistedChildEnv
-} from "./chunk-QZVG3BG4.js";
-import {
-  VERSION
-} from "./chunk-PC6RCKQV.js";
-
-// packages/core/dist/verify/replay-runner.js
-import { spawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync, mkdtempSync, writeFileSync, existsSync, statSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve, isAbsolute, posix, win32 } from "node:path";
-import { arch as nodeArch, platform as nodePlatform } from "node:process";
-import { gzipSync } from "node:zlib";
-var STREAM_EXCERPT_BYTES = 8 * 1024;
-var DEFAULT_STEP_TIMEOUT_MS = 3e4;
-var MAX_STREAM_CAPTURE_BYTES = 1 * 1024 * 1024;
-var promiseWithResolvers = Promise;
-var LocalShellRunner = class {
-  kind = "local";
-  async exec(step, ctx) {
-    const start = Date.now();
-    if (step.action.type !== "shell") {
-      return {
-        argv: argvForStep(step),
-        exitCode: null,
-        stdoutFull: "",
-        stderrFull: "",
-        durationMs: Date.now() - start,
-        launchError: `LocalShellRunner only executes shell steps; got '${step.action.type}'`
-      };
-    }
-    const cmd = step.action.cmd;
-    const stepCwd = step.action.cwd ? resolveStepCwd(step.action.cwd, ctx.runDir) : ctx.runDir;
-    return new Promise((resolveP) => {
-      const argv = ["/bin/sh", "-c", cmd];
-      let stdout = "";
-      let stderr = "";
-      let stdoutBytes = 0;
-      let stderrBytes = 0;
-      let timedOut = false;
-      let settled = false;
-      let child;
-      try {
-        child = spawn("/bin/sh", ["-c", cmd], {
-          cwd: stepCwd,
-          // `cmd` is a PoC-authored shell step (model/target-derived), so this
-          // child must not inherit the harness's provider/cloud credentials.
-          // Build from the allowlist (PATH/HOME/TMPDIR + target-auth vars a
-          // reproduction legitimately needs) rather than copying process.env.
-          env: allowlistedChildEnv({ "ZERO_VERIFY": "1" }),
-          stdio: ["ignore", "pipe", "pipe"],
-          // On POSIX, isolate the shell and all descendants into a process
-          // group so a timeout cannot leave a grandchild holding stdout open.
-          detached: nodePlatform !== "win32"
-        });
-      } catch (err) {
-        resolveP({
-          argv,
-          exitCode: null,
-          stdoutFull: "",
-          stderrFull: "",
-          durationMs: Date.now() - start,
-          launchError: err instanceof Error ? err.message : String(err)
-        });
-        return;
-      }
-      const timer = setTimeout(() => {
-        timedOut = true;
-        try {
-          if (nodePlatform !== "win32" && child.pid) {
-            process.kill(-child.pid, "SIGKILL");
-          } else {
-            child.kill("SIGKILL");
-          }
-        } catch {
-        }
-      }, ctx.stepTimeoutMs);
-      child.stdout?.on("data", (chunk) => {
-        if (stdoutBytes >= MAX_STREAM_CAPTURE_BYTES)
-          return;
-        const remaining = MAX_STREAM_CAPTURE_BYTES - stdoutBytes;
-        const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-        stdout += slice.toString("utf8");
-        stdoutBytes += slice.length;
-      });
-      child.stderr?.on("data", (chunk) => {
-        if (stderrBytes >= MAX_STREAM_CAPTURE_BYTES)
-          return;
-        const remaining = MAX_STREAM_CAPTURE_BYTES - stderrBytes;
-        const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-        stderr += slice.toString("utf8");
-        stderrBytes += slice.length;
-      });
-      child.on("error", (err) => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        resolveP({
-          argv,
-          exitCode: null,
-          stdoutFull: stdout,
-          stderrFull: stderr,
-          durationMs: Date.now() - start,
-          launchError: err.message
-        });
-      });
-      child.on("close", (code) => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        resolveP({
-          argv,
-          exitCode: typeof code === "number" ? code : null,
-          stdoutFull: stdout,
-          stderrFull: stderr,
-          durationMs: Date.now() - start,
-          timedOut
-        });
-      });
-    });
-  }
-};
-function resolveStepCwd(cwd, runDir) {
-  if (isAbsolute(cwd)) {
-    return runDir;
-  }
-  const resolved = resolve(runDir, cwd);
-  if (!resolved.startsWith(runDir))
-    return runDir;
-  return resolved;
-}
-var DEFAULT_DOCKER_SHELL_IMAGE = "alpine:3.20";
-var DEFAULT_DOCKER_HTTP_IMAGE = "curlimages/curl:8.12.1";
-var DOCKER_HTTP_STATUS_MARKER = "\n__ZERO_HTTP_STATUS__:";
-var CONTAINER_ID_RE = /^[a-f0-9]{12,64}$/i;
-var DOCKER_NETWORK_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
-var DockerRunner = class {
-  kind = "docker";
-  dockerBinary;
-  shellImage;
-  httpImage;
-  network;
-  memoryMb;
-  pidsLimit;
-  cpus;
-  constructor(options = {}) {
-    this.dockerBinary = options.dockerBinary ?? "docker";
-    this.shellImage = options.shellImage ?? DEFAULT_DOCKER_SHELL_IMAGE;
-    this.httpImage = options.httpImage ?? DEFAULT_DOCKER_HTTP_IMAGE;
-    this.network = options.network ?? "none";
-    this.memoryMb = options.memoryMb ?? 256;
-    this.pidsLimit = options.pidsLimit ?? 128;
-    this.cpus = options.cpus ?? 1;
-    if (!this.dockerBinary || !this.shellImage || !this.httpImage || !Number.isInteger(this.memoryMb) || this.memoryMb < 16 || !Number.isInteger(this.pidsLimit) || this.pidsLimit < 1 || !Number.isFinite(this.cpus) || this.cpus <= 0) {
-      throw new Error("invalid DockerRunner configuration");
-    }
-    if (this.network !== "none" && this.network !== "bridge" && (!DOCKER_NETWORK_RE.test(this.network) || this.network === "host")) {
-      throw new Error("DockerRunner network must be none, bridge, or a simple custom network name (host is refused)");
-    }
-  }
-  async exec(step, ctx) {
-    const startedAt = Date.now();
-    const preflightError = this.networkPreflight(step, ctx.scope);
-    if (preflightError) {
-      return failedStep(step, startedAt, preflightError);
-    }
-    const command = this.commandForStep(step, ctx.stepTimeoutMs);
-    if (typeof command === "string") {
-      return failedStep(step, startedAt, command);
-    }
-    const safeStepId = step.id.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 64) || "step";
-    const cidPath = join(ctx.runDir, `.0-docker-${safeStepId}-${randomUUID()}.cid`);
-    const args = this.dockerRunArgs(command, ctx.runDir, cidPath);
-    const result = await runDockerCommand({
-      dockerBinary: this.dockerBinary,
-      args,
-      runDir: ctx.runDir,
-      cidPath,
-      stepTimeoutMs: ctx.stepTimeoutMs
-    });
-    if (!command.parseHttpStatus)
-      return result;
-    const parsed = parseDockerHttpStatus(result.stdoutFull);
-    return {
-      ...result,
-      stdoutFull: parsed.stdout,
-      ...parsed.httpStatus === void 0 ? {} : { httpStatus: parsed.httpStatus }
-    };
-  }
-  networkPreflight(step, scope) {
-    if (this.network === "none")
-      return void 0;
-    if (step.action.type !== "http") {
-      return "networked Docker replay only permits declarative HTTP steps; shell and docker actions always run with network=none";
-    }
-    let parsed;
-    try {
-      parsed = new URL(step.action.url);
-    } catch {
-      return `invalid HTTP replay URL: ${step.action.url}`;
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      return `Docker HTTP replay only permits http(s) URLs, got ${parsed.protocol}`;
-    }
-    if (!scope) {
-      return "networked Docker replay requires an explicit engagement scope";
-    }
-    const scopeMatch = scope.match(step.action.url);
-    return scopeMatch.allowed ? void 0 : `Docker replay refused ${step.action.url}: ${scopeMatch.reason}`;
-  }
-  commandForStep(step, stepTimeoutMs) {
-    switch (step.action.type) {
-      case "shell": {
-        const cwd = step.action.cwd ?? ".";
-        const workdir = posix.resolve("/work", cwd);
-        if (isAbsolute(cwd) || win32.isAbsolute(cwd) || /[\\\0]/.test(cwd) || workdir !== "/work" && !workdir.startsWith("/work/")) {
-          return "Docker shell cwd must be relative and remain inside the replay workspace";
-        }
-        return {
-          image: this.shellImage,
-          command: ["/bin/sh", "-lc", step.action.cmd],
-          parseHttpStatus: false,
-          workdir
-        };
-      }
-      case "docker":
-        if (!step.action.image.trim())
-          return "Docker action is missing an image";
-        if (step.action.image.trimStart().startsWith("-"))
-          return "Docker image must not be a command-line option";
-        return {
-          image: step.action.image,
-          // These arguments come after the image and therefore cannot alter
-          // Docker's hardening flags (for example, they cannot add --privileged).
-          command: step.action.args,
-          parseHttpStatus: false
-        };
-      case "http": {
-        const method = step.action.method.trim().toUpperCase();
-        if (!/^[A-Z]+$/.test(method)) {
-          return `invalid HTTP method for Docker replay: ${step.action.method}`;
-        }
-        const headers = Object.entries(step.action.headers ?? {});
-        if (headers.some(([name, value]) => !name.trim() || /[\r\n]/.test(name) || /[\r\n]/.test(value))) {
-          return "HTTP replay headers must be non-empty single-line values";
-        }
-        const command = [
-          "--silent",
-          "--show-error",
-          "--request",
-          method,
-          "--max-time",
-          String(Math.max(1, Math.ceil(stepTimeoutMs / 1e3))),
-          "--output",
-          "-",
-          "--write-out",
-          `${DOCKER_HTTP_STATUS_MARKER}%{http_code}
-`
-        ];
-        for (const [name, value] of headers) {
-          command.push("--header", `${name}: ${value}`);
-        }
-        if (step.action.body !== void 0) {
-          command.push("--data-binary", step.action.body);
-        }
-        command.push(step.action.url);
-        return {
-          image: this.httpImage,
-          dockerOptions: ["--entrypoint", "curl"],
-          command,
-          parseHttpStatus: true
-        };
-      }
-      case "note":
-        return `DockerRunner only executes shell, docker, and http steps; got '${step.action.type}'`;
-      default: {
-        const _exhaustive = step.action;
-        void _exhaustive;
-        return "unsupported Docker replay action";
-      }
-    }
-  }
-  dockerRunArgs(command, runDir, cidPath) {
-    const args = [
-      "run",
-      "--rm",
-      "--pull",
-      "never",
-      "--init",
-      "--read-only",
-      "--cap-drop",
-      "ALL",
-      "--security-opt",
-      "no-new-privileges:true",
-      "--pids-limit",
-      String(this.pidsLimit),
-      "--memory",
-      `${this.memoryMb}m`,
-      "--cpus",
-      String(this.cpus),
-      "--network",
-      this.network,
-      "--workdir",
-      command.workdir ?? "/work",
-      "--tmpfs",
-      "/tmp:rw,noexec,nosuid,size=64m",
-      "--mount",
-      `type=bind,src=${resolve(runDir)},dst=/work`,
-      "--cidfile",
-      cidPath,
-      ...command.dockerOptions ?? []
-    ];
-    if (typeof process.getuid === "function" && typeof process.getgid === "function") {
-      args.push("--user", `${process.getuid()}:${process.getgid()}`);
-    }
-    args.push("--", command.image, ...command.command);
-    return args;
-  }
-};
-function failedStep(step, startedAt, launchError) {
-  return {
-    argv: argvForStep(step),
-    exitCode: null,
-    stdoutFull: "",
-    stderrFull: "",
-    durationMs: Date.now() - startedAt,
-    launchError
-  };
-}
-function parseDockerHttpStatus(stdout) {
-  const markerIndex = stdout.lastIndexOf(DOCKER_HTTP_STATUS_MARKER);
-  if (markerIndex === -1)
-    return { stdout };
-  const status = /^(\d{3})\r?\n?$/.exec(stdout.slice(markerIndex + DOCKER_HTTP_STATUS_MARKER.length));
-  if (!status)
-    return { stdout };
-  return {
-    stdout: stdout.slice(0, markerIndex),
-    httpStatus: Number(status[1])
-  };
-}
-async function runDockerCommand(args) {
-  const startedAt = Date.now();
-  const { promise, resolve: resolveResult } = promiseWithResolvers.withResolvers();
-  let timer;
-  const argv = [args.dockerBinary, ...args.args];
-  let stdout = "";
-  let stderr = "";
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-  let timedOut = false;
-  let settled = false;
-  let timeoutCleanup;
-  let child;
-  const finish = async (exitCode, launchError) => {
-    if (settled)
-      return;
-    settled = true;
-    clearTimeout(timer);
-    if (timeoutCleanup)
-      await timeoutCleanup;
-    const containerStarted = existsSync(args.cidPath);
-    rmSync(args.cidPath, { force: true });
-    const startError = launchError ?? (exitCode !== 0 && !timedOut && !containerStarted ? `Docker sandbox did not start (exit ${exitCode ?? "unknown"}): ${excerpt(stderr, 512)}` : void 0);
-    resolveResult({
-      argv,
-      exitCode,
-      stdoutFull: stdout,
-      stderrFull: stderr,
-      durationMs: Date.now() - startedAt,
-      ...timedOut ? { timedOut: true } : {},
-      ...startError ? { launchError: startError } : {}
-    });
-  };
-  try {
-    child = spawn(args.dockerBinary, args.args, {
-      cwd: args.runDir,
-      env: allowlistedChildEnv({ "ZERO_VERIFY": "1" }),
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: nodePlatform !== "win32"
-    });
-  } catch (err) {
-    void finish(null, err instanceof Error ? err.message : String(err));
-    return promise;
-  }
-  timer = setTimeout(() => {
-    timedOut = true;
-    timeoutCleanup = stopDockerContainer(args.dockerBinary, args.cidPath, args.runDir).finally(() => killProcessGroup(child));
-  }, args.stepTimeoutMs);
-  child.stdout?.on("data", (chunk) => {
-    if (stdoutBytes >= MAX_STREAM_CAPTURE_BYTES)
-      return;
-    const remaining = MAX_STREAM_CAPTURE_BYTES - stdoutBytes;
-    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-    stdout += slice.toString("utf8");
-    stdoutBytes += slice.length;
-  });
-  child.stderr?.on("data", (chunk) => {
-    if (stderrBytes >= MAX_STREAM_CAPTURE_BYTES)
-      return;
-    const remaining = MAX_STREAM_CAPTURE_BYTES - stderrBytes;
-    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-    stderr += slice.toString("utf8");
-    stderrBytes += slice.length;
-  });
-  child.on("error", (err) => {
-    void finish(null, err.message);
-  });
-  child.on("close", (code) => {
-    void finish(typeof code === "number" ? code : null);
-  });
-  return promise;
-}
-async function stopDockerContainer(dockerBinary, cidPath, runDir) {
-  let containerId;
-  for (let attempt = 0; attempt < 20; attempt += 1) {
-    try {
-      const candidate = readFileSync(cidPath, "utf8").trim();
-      if (CONTAINER_ID_RE.test(candidate)) {
-        containerId = candidate;
-        break;
-      }
-    } catch {
-    }
-    const { promise, resolve: resolve2 } = promiseWithResolvers.withResolvers();
-    setTimeout(resolve2, 25);
-    await promise;
-  }
-  if (!containerId)
-    return;
-  await runDockerControl(dockerBinary, ["kill", containerId], runDir);
-  await runDockerControl(dockerBinary, ["rm", "--force", containerId], runDir);
-}
-function runDockerControl(dockerBinary, args, cwd) {
-  const { promise, resolve: resolve2 } = promiseWithResolvers.withResolvers();
-  let child;
-  try {
-    child = spawn(dockerBinary, args, {
-      cwd,
-      env: allowlistedChildEnv({ "ZERO_VERIFY": "1" }),
-      stdio: "ignore",
-      detached: nodePlatform !== "win32"
-    });
-  } catch {
-    resolve2();
-    return promise;
-  }
-  const timer = setTimeout(() => {
-    killProcessGroup(child);
-  }, 5e3);
-  child.once("error", () => {
-    clearTimeout(timer);
-    resolve2();
-  });
-  child.once("close", () => {
-    clearTimeout(timer);
-    resolve2();
-  });
-  return promise;
-}
-function killProcessGroup(child) {
-  try {
-    if (nodePlatform !== "win32" && child.pid) {
-      process.kill(-child.pid, "SIGKILL");
-    } else {
-      child.kill("SIGKILL");
-    }
-  } catch {
-  }
-}
-var QemuRunner = class {
-  kind = "qemu";
-  qemuBinary;
-  kernelImage;
-  busyboxPath;
-  memoryMb;
-  cpus;
-  constructor(options = {}) {
-    this.qemuBinary = options.qemuBinary ?? process.env["ZERO_REPLAY_QEMU_BINARY"]?.trim() ?? (nodeArch === "arm64" ? "qemu-system-aarch64" : "qemu-system-x86_64");
-    this.kernelImage = options.kernelImage ?? process.env["ZERO_REPLAY_QEMU_KERNEL"]?.trim() ?? "";
-    this.busyboxPath = options.busyboxPath ?? process.env["ZERO_REPLAY_QEMU_BUSYBOX"]?.trim() ?? "";
-    this.memoryMb = options.memoryMb ?? 512;
-    this.cpus = options.cpus ?? 1;
-    if (!this.qemuBinary || !Number.isInteger(this.memoryMb) || this.memoryMb < 128 || !Number.isInteger(this.cpus) || this.cpus < 1) {
-      throw new Error("invalid QemuRunner configuration");
-    }
-  }
-  async exec(step, ctx) {
-    const startedAt = Date.now();
-    if (!this.kernelImage || !this.busyboxPath) {
-      return failedStep(step, startedAt, "QEMU replay requires kernelImage and busyboxPath (or ZERO_REPLAY_QEMU_KERNEL and ZERO_REPLAY_QEMU_BUSYBOX)");
-    }
-    if (!existsSync(this.kernelImage) || !statSync(this.kernelImage).isFile()) {
-      return failedStep(step, startedAt, `QEMU kernel image is not a file: ${this.kernelImage}`);
-    }
-    if (!existsSync(this.busyboxPath) || !statSync(this.busyboxPath).isFile()) {
-      return failedStep(step, startedAt, `QEMU BusyBox binary is not a file: ${this.busyboxPath}`);
-    }
-    if (step.action.type !== "shell") {
-      return failedStep(step, startedAt, `QemuRunner only executes shell steps in an offline guest; got '${step.action.type}'`);
-    }
-    const guestCwd = qemuGuestWorkingDirectory(step.action.cwd);
-    if (!guestCwd) {
-      return failedStep(step, startedAt, "QEMU replay refuses an absolute step cwd");
-    }
-    const safeStepId = step.id.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 64) || "step";
-    const workspaceName = `.0-qemu-${safeStepId}-${randomUUID()}`;
-    const workspace = join(ctx.runDir, workspaceName);
-    mkdirSync(workspace, { recursive: true });
-    writeFileSync(join(workspace, "step.sh"), step.action.cmd, "utf8");
-    const initrdPath = buildQemuInitramfs({
-      runDir: ctx.runDir,
-      busyboxPath: this.busyboxPath,
-      workspaceName,
-      guestCwd
-    });
-    const args = this.qemuArgs(ctx.runDir, initrdPath);
-    const qemu = await runQemuCommand({
-      qemuBinary: this.qemuBinary,
-      args,
-      runDir: ctx.runDir,
-      stepTimeoutMs: ctx.stepTimeoutMs
-    });
-    const stdout = readQemuCapture(join(workspace, "stdout.log"));
-    const guestStderr = readQemuCapture(join(workspace, "stderr.log"));
-    const guestExitCode = readQemuExitCode(join(workspace, "exit-code"));
-    const serial = qemu.stdoutFull ? `
-[qemu serial]
-${qemu.stdoutFull}` : "";
-    const stderr = `${guestStderr}${qemu.stderrFull}${serial}`;
-    const missingExitMarker = !qemu.timedOut && guestExitCode === null ? "QEMU guest did not write an exit marker; inspect serial evidence" : void 0;
-    return {
-      argv: [this.qemuBinary, ...args],
-      exitCode: guestExitCode,
-      stdoutFull: stdout,
-      stderrFull: stderr,
-      durationMs: qemu.durationMs,
-      ...qemu.timedOut ? { timedOut: true } : {},
-      ...qemu.launchError || missingExitMarker ? { launchError: qemu.launchError ?? missingExitMarker } : {}
-    };
-  }
-  qemuArgs(runDir, initrdPath) {
-    return [
-      "-nodefaults",
-      "-no-reboot",
-      "-display",
-      "none",
-      "-monitor",
-      "none",
-      "-serial",
-      "stdio",
-      "-m",
-      String(this.memoryMb),
-      "-smp",
-      String(this.cpus),
-      "-kernel",
-      this.kernelImage,
-      "-initrd",
-      initrdPath,
-      "-append",
-      "console=ttyS0 rdinit=/init panic=-1",
-      "-virtfs",
-      `local,path=${resolve(runDir)},mount_tag=0-replay,security_model=none,id=osecshare`,
-      "-net",
-      "none",
-      "-sandbox",
-      "on,obsolete=deny,elevateprivileges=deny,spawn=deny,resourcecontrol=deny"
-    ];
-  }
-};
-function qemuGuestWorkingDirectory(cwd) {
-  if (!cwd)
-    return "/mnt/0";
-  if (isAbsolute(cwd))
-    return void 0;
-  const relative = resolve("/", cwd).slice(1);
-  return relative ? `/mnt/0/${relative}` : "/mnt/0";
-}
-function buildQemuInitramfs(args) {
-  const empty = Buffer.alloc(0);
-  const init = Buffer.from(renderQemuInit(args.workspaceName, args.guestCwd), "utf8");
-  const entries = [
-    { name: "bin", mode: 16877, body: empty },
-    { name: "dev", mode: 16877, body: empty },
-    { name: "mnt", mode: 16877, body: empty },
-    { name: "mnt/0", mode: 16877, body: empty },
-    { name: "proc", mode: 16877, body: empty },
-    { name: "sys", mode: 16877, body: empty },
-    { name: "tmp", mode: 16877, body: empty },
-    { name: "bin/busybox", mode: 33261, body: readFileSync(args.busyboxPath) },
-    { name: "init", mode: 33261, body: init }
-  ];
-  const chunks = [];
-  for (let index = 0; index < entries.length; index += 1) {
-    appendNewcEntry(chunks, entries[index], index + 1);
-  }
-  appendNewcEntry(chunks, { name: "TRAILER!!!", mode: 0, body: empty }, 0);
-  const initrdPath = join(args.runDir, `.0-qemu-initrd-${randomUUID()}.cpio.gz`);
-  writeFileSync(initrdPath, gzipSync(Buffer.concat(chunks)));
-  return initrdPath;
-}
-function appendNewcEntry(chunks, entry, inode) {
-  const name = Buffer.from(`${entry.name}\0`, "utf8");
-  const fields = [
-    inode,
-    entry.mode,
-    0,
-    0,
-    1,
-    0,
-    entry.body.length,
-    0,
-    0,
-    0,
-    0,
-    name.length,
-    0
-  ];
-  const header = Buffer.from(`070701${fields.map((field) => field.toString(16).padStart(8, "0")).join("")}`, "ascii");
-  chunks.push(header, name);
-  const headerPadding = (4 - (header.length + name.length) % 4) % 4;
-  if (headerPadding > 0)
-    chunks.push(Buffer.alloc(headerPadding));
-  chunks.push(entry.body);
-  const bodyPadding = (4 - entry.body.length % 4) % 4;
-  if (bodyPadding > 0)
-    chunks.push(Buffer.alloc(bodyPadding));
-}
-function renderQemuInit(workspaceName, guestCwd) {
-  const workspace = `/mnt/0/${workspaceName}`;
-  const step = `${workspace}/step.sh`;
-  const stdout = `${workspace}/stdout.log`;
-  const stderr = `${workspace}/stderr.log`;
-  const exitCode = `${workspace}/exit-code`;
-  return [
-    "#!/bin/busybox sh",
-    "/bin/busybox mkdir -p /proc /sys /dev /tmp /mnt/0",
-    "/bin/busybox mount -t proc proc /proc",
-    "/bin/busybox mount -t sysfs sysfs /sys",
-    "/bin/busybox mount -t devtmpfs devtmpfs /dev 2>/dev/null || true",
-    "if ! /bin/busybox mount -t 9p -o trans=virtio,version=9p2000.L 0-replay /mnt/0; then",
-    '  echo "__ZERO_QEMU_MOUNT_FAILED__"',
-    "  /bin/busybox poweroff -f",
-    "fi",
-    `(
-      cd ${shellQuote(guestCwd)} || exit 125
-      /bin/busybox sh ${shellQuote(step)}
-    ) > ${shellQuote(stdout)} 2> ${shellQuote(stderr)}`,
-    "rc=$?",
-    `printf '%s\\n' "$rc" > ${shellQuote(exitCode)}`,
-    "/bin/busybox sync",
-    "/bin/busybox poweroff -f"
-  ].join("\n");
-}
-function shellQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function readQemuCapture(path) {
-  try {
-    return readFileSync(path).subarray(0, MAX_STREAM_CAPTURE_BYTES).toString("utf8");
-  } catch {
-    return "";
-  }
-}
-function readQemuExitCode(path) {
-  try {
-    const raw = readFileSync(path, "utf8").trim();
-    if (!/^(0|[1-9][0-9]{0,2})$/.test(raw))
-      return null;
-    const value = Number(raw);
-    return value <= 255 ? value : null;
-  } catch {
-    return null;
-  }
-}
-function runQemuCommand(args) {
-  const startedAt = Date.now();
-  const { promise, resolve: resolveResult } = promiseWithResolvers.withResolvers();
-  let timer;
-  let stdout = "";
-  let stderr = "";
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-  let timedOut = false;
-  let settled = false;
-  let child;
-  const finish = (exitCode, launchError) => {
-    if (settled)
-      return;
-    settled = true;
-    clearTimeout(timer);
-    resolveResult({
-      exitCode,
-      stdoutFull: stdout,
-      stderrFull: stderr,
-      durationMs: Date.now() - startedAt,
-      ...timedOut ? { timedOut: true } : {},
-      ...launchError ? { launchError } : {}
-    });
-  };
-  try {
-    child = spawn(args.qemuBinary, args.args, {
-      cwd: args.runDir,
-      env: allowlistedChildEnv({ "ZERO_VERIFY": "1" }),
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: nodePlatform !== "win32"
-    });
-  } catch (err) {
-    finish(null, err instanceof Error ? err.message : String(err));
-    return promise;
-  }
-  timer = setTimeout(() => {
-    timedOut = true;
-    killProcessGroup(child);
-  }, args.stepTimeoutMs);
-  child.stdout?.on("data", (chunk) => {
-    if (stdoutBytes >= MAX_STREAM_CAPTURE_BYTES)
-      return;
-    const remaining = MAX_STREAM_CAPTURE_BYTES - stdoutBytes;
-    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-    stdout += slice.toString("utf8");
-    stdoutBytes += slice.length;
-  });
-  child.stderr?.on("data", (chunk) => {
-    if (stderrBytes >= MAX_STREAM_CAPTURE_BYTES)
-      return;
-    const remaining = MAX_STREAM_CAPTURE_BYTES - stderrBytes;
-    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-    stderr += slice.toString("utf8");
-    stderrBytes += slice.length;
-  });
-  child.on("error", (err) => {
-    finish(null, err.message);
-  });
-  child.on("close", (code) => {
-    const exitCode = typeof code === "number" ? code : null;
-    finish(exitCode, exitCode !== 0 && !timedOut ? `QEMU exited before guest completion (exit ${exitCode ?? "unknown"})` : void 0);
-  });
-  return promise;
-}
-function argvForStep(step) {
-  switch (step.action.type) {
-    case "shell":
-      return ["/bin/sh", "-c", step.action.cmd];
-    case "docker":
-      return ["docker", "run", "--rm", ...step.action.args, step.action.image];
-    case "http":
-      return [step.action.method, step.action.url];
-    case "note":
-      return ["note", step.id];
-    default: {
-      const _exhaustive = step.action;
-      void _exhaustive;
-      return ["unknown"];
-    }
-  }
-}
-function assertionFromStepExpect(step, expect, result) {
-  switch (expect.type) {
-    case "exit-zero": {
-      const passed = result.exitCode === 0;
-      return {
-        kind: "exit_code",
-        target: step.id,
-        expected: 0,
-        actual: result.exitCode,
-        passed
-      };
-    }
-    case "http-status": {
-      const expectedStatuses = Array.isArray(expect.status) ? expect.status : [expect.status];
-      const actual = result.httpStatus ?? null;
-      return {
-        kind: "http_status",
-        target: step.id,
-        expected: Array.isArray(expect.status) ? expect.status.join(",") : expect.status,
-        actual,
-        passed: actual !== null && expectedStatuses.includes(actual)
-      };
-    }
-    case "body-contains": {
-      const haystack = result.stdoutFull;
-      const passed = haystack.includes(expect.text);
-      return {
-        kind: "string_in_output",
-        target: step.id,
-        expected: expect.text,
-        actual: passed ? expect.text : null,
-        passed
-      };
-    }
-    case "body-matches": {
-      let passed = false;
-      try {
-        passed = new RegExp(expect.pattern).test(result.stdoutFull);
-      } catch {
-        passed = false;
-      }
-      return {
-        kind: "string_in_output",
-        target: step.id,
-        expected: expect.pattern,
-        actual: passed ? "matched" : null,
-        passed
-      };
-    }
-    case "file-exists": {
-      const passed = existsSync(expect.path);
-      return {
-        kind: "file_exists",
-        target: expect.path,
-        expected: true,
-        actual: passed,
-        passed
-      };
-    }
-    default: {
-      const _exhaustive = expect;
-      void _exhaustive;
-      return {
-        kind: "string_in_output",
-        target: step.id,
-        expected: "",
-        actual: null,
-        passed: false
-      };
-    }
-  }
-}
-function evaluateAssertion(input, ctx) {
-  switch (input.kind) {
-    case "exit_code": {
-      const actual = ctx.lastExitCode;
-      return {
-        ...input,
-        actual,
-        passed: actual === input.expected
-      };
-    }
-    case "string_in_output": {
-      const needle = String(input.expected);
-      const passed = ctx.aggregatedStdout.includes(needle);
-      return {
-        ...input,
-        actual: passed ? needle : null,
-        passed
-      };
-    }
-    case "file_exists": {
-      const path = isAbsolute(input.target) ? input.target : join(ctx.runDir, input.target);
-      const passed = existsSync(path);
-      return {
-        ...input,
-        actual: passed,
-        passed
-      };
-    }
-    case "http_status": {
-      const actual = ctx.lastHttpStatus;
-      const expectedStatuses = String(input.expected).split(",").map((status) => Number(status.trim())).filter((status) => Number.isInteger(status));
-      return {
-        ...input,
-        actual,
-        passed: actual !== null && expectedStatuses.includes(actual)
-      };
-    }
-    default: {
-      const _exhaustive = input.kind;
-      void _exhaustive;
-      return {
-        ...input,
-        actual: null,
-        passed: false
-      };
-    }
-  }
-}
-function excerpt(text, max = STREAM_EXCERPT_BYTES) {
-  if (!text)
-    return "";
-  if (Buffer.byteLength(text, "utf8") <= max)
-    return text;
-  const buf = Buffer.from(text, "utf8");
-  return buf.subarray(0, max).toString("utf8") + "\u2026[truncated]";
-}
-function sha256Hex(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-function persistArtifact(args) {
-  if (!args.body)
-    return null;
-  const artifactsDir = join(args.runDir, "artifacts");
-  mkdirSync(artifactsDir, { recursive: true });
-  const sha = sha256Hex(args.body);
-  const safeHint = args.filenameHint.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const fname = `${safeHint}-${sha.slice(0, 16)}`;
-  const fullPath = join(artifactsDir, fname);
-  writeFileSync(fullPath, args.body, "utf8");
-  return {
-    kind: args.kind,
-    path: join("artifacts", fname),
-    sha256: sha,
-    bytes: statSync(fullPath).size
-  };
-}
-async function runDeterministicReplay(finding, opts = {}) {
-  const runner = opts.runner ?? new LocalShellRunner();
-  const stepTimeoutMs = opts.stepTimeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
-  const engineVersion = opts.engineVersion ?? VERSION;
-  const runDir = opts.runDir ?? mkdtempSync(join(tmpdir(), "0-replay-"));
-  mkdirSync(runDir, { recursive: true });
-  const startedAt = /* @__PURE__ */ new Date();
-  const startMs = Date.now();
-  const commands = [];
-  const assertions = [];
-  const evidenceArtifacts = [];
-  const steps = finding.pocSteps ?? [];
-  if (steps.length === 0) {
-    const completedAt2 = /* @__PURE__ */ new Date();
-    return {
-      runDir,
-      result: {
-        status: "skipped",
-        mode: "deterministic_replay",
-        finding_id: finding.id,
-        engine_version: engineVersion,
-        started_at: startedAt.toISOString(),
-        completed_at: completedAt2.toISOString(),
-        duration_ms: completedAt2.getTime() - startMs,
-        commands: [],
-        assertions: [],
-        evidence_artifacts: [],
-        engine_metadata: {
-          os: nodePlatform,
-          arch: nodeArch,
-          runner: runner.kind
-        },
-        summary: "no pocSteps to execute"
-      }
-    };
-  }
-  let lastExit = null;
-  let lastHttpStatus = null;
-  let aggregatedStdout = "";
-  let runnerLaunchError = null;
-  for (const step of steps) {
-    let stepResult;
-    try {
-      stepResult = await runner.exec(step, { runDir, stepTimeoutMs, scope: opts.scope });
-    } catch (err) {
-      stepResult = {
-        argv: argvForStep(step),
-        exitCode: null,
-        stdoutFull: "",
-        stderrFull: "",
-        durationMs: 0,
-        launchError: err instanceof Error ? err.message : String(err)
-      };
-      runnerLaunchError = stepResult.launchError ?? "runner exec failed";
-    }
-    lastExit = stepResult.exitCode;
-    aggregatedStdout += stepResult.stdoutFull;
-    if (stepResult.launchError) {
-      runnerLaunchError = stepResult.launchError;
-    }
-    lastHttpStatus = stepResult.httpStatus ?? null;
-    commands.push({
-      argv: stepResult.argv,
-      exit_code: stepResult.exitCode,
-      stdout_excerpt: excerpt(stepResult.stdoutFull),
-      stderr_excerpt: excerpt(stepResult.stderrFull),
-      duration_ms: stepResult.durationMs
-    });
-    const stdoutArt = persistArtifact({
-      runDir,
-      kind: "stdout",
-      filenameHint: `step-${step.id}.stdout`,
-      body: stepResult.stdoutFull
-    });
-    if (stdoutArt)
-      evidenceArtifacts.push(stdoutArt);
-    const stderrArt = persistArtifact({
-      runDir,
-      kind: "stderr",
-      filenameHint: `step-${step.id}.stderr`,
-      body: stepResult.stderrFull
-    });
-    if (stderrArt)
-      evidenceArtifacts.push(stderrArt);
-    if (step.expect) {
-      assertions.push(assertionFromStepExpect(step, step.expect, stepResult));
-    }
-    if (runnerLaunchError)
-      break;
-  }
-  for (const a of opts.assertions ?? []) {
-    assertions.push(evaluateAssertion(a, {
-      lastExitCode: lastExit,
-      aggregatedStdout,
-      runDir,
-      lastHttpStatus
-    }));
-  }
-  const completedAt = /* @__PURE__ */ new Date();
-  const allAssertionsPassed = assertions.length === 0 ? false : assertions.every((a) => a.passed);
-  const status = runnerLaunchError ? "error" : allAssertionsPassed ? "reproduced" : "not_reproduced";
-  return {
-    runDir,
-    result: {
-      status,
-      mode: "deterministic_replay",
-      finding_id: finding.id,
-      engine_version: engineVersion,
-      started_at: startedAt.toISOString(),
-      completed_at: completedAt.toISOString(),
-      duration_ms: completedAt.getTime() - startMs,
-      commands,
-      assertions,
-      evidence_artifacts: evidenceArtifacts,
-      engine_metadata: {
-        os: nodePlatform,
-        arch: nodeArch,
-        runner: runner.kind
-      },
-      error_reason: runnerLaunchError ?? null,
-      summary: summariseOutcome({
-        status,
-        ran: commands.length,
-        total: steps.length,
-        runnerLaunchError
-      })
-    }
-  };
-}
-function summariseOutcome(args) {
-  switch (args.status) {
-    case "reproduced":
-      return `replay reproduced the finding (${args.ran}/${args.total} steps executed)`;
-    case "not_reproduced":
-      return `replay completed but assertions failed (${args.ran}/${args.total} steps executed)`;
-    case "error":
-      return args.runnerLaunchError ? `runner error: ${args.runnerLaunchError}` : "runner error";
-    case "skipped":
-      return "no pocSteps to execute";
-  }
-}
-
-export {
-  STREAM_EXCERPT_BYTES,
-  DEFAULT_STEP_TIMEOUT_MS,
-  MAX_STREAM_CAPTURE_BYTES,
-  LocalShellRunner,
-  DEFAULT_DOCKER_SHELL_IMAGE,
-  DEFAULT_DOCKER_HTTP_IMAGE,
-  DockerRunner,
-  QemuRunner,
-  argvForStep,
-  assertionFromStepExpect,
-  evaluateAssertion,
-  excerpt,
-  persistArtifact,
-  runDeterministicReplay
-};