@vibgrate/cli 2026.722.2 → 2026.727.1

package/dist/chunk-IS7VTH2Q.js

@@ -0,0 +1,627 @@
+import * as fs3 from 'fs';
+import * as os from 'os';
+import * as path3 from 'path';
+import { spawnSync } from 'child_process';
+
+// src/runtime/execution-env.ts
+function buildFirecrackerConfig(paths, options) {
+  const bootArgs = [
+    "console=ttyS0",
+    "reboot=k",
+    "panic=1",
+    "pci=off",
+    "init=/sbin/vg-agent-init",
+    `vg_cmd=${encodeURIComponent(options.command)}`
+  ];
+  if (options.denyNetwork !== false) bootArgs.push("vg_net=off");
+  const cfg = {
+    "boot-source": {
+      kernel_image_path: paths.kernel,
+      boot_args: bootArgs.join(" ")
+    },
+    drives: [
+      {
+        drive_id: "rootfs",
+        path_on_host: paths.rootfs,
+        is_root_device: true,
+        is_read_only: false
+      }
+    ],
+    "machine-config": {
+      vcpu_count: options.vcpuCount ?? 1,
+      mem_size_mib: options.memSizeMib ?? 512,
+      smt: false
+    }
+  };
+  cfg["vg-writable-roots"] = [...options.writableRoots].map((r) => path3.resolve(r)).sort((a, b) => a.localeCompare(b));
+  if (options.denyNetwork === false) {
+    cfg["network-interfaces"] = [
+      {
+        iface_id: "eth0",
+        guest_mac: "06:00:00:00:00:01",
+        host_dev_name: "vmtap0"
+      }
+    ];
+  }
+  return cfg;
+}
+function firecrackerArgv(binary, configPath) {
+  return [binary, "--config-file", configPath, "--no-api"];
+}
+function resolveFirecrackerPaths(env = process.env, probeExists = (p) => {
+  try {
+    return fs3.existsSync(p);
+  } catch {
+    return false;
+  }
+}) {
+  const binary = env.VIBGRATE_FIRECRACKER_BIN || which("firecracker") || "";
+  const kernel = env.VIBGRATE_FIRECRACKER_KERNEL || "";
+  const rootfs = env.VIBGRATE_FIRECRACKER_ROOTFS || "";
+  if (!binary || !kernel || !rootfs) return null;
+  if (!probeExists(binary) || !probeExists(kernel) || !probeExists(rootfs)) return null;
+  return { binary, kernel, rootfs };
+}
+function tryCreateFirecrackerEnv(options) {
+  const paths = options.paths === void 0 ? resolveFirecrackerPaths() : options.paths;
+  if (!paths) return null;
+  const denyNetwork = options.denyNetwork !== false;
+  const reason = options.reason ?? "L3 Firecracker microVM";
+  return {
+    tier: "L3",
+    label: "firecracker",
+    reason,
+    run(command, runOpts) {
+      const roots = options.writableRoots.length ? options.writableRoots : [runOpts.cwd];
+      const configPath = path3.join(
+        process.env.TMPDIR || "/tmp",
+        `vg-fc-${process.pid}-${Date.now()}.json`
+      );
+      const cfg = buildFirecrackerConfig(paths, {
+        writableRoots: roots,
+        command,
+        denyNetwork});
+      try {
+        fs3.writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}
+`, {
+          encoding: "utf8",
+          mode: 384
+        });
+        const argv = firecrackerArgv(paths.binary, configPath);
+        const res = spawnSync(argv[0], argv.slice(1), {
+          encoding: "utf8",
+          timeout: runOpts.timeoutMs ?? 12e4,
+          maxBuffer: 10 * 1024 * 1024,
+          env: process.env
+        });
+        const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+        if (res.error) {
+          return {
+            stdout: `firecracker failed to start: ${res.error.message}`,
+            exitCode: 1
+          };
+        }
+        return { stdout, exitCode: res.status ?? 1 };
+      } finally {
+        try {
+          fs3.unlinkSync(configPath);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function which(bin) {
+  try {
+    const res = spawnSync(process.platform === "win32" ? "where" : "which", [bin], {
+      encoding: "utf8"
+    });
+    if (res.status !== 0) return null;
+    const line = (res.stdout ?? "").trim().split("\n")[0]?.trim();
+    return line || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/runtime/sandbox-backend.ts
+function detectSandboxCapabilities(platform = process.platform) {
+  const backends = [];
+  if (platform === "darwin") {
+    const seatbelt = commandOnPath("sandbox-exec");
+    backends.push({
+      id: "seatbelt",
+      tier: "L1",
+      available: seatbelt,
+      reason: seatbelt ? "sandbox-exec present" : "sandbox-exec not found"
+    });
+  }
+  if (platform === "linux") {
+    const bwrap = commandOnPath("bwrap");
+    backends.push({
+      id: "bwrap",
+      tier: "L1",
+      available: bwrap,
+      reason: bwrap ? "bubblewrap present" : "bwrap not found"
+    });
+    const firejail = commandOnPath("firejail");
+    backends.push({
+      id: "firejail",
+      tier: "L2",
+      available: firejail,
+      reason: firejail ? "firejail present" : "firejail not found"
+    });
+    const runsc = commandOnPath("runsc");
+    backends.push({
+      id: "gvisor",
+      tier: "L2",
+      available: runsc,
+      reason: runsc ? "gVisor runsc present" : "runsc not found"
+    });
+  }
+  const fc = resolveFirecrackerPaths();
+  backends.push({
+    id: "firecracker",
+    tier: "L3",
+    available: !!fc,
+    reason: fc ? `Firecracker configured (${fc.binary})` : "Firecracker unset \u2014 set VIBGRATE_FIRECRACKER_BIN, _KERNEL, _ROOTFS"
+  });
+  backends.push({
+    id: "host",
+    tier: "L0",
+    available: true,
+    reason: "always available"
+  });
+  let bestTier = "L0";
+  for (const b of backends) {
+    if (!b.available) continue;
+    if (tierRank(b.tier) > tierRank(bestTier)) bestTier = b.tier;
+  }
+  return { platform, backends, bestTier };
+}
+function selectSandboxBackend(requested, caps = detectSandboxCapabilities()) {
+  const want = tierRank(requested);
+  const available = caps.backends.filter((b) => b.available);
+  const exact = available.find((b) => b.tier === requested && b.id !== "host");
+  if (exact) return exact;
+  const stronger = available.filter((b) => tierRank(b.tier) >= want && b.id !== "host").sort((a, b) => tierRank(a.tier) - tierRank(b.tier));
+  if (stronger[0]) return stronger[0];
+  const weaker = available.filter((b) => tierRank(b.tier) < want).sort((a, b) => tierRank(b.tier) - tierRank(a.tier));
+  if (weaker[0]) return weaker[0];
+  return available.find((b) => b.id === "host") ?? {
+    id: "host",
+    tier: "L0",
+    available: true,
+    reason: "fallback host"
+  };
+}
+function firejailArgv(writableRoots, command, options = {}) {
+  const args = [
+    "firejail",
+    "--quiet",
+    "--noprofile",
+    "--private-tmp",
+    "--nonewprivs",
+    "--nogroups"
+  ];
+  if (options.denyNetwork !== false) args.push("--net=none");
+  for (const root of writableRoots) {
+    args.push(`--whitelist=${root}`);
+  }
+  if (options.cwd) args.push(`--whitelist=${options.cwd}`);
+  args.push("--", "/bin/sh", "-c", command);
+  return args;
+}
+function tierRank(t) {
+  if (t === "L0") return 0;
+  if (t === "L1") return 1;
+  if (t === "L2") return 2;
+  return 3;
+}
+function commandOnPath(bin) {
+  try {
+    const res = spawnSync(process.platform === "win32" ? "where" : "which", [bin], { encoding: "utf8" });
+    return res.status === 0 && Boolean(res.stdout?.trim());
+  } catch {
+    return false;
+  }
+}
+function gvisorArgv(paths, options) {
+  const args = [
+    paths.binary,
+    "--rootless=true",
+    "--network=" + (options.denyNetwork === false ? "host" : "none"),
+    "do",
+    "--rootfs-path",
+    paths.rootfs
+  ];
+  for (const root of [...options.writableRoots].map((r) => path3.resolve(r)).sort()) {
+    args.push("--bind", `${root}:${root}:rw`);
+  }
+  if (options.cwd) {
+    args.push("--cwd", path3.resolve(options.cwd));
+  }
+  args.push("--", "/bin/sh", "-c", options.command);
+  return args;
+}
+function resolveGvisorPaths(env = process.env, probeExists = (p) => {
+  try {
+    return fs3.existsSync(p);
+  } catch {
+    return false;
+  }
+}, which2 = whichBin) {
+  const binary = env.VIBGRATE_GVISOR_BIN || which2("runsc") || "";
+  const rootfs = env.VIBGRATE_GVISOR_ROOTFS || "";
+  if (!binary || !rootfs) return null;
+  if (!probeExists(binary) || !probeExists(rootfs)) return null;
+  return { binary, rootfs };
+}
+function tryCreateGvisorEnv(options) {
+  const paths = options.paths === void 0 ? resolveGvisorPaths() : options.paths;
+  if (!paths) return null;
+  const denyNetwork = options.denyNetwork !== false;
+  return {
+    tier: "L2",
+    label: "gvisor",
+    reason: options.reason ?? "L2 gVisor runsc",
+    run(command, runOpts) {
+      const roots = options.writableRoots.length ? options.writableRoots : [runOpts.cwd];
+      const argv = gvisorArgv(paths, {
+        writableRoots: roots,
+        command,
+        denyNetwork,
+        cwd: runOpts.cwd
+      });
+      const res = spawnSync(argv[0], argv.slice(1), {
+        encoding: "utf8",
+        timeout: runOpts.timeoutMs ?? 12e4,
+        maxBuffer: 10 * 1024 * 1024,
+        env: process.env
+      });
+      if (res.error) {
+        return { stdout: `gvisor failed to start: ${res.error.message}`, exitCode: 1 };
+      }
+      const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+      return { stdout, exitCode: res.status ?? 1 };
+    }
+  };
+}
+function whichBin(bin) {
+  try {
+    const res = spawnSync(process.platform === "win32" ? "where" : "which", [bin], {
+      encoding: "utf8"
+    });
+    if (res.status !== 0) return null;
+    return (res.stdout ?? "").trim().split("\n")[0]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/runtime/execution-env.ts
+function detectSecurityCapabilities(platform = process.platform) {
+  if (platform === "linux") {
+    return {
+      platform,
+      landlock: linuxLandlockAvailable(),
+      seatbelt: false,
+      bubblewrap: commandOnPath2("bwrap"),
+      firejail: commandOnPath2("firejail"),
+      gvisor: commandOnPath2("runsc")
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      platform,
+      landlock: false,
+      seatbelt: macSeatbeltAvailable(),
+      bubblewrap: false,
+      firejail: false,
+      gvisor: false
+    };
+  }
+  return { platform, landlock: false, seatbelt: false, bubblewrap: false, firejail: false, gvisor: false };
+}
+function resolveExecutionEnv(requested = "L0", options = {}) {
+  const caps = options.capabilities ?? detectSecurityCapabilities();
+  const writableRoots = normalizeRoots(options.writableRoots);
+  const denyNetwork = options.denyNetwork !== false;
+  if (requested === "L0") return createHostExecutionEnv("explicit L0");
+  if (requested === "L3") {
+    const l3 = tryCreateFirecrackerEnv({
+      writableRoots,
+      denyNetwork,
+      reason: "L3 Firecracker microVM"
+    });
+    if (l3) return l3;
+    const l2 = tryCreateL2Env(caps, writableRoots, denyNetwork, requested);
+    if (l2) return l2;
+    const l1 = tryCreateL1Env(caps, writableRoots, denyNetwork, requested);
+    if (l1) return l1;
+    return createHostExecutionEnv("L3 not available (Firecracker images unset) \u2014 falling back to L0");
+  }
+  if (requested === "L2") {
+    const l2 = tryCreateL2Env(caps, writableRoots, denyNetwork, requested);
+    if (l2) return l2;
+    const l1 = tryCreateL1Env(caps, writableRoots, denyNetwork, requested);
+    if (l1) return l1;
+    return createHostExecutionEnv(`${requested} not available \u2014 falling back to L0`);
+  }
+  if (requested === "L1") {
+    const l1 = tryCreateL1Env(caps, writableRoots, denyNetwork, requested);
+    if (l1) return l1;
+    return createHostExecutionEnv("L1 requested but no Seatbelt/bubblewrap \u2014 falling back to L0");
+  }
+  return createHostExecutionEnv("unknown tier \u2014 falling back to L0");
+}
+function createHostExecutionEnv(reason = "host process") {
+  return {
+    tier: "L0",
+    label: "host",
+    reason,
+    run(command, options) {
+      return hostRun(command, options);
+    }
+  };
+}
+function buildSeatbeltProfile(writableRoots, options = {}) {
+  const roots = uniqueResolved([...writableRoots, ...options.tempRoots ?? defaultTempRoots()]);
+  const lines = [
+    "(version 1)",
+    "(deny default)",
+    "(allow process*)",
+    "(allow sysctl-read)",
+    "(allow mach*)",
+    "(allow system-socket)",
+    "(allow file-read*)",
+    '(allow file-write-data (literal "/dev/null"))',
+    '(allow file-write-data (literal "/dev/zero"))',
+    "(allow file-ioctl)",
+    '(allow file-write* (literal "/dev/tty"))',
+    '(allow file-write* (literal "/dev/dtracehelper"))'
+  ];
+  for (const root of roots) {
+    const escaped = escapeSeatbeltPath(root);
+    lines.push(`(allow file-write* (subpath "${escaped}"))`);
+    if (root.startsWith("/var/") || root.startsWith("/tmp")) {
+      lines.push(`(allow file-write* (subpath "${escapeSeatbeltPath(`/private${root}`)}"))`);
+    }
+    if (root.startsWith("/private/var/") || root.startsWith("/private/tmp")) {
+      const short = root.slice("/private".length);
+      lines.push(`(allow file-write* (subpath "${escapeSeatbeltPath(short)}"))`);
+    }
+  }
+  if (options.denyNetwork !== false) {
+    lines.push("(deny network*)");
+  } else {
+    lines.push("(allow network*)");
+  }
+  lines.push("(allow ipc*)");
+  lines.push("(allow signal)");
+  lines.push("(allow pseudo-tty)");
+  return `${lines.join("\n")}
+`;
+}
+function seatbeltArgv(profilePath, command) {
+  return ["sandbox-exec", "-f", profilePath, "/bin/sh", "-c", command];
+}
+function bubblewrapArgv(writableRoots, command, options = {}) {
+  const args = [
+    "bwrap",
+    "--die-with-parent",
+    "--ro-bind",
+    "/",
+    "/",
+    "--dev",
+    "/dev",
+    "--proc",
+    "/proc",
+    "--tmpfs",
+    "/tmp"
+  ];
+  const roots = uniqueResolved(writableRoots);
+  for (const root of roots) {
+    args.push("--bind", root, root);
+  }
+  for (const t of defaultTempRoots()) {
+    if (fs3.existsSync(t)) args.push("--bind", t, t);
+  }
+  if (options.denyNetwork !== false) {
+    args.push("--unshare-net");
+  }
+  if (options.cwd) {
+    args.push("--chdir", options.cwd);
+  }
+  args.push("--", "/bin/sh", "-c", command);
+  return args;
+}
+function tryCreateL2Env(caps, writableRoots, denyNetwork, requested) {
+  if (caps.firejail) {
+    return createFirejailEnv(
+      requested === "L2" ? "L2 firejail process jail" : `${requested} requested; using L2 firejail`,
+      writableRoots,
+      denyNetwork
+    );
+  }
+  if (caps.gvisor) {
+    const gv = tryCreateGvisorEnv({
+      writableRoots,
+      denyNetwork,
+      reason: requested === "L2" ? "L2 gVisor runsc" : `${requested} requested; using L2 gVisor`
+    });
+    if (gv) return gv;
+  }
+  return null;
+}
+function tryCreateL1Env(caps, writableRoots, denyNetwork, requested) {
+  if (caps.seatbelt) {
+    return createSeatbeltEnv(
+      requested === "L1" ? "L1 Seatbelt (sandbox-exec) path isolation" : `${requested} requested; using L1 Seatbelt (sandbox-exec)`,
+      writableRoots,
+      denyNetwork
+    );
+  }
+  if (caps.bubblewrap) {
+    return createBubblewrapEnv(
+      requested === "L1" ? "L1 bubblewrap path isolation" : `${requested} requested; using L1 bubblewrap`,
+      writableRoots,
+      denyNetwork,
+      caps.landlock
+    );
+  }
+  if (caps.landlock) {
+    return null;
+  }
+  return null;
+}
+function createFirejailEnv(reason, writableRoots, denyNetwork) {
+  return {
+    tier: "L2",
+    label: "firejail",
+    reason,
+    run(command, options) {
+      const roots = writableRoots.length ? writableRoots : [options.cwd];
+      if (!roots.some((r) => isPathInside(options.cwd, r))) {
+        roots.push(path3.resolve(options.cwd));
+      }
+      const argv = firejailArgv(roots, command, { denyNetwork, cwd: options.cwd });
+      const res = spawnSync(argv[0], argv.slice(1), {
+        encoding: "utf8",
+        timeout: options.timeoutMs ?? 12e4,
+        maxBuffer: 10 * 1024 * 1024,
+        env: process.env
+      });
+      const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+      return { stdout, exitCode: res.status ?? 1 };
+    }
+  };
+}
+function createSeatbeltEnv(reason, writableRoots, denyNetwork) {
+  return {
+    tier: "L1",
+    label: "seatbelt",
+    reason,
+    run(command, options) {
+      const roots = writableRoots.length ? writableRoots : [options.cwd];
+      const profile = buildSeatbeltProfile(roots, { denyNetwork });
+      const profilePath = path3.join(os.tmpdir(), `vg-seatbelt-${process.pid}-${Date.now()}.sb`);
+      try {
+        fs3.writeFileSync(profilePath, profile, { encoding: "utf8", mode: 384 });
+        const argv = seatbeltArgv(profilePath, command);
+        const res = spawnSync(argv[0], argv.slice(1), {
+          cwd: options.cwd,
+          encoding: "utf8",
+          timeout: options.timeoutMs ?? 12e4,
+          maxBuffer: 10 * 1024 * 1024,
+          env: process.env
+        });
+        const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+        return { stdout, exitCode: res.status ?? 1 };
+      } finally {
+        try {
+          fs3.unlinkSync(profilePath);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function createBubblewrapEnv(reason, writableRoots, denyNetwork, landlockPresent) {
+  return {
+    tier: "L1",
+    label: landlockPresent ? "bwrap+landlock-host" : "bwrap",
+    reason,
+    run(command, options) {
+      const roots = writableRoots.length ? writableRoots : [options.cwd];
+      if (!roots.some((r) => isPathInside(options.cwd, r))) {
+        roots.push(path3.resolve(options.cwd));
+      }
+      const argv = bubblewrapArgv(roots, command, { denyNetwork, cwd: options.cwd });
+      const res = spawnSync(argv[0], argv.slice(1), {
+        encoding: "utf8",
+        timeout: options.timeoutMs ?? 12e4,
+        maxBuffer: 10 * 1024 * 1024,
+        env: process.env
+      });
+      const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+      return { stdout, exitCode: res.status ?? 1 };
+    }
+  };
+}
+function hostRun(command, options) {
+  const res = spawnSync(command, {
+    cwd: options.cwd,
+    shell: true,
+    encoding: "utf8",
+    timeout: options.timeoutMs ?? 12e4,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  const stdout = (res.stdout ?? "") + (res.stderr ? `
+${res.stderr}` : "");
+  return { stdout, exitCode: res.status ?? 1 };
+}
+function linuxLandlockAvailable() {
+  try {
+    return fs3.existsSync("/sys/kernel/security/landlock") || fs3.existsSync("/proc/sys/kernel/landlock");
+  } catch {
+    return false;
+  }
+}
+function macSeatbeltAvailable() {
+  return commandOnPath2("sandbox-exec");
+}
+function commandOnPath2(bin) {
+  try {
+    const res = spawnSync(process.platform === "win32" ? "where" : "which", [bin], { encoding: "utf8" });
+    return res.status === 0 && Boolean(res.stdout?.trim());
+  } catch {
+    return false;
+  }
+}
+function defaultTempRoots() {
+  const roots = [];
+  try {
+    roots.push(os.tmpdir());
+  } catch {
+  }
+  if (process.env.TMPDIR) roots.push(process.env.TMPDIR);
+  if (process.env.TMP) roots.push(process.env.TMP);
+  if (process.env.TEMP) roots.push(process.env.TEMP);
+  roots.push("/tmp", "/private/tmp");
+  return uniqueResolved(roots.filter((r) => typeof r === "string" && r.length > 0));
+}
+function normalizeRoots(roots) {
+  if (!roots?.length) return [];
+  return uniqueResolved(roots.filter((r) => typeof r === "string" && r.trim()).map((r) => r.trim()));
+}
+function uniqueResolved(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of paths) {
+    try {
+      const abs = path3.resolve(p);
+      if (seen.has(abs)) continue;
+      seen.add(abs);
+      out.push(abs);
+    } catch {
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function escapeSeatbeltPath(p) {
+  return p.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function isPathInside(child, parent) {
+  const rel = path3.relative(path3.resolve(parent), path3.resolve(child));
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+
+export { bubblewrapArgv, buildSeatbeltProfile, createHostExecutionEnv, detectSandboxCapabilities, detectSecurityCapabilities, firejailArgv, resolveExecutionEnv, seatbeltArgv, selectSandboxBackend };
+//# sourceMappingURL=chunk-IS7VTH2Q.js.map
+//# sourceMappingURL=chunk-IS7VTH2Q.js.map