vmsan 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Angelo Recca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+# vmsan
+
+<!-- automd:badges color="yellow" license licenseSrc bundlephobia packagephobia -->
+
+[![npm version](https://img.shields.io/npm/v/vmsan?color=yellow)](https://npmjs.com/package/vmsan)
+[![npm downloads](https://img.shields.io/npm/dm/vmsan?color=yellow)](https://npm.chart.dev/vmsan)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/vmsan?color=yellow)](https://bundlephobia.com/package/vmsan)
+[![install size](https://badgen.net/packagephobia/install/vmsan?color=yellow)](https://packagephobia.com/result?p=vmsan)
+[![license](https://img.shields.io/github/license/angelorc/vmsan?color=yellow)](https://github.com/angelorc/vmsan/blob/main/LICENSE)
+
+<!-- /automd -->
+
+Firecracker microVM sandbox toolkit. Create, manage, and connect to isolated Firecracker microVMs from the command line.
+
+## Features
+
+- Full VM lifecycle management (create, start, stop, remove)
+- Network isolation with policy-based controls (allow-all, deny-all, custom domain/CIDR allowlists)
+- Interactive shell access via WebSocket PTY
+- File upload/download to running VMs
+- Command execution with streaming output
+- Multiple runtimes: `base`, `node22`, `python3.13`
+- Docker image support via `--from-image`
+- VM snapshots
+- Structured JSON output for scripting
+
+## Prerequisites
+
+- Linux (x86_64 or aarch64) with KVM support
+- [Bun](https://bun.sh) >= 1.2
+- [Go](https://go.dev) >= 1.22 (to build the in-VM agent)
+- Root/sudo access (required for TAP device networking and jailer)
+- `squashfs-tools` (for rootfs conversion during install)
+
+## Install
+
+### 1. Install Firecracker, kernel, and rootfs
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/angelorc/vmsan/main/install.sh | bash
+```
+
+This downloads and installs into `~/.vmsan/`:
+
+- Firecracker + Jailer (latest release)
+- Linux kernel (vmlinux 6.1)
+- Ubuntu 24.04 rootfs (converted from squashfs to ext4)
+
+### 2. Install vmsan CLI
+
+<!-- automd:pm-install -->
+
+```sh
+# ✨ Auto-detect
+npx nypm install vmsan
+
+# npm
+npm install vmsan
+
+# yarn
+yarn add vmsan
+
+# pnpm
+pnpm add vmsan
+
+# bun
+bun install vmsan
+
+# deno
+deno install npm:vmsan
+```
+
+<!-- /automd -->
+
+### 3. Build the in-VM agent
+
+```bash
+cd agent
+make install
+cd ..
+```
+
+### Link globally (optional)
+
+```bash
+bun link
+```
+
+This makes the `vmsan` command available system-wide.
+
+## Usage
+
+```bash
+# Create and start a VM
+vmsan create --runtime node22 --memory 512 --cpus 2
+
+# Create a VM from a Docker image
+vmsan create --from-image node:22-alpine
+
+# List all VMs
+vmsan list
+
+# Connect to a running VM shell
+vmsan connect <vm-id>
+
+# Upload a file to a VM
+vmsan upload <vm-id> ./local-file.txt /remote/path/file.txt
+
+# Download a file from a VM
+vmsan download <vm-id> /remote/path/file.txt ./local-file.txt
+
+# Stop a VM
+vmsan stop <vm-id>
+
+# Remove a VM
+vmsan remove <vm-id>
+```
+
+### Global flags
+
+```
+--json       Output structured JSON
+--verbose    Show detailed debug output
+```
+
+### Commands
+
+| Command    | Alias | Description                       |
+| ---------- | ----- | --------------------------------- |
+| `create`   |       | Create and start a new microVM    |
+| `list`     | `ls`  | List all VMs                      |
+| `start`    |       | Start a stopped VM                |
+| `stop`     |       | Stop a running VM                 |
+| `remove`   | `rm`  | Remove a VM                       |
+| `connect`  |       | Open an interactive shell to a VM |
+| `upload`   |       | Upload files to a VM              |
+| `download` |       | Download files from a VM          |
+
+## Development
+
+To use your local build instead of the installed one, link it:
+
+```bash
+bun run build
+ln -sf "$(pwd)/dist/bin/cli.mjs" ~/.vmsan/bin/vmsan
+```
+
+```bash
+# Dev mode (watch)
+bun run dev
+
+# Run tests
+bun run test
+
+# Type check
+bun run typecheck
+
+# Lint
+bun run lint
+
+# Format
+bun run fmt
+```
+
+## Project structure
+
+```
+bin/            CLI entry point
+src/
+  commands/     CLI subcommands
+  services/     Firecracker client, agent client, VM service
+  lib/          Utilities (jailer, networking, shell, logging)
+  errors/       Typed error system
+  generated/    Firecracker API type definitions
+agent/          Go agent that runs inside the VM
+```
+
+## How it works
+
+1. **vmsan** uses [Firecracker](https://github.com/firecracker-microvm/firecracker) to create lightweight microVMs with a jailer for security isolation
+2. Each VM gets a TAP network device with its own `/30` subnet (`172.16.{slot}.0/30`)
+3. A Go-based **agent** runs inside the VM, exposing an HTTP API on port 9119 for command execution, file operations, and shell access
+4. The CLI communicates with the agent over the host-guest network to manage the VM
+
+State is persisted in `~/.vmsan/`:
+
+```
+~/.vmsan/
+  vms/          VM state files (JSON)
+  jailer/       Chroot directories
+  bin/          Agent binary
+  kernels/      VM kernel images
+  rootfs/       Base root filesystems
+  registry/     Docker image rootfs cache
+  snapshots/    VM snapshots
+```
+
+## License
+
+[MIT](./LICENSE)
+
+<!-- automd:contributors author="angelorc" license="MIT" -->
+
+Published under the [MIT](https://github.com/angelorc/vmsan/blob/main/LICENSE) license.
+Made by [@angelorc](https://github.com/angelorc) and [community](https://github.com/angelorc/vmsan/graphs/contributors) 💛
+<br><br>
+<a href="https://github.com/angelorc/vmsan/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=angelorc/vmsan" />
+</a>
+
+<!-- /automd -->
+
+<!-- automd:with-automd -->
+
+---
+
+_🤖 auto updated with [automd](https://automd.unjs.io)_
+
+<!-- /automd -->

package/dist/_chunks/agent.mjs

@@ -0,0 +1,121 @@
+import { createGzip } from "node:zlib";
+import { Readable } from "node:stream";
+import { pack } from "tar-stream";
+var AgentClient = class {
+	constructor(baseUrl, token) {
+		this.baseUrl = baseUrl;
+		this.token = token;
+	}
+	async health() {
+		const res = await fetch(`${this.baseUrl}/health`);
+		if (!res.ok) throw new Error(`Agent health check failed: ${res.status}`);
+		return res.json();
+	}
+	async *run(params) {
+		const res = await fetch(`${this.baseUrl}/exec`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this.token}`
+			},
+			body: JSON.stringify(params)
+		});
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent exec failed (${res.status}): ${text}`);
+		}
+		if (!res.body) throw new Error("Agent exec returned no body");
+		const reader = res.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (trimmed) yield JSON.parse(trimmed);
+			}
+		}
+		if (buffer.trim()) yield JSON.parse(buffer.trim());
+	}
+	async killCommand(cmdId, signal) {
+		const url = `${this.baseUrl}/exec/${cmdId}/kill`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this.token}`
+			},
+			body: signal ? JSON.stringify({ signal }) : void 0
+		});
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent kill failed (${res.status}): ${text}`);
+		}
+	}
+	async writeFiles(files, extractDir) {
+		const tarPack = pack();
+		for (const file of files) tarPack.entry({ name: file.path }, file.content);
+		tarPack.finalize();
+		const gzipped = await tarToGzipBuffer(tarPack);
+		const headers = {
+			"Content-Type": "application/gzip",
+			Authorization: `Bearer ${this.token}`
+		};
+		if (extractDir) headers["X-Extract-Dir"] = extractDir;
+		const res = await fetch(`${this.baseUrl}/files/write`, {
+			method: "POST",
+			headers,
+			body: new Uint8Array(gzipped)
+		});
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent writeFiles failed (${res.status}): ${text}`);
+		}
+	}
+	async listShellSessions() {
+		const res = await fetch(`${this.baseUrl}/shell/sessions`, { headers: { Authorization: `Bearer ${this.token}` } });
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent listShellSessions failed (${res.status}): ${text}`);
+		}
+		return res.json();
+	}
+	async killShellSession(sessionId) {
+		const res = await fetch(`${this.baseUrl}/shell/sessions/${sessionId}/kill`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${this.token}` }
+		});
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent killShellSession failed (${res.status}): ${text}`);
+		}
+	}
+	async readFile(path) {
+		const res = await fetch(`${this.baseUrl}/files/read`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${this.token}`
+			},
+			body: JSON.stringify({ path })
+		});
+		if (res.status === 404) return null;
+		if (!res.ok) {
+			const text = await res.text();
+			throw new Error(`Agent readFile failed (${res.status}): ${text}`);
+		}
+		return Buffer.from(await res.arrayBuffer());
+	}
+};
+async function tarToGzipBuffer(tarPack) {
+	const gzip = createGzip();
+	Readable.from(tarPack).pipe(gzip);
+	const chunks = [];
+	for await (const chunk of gzip) chunks.push(Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+export { AgentClient as t };

package/dist/_chunks/cleanup.mjs

@@ -0,0 +1,328 @@
+import { o as safeKill, t as FileVmStateStore } from "./vm-state.mjs";
+import { a as getVmPid, c as NetworkManager, i as getVmJailerPid } from "./environment.mjs";
+import { dirname, join } from "node:path";
+import { execFileSync, execSync } from "node:child_process";
+import { copyFileSync, existsSync, linkSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+/**
+* Template generators for the node22-demo runtime welcome page.
+* All functions are pure and return string content ready to write to files.
+*/
+function generateWelcomeHtml(vmId, ports) {
+	ports.map((p) => `<li>${p}</li>`).join("\n            ");
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>vmsan VM ${vmId}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background: #0f172a;
+      color: #e2e8f0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 2rem;
+    }
+    .container { max-width: 640px; width: 100%; }
+    .header { text-align: center; margin-bottom: 2rem; }
+    .logo {
+      font-size: 2.5rem;
+      font-weight: 800;
+      background: linear-gradient(135deg, #f97316, #ef4444);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+    .subtitle { color: #94a3b8; margin-top: 0.5rem; font-size: 1.1rem; }
+    .card {
+      background: #1e293b;
+      border: 1px solid #334155;
+      border-radius: 12px;
+      padding: 1.5rem;
+      margin-bottom: 1.25rem;
+    }
+    .card h2 { font-size: 1rem; color: #f97316; margin-bottom: 0.75rem; }
+    .info-row { display: flex; justify-content: space-between; padding: 0.35rem 0; }
+    .info-label { color: #94a3b8; }
+    .info-value { font-family: monospace; color: #e2e8f0; }
+    ul { list-style: none; }
+    ul li { padding: 0.25rem 0; }
+    code {
+      background: #0f172a;
+      border: 1px solid #334155;
+      border-radius: 6px;
+      padding: 0.2rem 0.5rem;
+      font-size: 0.875rem;
+      color: #f97316;
+    }
+    .steps li { padding: 0.5rem 0; color: #cbd5e1; }
+    .steps li strong { color: #e2e8f0; }
+    .footer { text-align: center; color: #475569; font-size: 0.85rem; margin-top: 1.5rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <div class="logo">vmsan</div>
+      <div class="subtitle">Your microVM is running</div>
+    </div>
+    <div class="card">
+      <h2>VM Info</h2>
+      <div class="info-row">
+        <span class="info-label">VM ID</span>
+        <span class="info-value">${vmId}</span>
+      </div>
+      <div class="info-row">
+        <span class="info-label">Runtime</span>
+        <span class="info-value">node22-demo</span>
+      </div>
+      <div class="info-row">
+        <span class="info-label">Published Ports</span>
+        <span class="info-value">${ports.join(", ")}</span>
+      </div>
+    </div>
+    <div class="card">
+      <h2>Next Steps</h2>
+      <ul class="steps">
+        <li><strong>Connect to the VM:</strong> <code>vmsan connect ${vmId}</code></li>
+        <li><strong>Deploy your app:</strong> Replace this page by stopping the welcome service and running your own server on the published port(s).</li>
+        <li><strong>Stop this page:</strong> <code>systemctl stop vmsan-welcome</code></li>
+      </ul>
+    </div>
+    <div class="footer">Powered by vmsan &middot; Firecracker microVMs</div>
+  </div>
+</body>
+</html>`;
+}
+function generateWelcomeServer(ports) {
+	return `"use strict";
+const http = require("node:http");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const html = fs.readFileSync(path.join(__dirname, "index.html"), "utf-8");
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-cache",
+  });
+  res.end(html);
+});
+
+${ports.map((p) => `server.listen(${p}, "0.0.0.0", () => console.log("vmsan-welcome listening on 0.0.0.0:${p}"));`).join("\n")}
+`;
+}
+function generateWelcomeService(ports) {
+	return `[Unit]
+Description=${`vmsan welcome page on port(s) ${ports.join(", ")}`}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/usr/local/bin/node /opt/vmsan/welcome/server.js
+Restart=on-failure
+RestartSec=2
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+/**
+* Template generators for the vmsan-agent systemd service.
+* Follows the same pattern as welcome-page.ts.
+*/
+function generateAgentService() {
+	return `[Unit]
+Description=Vmsan VM Agent
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/usr/local/bin/vmsan-agent
+EnvironmentFile=/etc/vmsan/agent.env
+Restart=always
+RestartSec=2
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function generateAgentEnv(token, port, vmId) {
+	return `VMSAN_AGENT_TOKEN=${token}
+VMSAN_AGENT_PORT=${port}
+VMSAN_VM_ID=${vmId}
+`;
+}
+function detectCgroupVersion() {
+	try {
+		readFileSync("/sys/fs/cgroup/cgroup.controllers", "utf-8");
+		return 2;
+	} catch {
+		return 1;
+	}
+}
+var Jailer = class {
+	paths;
+	constructor(vmId, jailerBaseDir) {
+		this.vmId = vmId;
+		const chrootBase = jailerBaseDir;
+		const chrootDir = join(chrootBase, "firecracker", vmId);
+		const rootDir = join(chrootDir, "root");
+		const kernelDir = join(rootDir, "kernel");
+		const rootfsDir = join(rootDir, "rootfs");
+		const socketDir = join(rootDir, "run");
+		const snapshotDir = join(rootDir, "snapshot");
+		this.paths = {
+			chrootBase,
+			chrootDir,
+			rootDir,
+			kernelDir,
+			kernelPath: join(kernelDir, "vmlinux"),
+			rootfsDir,
+			rootfsPath: join(rootfsDir, "rootfs.ext4"),
+			socketDir,
+			socketPath: join(socketDir, "firecracker.socket"),
+			snapshotDir
+		};
+	}
+	prepare(config) {
+		const paths = this.paths;
+		mkdirSync(paths.kernelDir, { recursive: true });
+		mkdirSync(paths.rootfsDir, { recursive: true });
+		mkdirSync(paths.socketDir, { recursive: true });
+		if (!existsSync(paths.kernelPath)) linkSync(config.kernelSrc, paths.kernelPath);
+		copyFileSync(config.rootfsSrc, paths.rootfsPath);
+		if (typeof config.diskSizeGb === "number" && Number.isFinite(config.diskSizeGb)) {
+			const targetBytes = Math.trunc(config.diskSizeGb * 1024 * 1024 * 1024);
+			if (targetBytes > statSync(paths.rootfsPath).size) {
+				execSync(`truncate -s ${targetBytes} "${paths.rootfsPath}"`, { stdio: "pipe" });
+				execSync(`sudo e2fsck -fy "${paths.rootfsPath}"; [ $? -lt 4 ]`, { stdio: "pipe" });
+				execSync(`sudo resize2fs "${paths.rootfsPath}"`, { stdio: "pipe" });
+				execSync(`sudo tune2fs -m 0 "${paths.rootfsPath}"`, { stdio: "pipe" });
+			}
+		}
+		const tmpMount = join(paths.rootDir, "tmp-mount");
+		mkdirSync(tmpMount, { recursive: true });
+		try {
+			execSync(`sudo mount -o loop "${paths.rootfsPath}" "${tmpMount}"`, { stdio: "pipe" });
+			execSync(`rm -f "${tmpMount}/etc/resolv.conf" && ln -s /proc/net/pnp "${tmpMount}/etc/resolv.conf"`, { stdio: "pipe" });
+			if (config.welcomePage) {
+				const { vmId: welcomeVmId, ports: welcomePorts } = config.welcomePage;
+				const welcomeDir = join(tmpMount, "opt", "vmsan", "welcome");
+				mkdirSync(welcomeDir, { recursive: true });
+				writeFileSync(join(welcomeDir, "index.html"), generateWelcomeHtml(welcomeVmId, welcomePorts));
+				writeFileSync(join(welcomeDir, "server.js"), generateWelcomeServer(welcomePorts));
+				const systemdDir = join(tmpMount, "etc", "systemd", "system");
+				mkdirSync(systemdDir, { recursive: true });
+				writeFileSync(join(systemdDir, "vmsan-welcome.service"), generateWelcomeService(welcomePorts));
+				const wantsDir = join(systemdDir, "multi-user.target.wants");
+				mkdirSync(wantsDir, { recursive: true });
+				execSync(`ln -sf /etc/systemd/system/vmsan-welcome.service "${join(wantsDir, "vmsan-welcome.service")}"`, { stdio: "pipe" });
+			}
+			if (config.agent) {
+				const agentDst = join(tmpMount, "usr", "local", "bin", "vmsan-agent");
+				mkdirSync(join(tmpMount, "usr", "local", "bin"), { recursive: true });
+				copyFileSync(config.agent.binaryPath, agentDst);
+				execSync(`chmod 755 "${agentDst}"`, { stdio: "pipe" });
+				const envDir = join(tmpMount, "etc", "vmsan");
+				mkdirSync(envDir, { recursive: true });
+				writeFileSync(join(envDir, "agent.env"), generateAgentEnv(config.agent.token, config.agent.port, config.agent.vmId));
+				const systemdDir = join(tmpMount, "etc", "systemd", "system");
+				mkdirSync(systemdDir, { recursive: true });
+				writeFileSync(join(systemdDir, "vmsan-agent.service"), generateAgentService());
+				const wantsDir = join(systemdDir, "multi-user.target.wants");
+				mkdirSync(wantsDir, { recursive: true });
+				execSync(`ln -sf /etc/systemd/system/vmsan-agent.service "${join(wantsDir, "vmsan-agent.service")}"`, { stdio: "pipe" });
+			}
+			execSync(`sudo umount "${tmpMount}"`, { stdio: "pipe" });
+		} catch {
+			try {
+				execSync(`sudo umount "${tmpMount}" 2>/dev/null`, { stdio: "pipe" });
+			} catch {}
+		}
+		try {
+			execSync(`rm -rf "${tmpMount}"`, { stdio: "pipe" });
+		} catch {}
+		if (config.snapshot) {
+			mkdirSync(paths.snapshotDir, { recursive: true });
+			copyFileSync(config.snapshot.snapshotFile, join(paths.snapshotDir, "snapshot_file"));
+			copyFileSync(config.snapshot.memFile, join(paths.snapshotDir, "mem_file"));
+		}
+		return paths;
+	}
+	spawn(config) {
+		const uid = config.uid ?? 0;
+		const gid = config.gid ?? 0;
+		const args = [
+			config.jailerBin,
+			"--exec-file",
+			config.firecrackerBin,
+			"--id",
+			this.vmId,
+			"--uid",
+			String(uid),
+			"--gid",
+			String(gid),
+			"--chroot-base-dir",
+			config.chrootBase,
+			"--daemonize"
+		];
+		if (config.newPidNs !== false) args.push("--new-pid-ns");
+		if (config.netns) args.push("--netns", `/var/run/netns/${config.netns}`);
+		if (config.cgroup) if (detectCgroupVersion() === 2) {
+			args.push("--cgroup-version", "2");
+			args.push("--cgroup", `cpu.max=${config.cgroup.cpuQuotaUs} ${config.cgroup.cpuPeriodUs}`);
+			args.push("--cgroup", `memory.max=${config.cgroup.memoryBytes}`);
+		} else {
+			args.push("--cgroup", `cpu.cfs_quota_us=${config.cgroup.cpuQuotaUs}`);
+			args.push("--cgroup", `cpu.cfs_period_us=${config.cgroup.cpuPeriodUs}`);
+			args.push("--cgroup", `memory.limit_in_bytes=${config.cgroup.memoryBytes}`);
+		}
+		args.push("--", "--api-sock", "run/firecracker.socket");
+		if (config.seccompFilter && existsSync(config.seccompFilter)) args.push("--seccomp-filter", config.seccompFilter);
+		else args.push("--no-seccomp");
+		execFileSync("sudo", args, { stdio: "pipe" });
+	}
+};
+function killOrphanVmProcess(vmId) {
+	const orphanPid = getVmPid(vmId);
+	const orphanJailerPid = getVmJailerPid(vmId);
+	if (orphanPid) safeKill(orphanPid, "SIGKILL");
+	if (orphanJailerPid) safeKill(orphanJailerPid, "SIGKILL");
+}
+function markVmAsError(vmId, error, paths) {
+	try {
+		new FileVmStateStore(paths.vmsDir).update(vmId, {
+			status: "error",
+			error: error instanceof Error ? error.message : String(error)
+		});
+	} catch {}
+}
+function cleanupNetwork(networkConfig) {
+	if (!networkConfig) return;
+	try {
+		NetworkManager.fromConfig(networkConfig).teardown();
+	} catch {}
+}
+function cleanupChroot(chrootDir) {
+	if (!chrootDir) return;
+	const vmJailerDir = dirname(chrootDir);
+	try {
+		rmSync(chrootDir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	try {
+		rmSync(vmJailerDir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+export { Jailer as a, markVmAsError as i, cleanupNetwork as n, detectCgroupVersion as o, killOrphanVmProcess as r, cleanupChroot as t };

package/dist/_chunks/connect.mjs

@@ -0,0 +1,13 @@
+import { l as agentTimeoutError } from "./errors.mjs";
+async function waitForAgent(guestIp, port, timeoutMs = 6e4) {
+	const start = Date.now();
+	const url = `http://${guestIp}:${port}/health`;
+	while (Date.now() - start < timeoutMs) {
+		try {
+			if ((await fetch(url, { signal: AbortSignal.timeout(2e3) })).ok) return;
+		} catch {}
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	throw agentTimeoutError(guestIp, timeoutMs);
+}
+export { waitForAgent as t };