@vm0/runner 3.5.0 → 3.6.1

package/index.js

@@ -450,7 +450,30 @@ import { exec } from "child_process";
 import { promisify } from "util";
 import * as fs2 from "fs";
 import * as path from "path";
+
+// src/lib/logger.ts
+var _log = null;
+var _error = null;
+function getLog() {
+  return _log ?? console.log.bind(console);
+}
+function getError() {
+  return _error ?? console.error.bind(console);
+}
+function setGlobalLogger(log, error) {
+  _log = log;
+  _error = error ?? log;
+}
+function createLogger(prefix) {
+  return {
+    log: (message) => getLog()(`[${prefix}] ${message}`),
+    error: (message) => getError()(`[${prefix}] ${message}`)
+  };
+}
+
+// src/lib/firecracker/ip-pool.ts
 var execAsync = promisify(exec);
+var logger = createLogger("IP Pool");
 var VM0_RUN_DIR = "/var/run/vm0";
 var REGISTRY_FILE_PATH = path.join(VM0_RUN_DIR, "ip-registry.json");
 var BRIDGE_NAME = "vm0br0";
@@ -564,8 +587,8 @@ function reconcileRegistry(registry, activeTaps) {
     } else if (isWithinGracePeriod) {
       reconciled.allocations[ip] = allocation;
     } else {
-      console.log(
-        `[IP Pool] Removing stale allocation for ${ip} (TAP ${allocation.tapDevice} no longer exists)`
+      logger.log(
+        `Removing stale allocation for ${ip} (TAP ${allocation.tapDevice} no longer exists)`
       );
     }
   }
@@ -593,8 +616,8 @@ async function allocateIP(vmId) {
     }
     const allocatedCount = Object.keys(registry.allocations).length;
     const allocatedIPs = Object.keys(registry.allocations).sort();
-    console.log(
-      `[IP Pool] Current state: ${allocatedCount} IPs allocated [${allocatedIPs.join(", ")}], assigning ${ip}`
+    logger.log(
+      `Current state: ${allocatedCount} IPs allocated [${allocatedIPs.join(", ")}], assigning ${ip}`
     );
     registry.allocations[ip] = {
       vmId,
@@ -602,7 +625,7 @@ async function allocateIP(vmId) {
       allocatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     writeRegistry(registry);
-    console.log(`[IP Pool] Allocated ${ip} for VM ${vmId} (TAP ${tapDevice})`);
+    logger.log(`Allocated ${ip} for VM ${vmId} (TAP ${tapDevice})`);
     return ip;
   });
 }
@@ -613,42 +636,39 @@ async function releaseIP(ip) {
       const allocation = registry.allocations[ip];
       delete registry.allocations[ip];
       writeRegistry(registry);
-      console.log(
-        `[IP Pool] Released ${ip} (was allocated to VM ${allocation.vmId})`
-      );
+      logger.log(`Released ${ip} (was allocated to VM ${allocation.vmId})`);
     } else {
-      console.log(`[IP Pool] IP ${ip} was not in registry, nothing to release`);
+      logger.log(`IP ${ip} was not in registry, nothing to release`);
     }
   });
 }
 async function cleanupOrphanedAllocations() {
   return withLock(async () => {
-    console.log("[IP Pool] Cleaning up orphaned allocations...");
+    logger.log("Cleaning up orphaned allocations...");
     const registry = readRegistry();
     const beforeCount = Object.keys(registry.allocations).length;
     if (beforeCount === 0) {
-      console.log("[IP Pool] No allocations in registry, nothing to clean up");
+      logger.log("No allocations in registry, nothing to clean up");
       return;
     }
     const activeTaps = await scanTapDevices();
-    console.log(
-      `[IP Pool] Found ${activeTaps.size} active TAP device(s) on bridge`
-    );
+    logger.log(`Found ${activeTaps.size} active TAP device(s) on bridge`);
     const reconciled = reconcileRegistry(registry, activeTaps);
     const afterCount = Object.keys(reconciled.allocations).length;
     if (afterCount !== beforeCount) {
       writeRegistry(reconciled);
-      console.log(
-        `[IP Pool] Cleaned up ${beforeCount - afterCount} orphaned allocation(s)`
+      logger.log(
+        `Cleaned up ${beforeCount - afterCount} orphaned allocation(s)`
       );
     } else {
-      console.log("[IP Pool] No orphaned allocations found");
+      logger.log("No orphaned allocations found");
     }
   });
 }
 
 // src/lib/firecracker/network.ts
 var execAsync2 = promisify2(exec2);
+var logger2 = createLogger("Network");
 var BRIDGE_NAME2 = "vm0br0";
 var BRIDGE_IP = "172.16.0.1";
 var BRIDGE_NETMASK = "255.255.255.0";
@@ -700,28 +720,28 @@ async function getDefaultInterface() {
 }
 async function setupForwardRules() {
   const extIface = await getDefaultInterface();
-  console.log(`Setting up FORWARD rules for ${BRIDGE_NAME2} <-> ${extIface}`);
+  logger2.log(`Setting up FORWARD rules for ${BRIDGE_NAME2} <-> ${extIface}`);
   try {
     await execCommand(
       `iptables -C FORWARD -i ${BRIDGE_NAME2} -o ${extIface} -j ACCEPT`
     );
-    console.log("FORWARD outbound rule already exists");
+    logger2.log("FORWARD outbound rule already exists");
   } catch {
     await execCommand(
       `iptables -I FORWARD -i ${BRIDGE_NAME2} -o ${extIface} -j ACCEPT`
     );
-    console.log("FORWARD outbound rule added");
+    logger2.log("FORWARD outbound rule added");
   }
   try {
     await execCommand(
       `iptables -C FORWARD -i ${extIface} -o ${BRIDGE_NAME2} -m state --state RELATED,ESTABLISHED -j ACCEPT`
     );
-    console.log("FORWARD inbound rule already exists");
+    logger2.log("FORWARD inbound rule already exists");
   } catch {
     await execCommand(
       `iptables -I FORWARD -i ${extIface} -o ${BRIDGE_NAME2} -m state --state RELATED,ESTABLISHED -j ACCEPT`
     );
-    console.log("FORWARD inbound rule added");
+    logger2.log("FORWARD inbound rule added");
   }
 }
 async function bridgeExists() {
@@ -734,11 +754,11 @@ async function bridgeExists() {
 }
 async function setupBridge() {
   if (await bridgeExists()) {
-    console.log(`Bridge ${BRIDGE_NAME2} already exists`);
+    logger2.log(`Bridge ${BRIDGE_NAME2} already exists`);
     await setupForwardRules();
     return;
   }
-  console.log(`Creating bridge ${BRIDGE_NAME2}...`);
+  logger2.log(`Creating bridge ${BRIDGE_NAME2}...`);
   await execCommand(`ip link add name ${BRIDGE_NAME2} type bridge`);
   await execCommand(
     `ip addr add ${BRIDGE_IP}/${BRIDGE_NETMASK} dev ${BRIDGE_NAME2}`
@@ -749,15 +769,15 @@ async function setupBridge() {
     await execCommand(
       `iptables -t nat -C POSTROUTING -s ${BRIDGE_CIDR} -j MASQUERADE`
     );
-    console.log("NAT rule already exists");
+    logger2.log("NAT rule already exists");
   } catch {
     await execCommand(
       `iptables -t nat -A POSTROUTING -s ${BRIDGE_CIDR} -j MASQUERADE`
     );
-    console.log("NAT rule added");
+    logger2.log("NAT rule added");
   }
   await setupForwardRules();
-  console.log(`Bridge ${BRIDGE_NAME2} configured with IP ${BRIDGE_IP}`);
+  logger2.log(`Bridge ${BRIDGE_NAME2} configured with IP ${BRIDGE_IP}`);
 }
 async function tapDeviceExists(tapDevice) {
   try {
@@ -777,7 +797,7 @@ async function clearStaleIptablesRulesForIP(ip) {
     if (rulesForIP.length === 0) {
       return;
     }
-    console.log(
+    logger2.log(
       `Clearing ${rulesForIP.length} stale iptables rule(s) for IP ${ip}`
     );
     for (const rule of rulesForIP) {
@@ -790,24 +810,27 @@ async function clearStaleIptablesRulesForIP(ip) {
   } catch {
   }
 }
-async function createTapDevice(vmId, logger) {
-  const log = logger ?? console.log;
+async function createTapDevice(vmId) {
   const tapDevice = `tap${vmId.substring(0, 8)}`;
   const guestMac = generateMacAddress(vmId);
   const guestIp = await allocateIP(vmId);
-  log(`[VM ${vmId}] IP allocated: ${guestIp}`);
+  logger2.log(`[VM ${vmId}] IP allocated: ${guestIp}`);
   await clearStaleIptablesRulesForIP(guestIp);
-  log(`[VM ${vmId}] Stale iptables cleared`);
+  logger2.log(`[VM ${vmId}] Stale iptables cleared`);
   if (await tapDeviceExists(tapDevice)) {
-    log(`[VM ${vmId}] TAP device ${tapDevice} already exists, deleting...`);
+    logger2.log(
+      `[VM ${vmId}] TAP device ${tapDevice} already exists, deleting...`
+    );
     await deleteTapDevice(tapDevice);
   }
   await execCommand(`ip tuntap add ${tapDevice} mode tap`);
-  log(`[VM ${vmId}] TAP device created`);
+  logger2.log(`[VM ${vmId}] TAP device created`);
   await execCommand(`ip link set ${tapDevice} master ${BRIDGE_NAME2}`);
-  log(`[VM ${vmId}] TAP added to bridge`);
+  logger2.log(`[VM ${vmId}] TAP added to bridge`);
   await execCommand(`ip link set ${tapDevice} up`);
-  log(`[VM ${vmId}] TAP created: ${tapDevice}, MAC ${guestMac}, IP ${guestIp}`);
+  logger2.log(
+    `[VM ${vmId}] TAP created: ${tapDevice}, MAC ${guestMac}, IP ${guestIp}`
+  );
   return {
     tapDevice,
     guestMac,
@@ -818,15 +841,15 @@ async function createTapDevice(vmId, logger) {
 }
 async function deleteTapDevice(tapDevice, guestIp) {
   if (!await tapDeviceExists(tapDevice)) {
-    console.log(`TAP device ${tapDevice} does not exist, skipping delete`);
+    logger2.log(`TAP device ${tapDevice} does not exist, skipping delete`);
   } else {
     await execCommand(`ip link delete ${tapDevice}`);
-    console.log(`TAP device ${tapDevice} deleted`);
+    logger2.log(`TAP device ${tapDevice} deleted`);
   }
   if (guestIp) {
     try {
       await execCommand(`ip neigh del ${guestIp} dev ${BRIDGE_NAME2}`, true);
-      console.log(`ARP entry cleared for ${guestIp}`);
+      logger2.log(`ARP entry cleared for ${guestIp}`);
     } catch {
     }
   }
@@ -857,53 +880,51 @@ function checkNetworkPrerequisites() {
     errors
   };
 }
-async function setupVMProxyRules(vmIp, proxyPort, runnerName) {
-  const comment = `vm0:runner:${runnerName}`;
-  console.log(
-    `Setting up proxy rules for VM ${vmIp} -> localhost:${proxyPort} (comment: ${comment})`
+async function setupCIDRProxyRules(proxyPort) {
+  const comment = "vm0:cidr-proxy";
+  logger2.log(
+    `Setting up CIDR proxy rules for ${BRIDGE_CIDR} -> port ${proxyPort}`
   );
   try {
     await execCommand(
-      `iptables -t nat -C PREROUTING -s ${vmIp} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -C PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:80 already exists`);
+    logger2.log("CIDR proxy rule for port 80 already exists");
   } catch {
     await execCommand(
-      `iptables -t nat -A PREROUTING -s ${vmIp} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -A PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:80 added`);
+    logger2.log("CIDR proxy rule for port 80 added");
   }
   try {
     await execCommand(
-      `iptables -t nat -C PREROUTING -s ${vmIp} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -C PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:443 already exists`);
+    logger2.log("CIDR proxy rule for port 443 already exists");
   } catch {
     await execCommand(
-      `iptables -t nat -A PREROUTING -s ${vmIp} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -A PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:443 added`);
+    logger2.log("CIDR proxy rule for port 443 added");
   }
-  console.log(`Proxy rules configured for VM ${vmIp}`);
 }
-async function removeVMProxyRules(vmIp, proxyPort, runnerName) {
-  const comment = `vm0:runner:${runnerName}`;
-  console.log(`Removing proxy rules for VM ${vmIp}...`);
+async function cleanupCIDRProxyRules(proxyPort) {
+  const comment = "vm0:cidr-proxy";
+  logger2.log("Cleaning up CIDR proxy rules...");
   try {
     await execCommand(
-      `iptables -t nat -D PREROUTING -s ${vmIp} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -D PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 80 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:80 removed`);
+    logger2.log("CIDR proxy rule for port 80 removed");
   } catch {
   }
   try {
     await execCommand(
-      `iptables -t nat -D PREROUTING -s ${vmIp} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
+      `iptables -t nat -D PREROUTING -s ${BRIDGE_CIDR} -p tcp --dport 443 -j REDIRECT --to-port ${proxyPort} -m comment --comment "${comment}"`
     );
-    console.log(`Proxy rule for ${vmIp}:443 removed`);
+    logger2.log("CIDR proxy rule for port 443 removed");
   } catch {
   }
-  console.log(`Proxy rules cleanup complete for VM ${vmIp}`);
 }
 async function listTapDevices() {
   try {
@@ -980,17 +1001,17 @@ async function findOrphanedIptablesRules(rules, activeVmIps, expectedProxyPort)
   return orphaned;
 }
 async function flushBridgeArpCache() {
-  console.log(`Flushing ARP cache on bridge ${BRIDGE_NAME2}...`);
+  logger2.log(`Flushing ARP cache on bridge ${BRIDGE_NAME2}...`);
   try {
     if (!await bridgeExists()) {
-      console.log("Bridge does not exist, skipping ARP flush");
+      logger2.log("Bridge does not exist, skipping ARP flush");
       return;
     }
     const { stdout } = await execAsync2(
       `ip neigh show dev ${BRIDGE_NAME2} 2>/dev/null || true`
     );
     if (!stdout.trim()) {
-      console.log("No ARP entries on bridge");
+      logger2.log("No ARP entries on bridge");
       return;
     }
     const lines = stdout.split("\n").filter((line) => line.trim());
@@ -1006,38 +1027,38 @@ async function flushBridgeArpCache() {
         }
       }
     }
-    console.log(`Cleared ${cleared} ARP entries from bridge`);
+    logger2.log(`Cleared ${cleared} ARP entries from bridge`);
   } catch (error) {
-    console.log(
+    logger2.log(
       `Warning: Could not flush ARP cache: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
 }
 async function cleanupOrphanedProxyRules(runnerName) {
   const comment = `vm0:runner:${runnerName}`;
-  console.log(`Cleaning up orphaned proxy rules for runner '${runnerName}'...`);
+  logger2.log(`Cleaning up orphaned proxy rules for runner '${runnerName}'...`);
   try {
     const rules = await execCommand("iptables -t nat -S PREROUTING", false);
     const ourRules = rules.split("\n").filter((rule) => rule.includes(comment));
     if (ourRules.length === 0) {
-      console.log("No orphaned proxy rules found");
+      logger2.log("No orphaned proxy rules found");
       return;
     }
-    console.log(`Found ${ourRules.length} orphaned rule(s) to clean up`);
+    logger2.log(`Found ${ourRules.length} orphaned rule(s) to clean up`);
     for (const rule of ourRules) {
       const deleteRule = rule.replace("-A ", "-D ");
       try {
         await execCommand(`iptables -t nat ${deleteRule}`);
-        console.log(`Deleted orphaned rule: ${rule.substring(0, 80)}...`);
+        logger2.log(`Deleted orphaned rule: ${rule.substring(0, 80)}...`);
       } catch {
-        console.log(
+        logger2.log(
           `Failed to delete rule (may already be gone): ${rule.substring(0, 80)}...`
         );
       }
     }
-    console.log("Orphaned proxy rules cleanup complete");
+    logger2.log("Orphaned proxy rules cleanup complete");
   } catch (error) {
-    console.log(
+    logger2.log(
       `Warning: Could not clean up orphaned rules: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
@@ -1045,6 +1066,7 @@ async function cleanupOrphanedProxyRules(runnerName) {
 
 // src/lib/firecracker/vm.ts
 var execAsync3 = promisify3(exec3);
+var logger3 = createLogger("VM");
 var FirecrackerVM = class {
   config;
   process = null;
@@ -1064,9 +1086,6 @@ var FirecrackerVM = class {
     this.vmOverlayPath = path2.join(this.workDir, "overlay.ext4");
     this.vsockPath = path2.join(this.workDir, "vsock.sock");
   }
-  log(msg) {
-    (this.config.logger ?? console.log)(msg);
-  }
   /**
    * Get current VM state
    */
@@ -1110,21 +1129,21 @@ var FirecrackerVM = class {
       if (fs3.existsSync(this.socketPath)) {
         fs3.unlinkSync(this.socketPath);
       }
-      this.log(`[VM ${this.config.vmId}] Setting up overlay and network...`);
+      logger3.log(`[VM ${this.config.vmId}] Setting up overlay and network...`);
       const createOverlay = async () => {
         const overlaySize = 2 * 1024 * 1024 * 1024;
         const fd = fs3.openSync(this.vmOverlayPath, "w");
         fs3.ftruncateSync(fd, overlaySize);
         fs3.closeSync(fd);
         await execAsync3(`mkfs.ext4 -F -q "${this.vmOverlayPath}"`);
-        this.log(`[VM ${this.config.vmId}] Overlay created`);
+        logger3.log(`[VM ${this.config.vmId}] Overlay created`);
       };
       const [, networkConfig] = await Promise.all([
         createOverlay(),
-        createTapDevice(this.config.vmId, this.log.bind(this))
+        createTapDevice(this.config.vmId)
       ]);
       this.networkConfig = networkConfig;
-      this.log(`[VM ${this.config.vmId}] Starting Firecracker...`);
+      logger3.log(`[VM ${this.config.vmId}] Starting Firecracker...`);
       this.process = spawn(
         this.config.firecrackerBinary,
         ["--api-sock", this.socketPath],
@@ -1135,11 +1154,11 @@ var FirecrackerVM = class {
         }
       );
       this.process.on("error", (err) => {
-        this.log(`[VM ${this.config.vmId}] Firecracker error: ${err}`);
+        logger3.log(`[VM ${this.config.vmId}] Firecracker error: ${err}`);
         this.state = "error";
       });
       this.process.on("exit", (code, signal) => {
-        this.log(
+        logger3.log(
           `[VM ${this.config.vmId}] Firecracker exited: code=${code}, signal=${signal}`
         );
         if (this.state !== "stopped") {
@@ -1152,7 +1171,7 @@ var FirecrackerVM = class {
         });
         stdoutRL.on("line", (line) => {
           if (line.trim()) {
-            this.log(`[VM ${this.config.vmId}] ${line}`);
+            logger3.log(`[VM ${this.config.vmId}] ${line}`);
           }
         });
       }
@@ -1162,19 +1181,19 @@ var FirecrackerVM = class {
         });
         stderrRL.on("line", (line) => {
           if (line.trim()) {
-            this.log(`[VM ${this.config.vmId}] stderr: ${line}`);
+            logger3.log(`[VM ${this.config.vmId}] stderr: ${line}`);
           }
         });
       }
       this.client = new FirecrackerClient(this.socketPath);
-      this.log(`[VM ${this.config.vmId}] Waiting for API...`);
+      logger3.log(`[VM ${this.config.vmId}] Waiting for API...`);
       await this.client.waitUntilReady(1e4, 100);
       this.state = "configuring";
       await this.configure();
-      this.log(`[VM ${this.config.vmId}] Booting...`);
+      logger3.log(`[VM ${this.config.vmId}] Booting...`);
       await this.client.start();
       this.state = "running";
-      this.log(
+      logger3.log(
         `[VM ${this.config.vmId}] Running at ${this.networkConfig.guestIp}`
       );
     } catch (error) {
@@ -1190,7 +1209,7 @@ var FirecrackerVM = class {
     if (!this.client || !this.networkConfig) {
       throw new Error("VM not properly initialized");
     }
-    this.log(
+    logger3.log(
       `[VM ${this.config.vmId}] Configuring: ${this.config.vcpus} vCPUs, ${this.config.memoryMb}MB RAM`
     );
     await this.client.setMachineConfig({
@@ -1199,26 +1218,28 @@ var FirecrackerVM = class {
     });
     const networkBootArgs = generateNetworkBootArgs(this.networkConfig);
     const bootArgs = `console=ttyS0 reboot=k panic=1 pci=off nomodules random.trust_cpu=on quiet loglevel=0 nokaslr audit=0 numa=off mitigations=off noresume init=/sbin/vm-init ${networkBootArgs}`;
-    this.log(`[VM ${this.config.vmId}] Boot args: ${bootArgs}`);
+    logger3.log(`[VM ${this.config.vmId}] Boot args: ${bootArgs}`);
     await this.client.setBootSource({
       kernel_image_path: this.config.kernelPath,
       boot_args: bootArgs
     });
-    this.log(`[VM ${this.config.vmId}] Base rootfs: ${this.config.rootfsPath}`);
+    logger3.log(
+      `[VM ${this.config.vmId}] Base rootfs: ${this.config.rootfsPath}`
+    );
     await this.client.setDrive({
       drive_id: "rootfs",
       path_on_host: this.config.rootfsPath,
       is_root_device: true,
       is_read_only: true
     });
-    this.log(`[VM ${this.config.vmId}] Overlay: ${this.vmOverlayPath}`);
+    logger3.log(`[VM ${this.config.vmId}] Overlay: ${this.vmOverlayPath}`);
     await this.client.setDrive({
       drive_id: "overlay",
       path_on_host: this.vmOverlayPath,
       is_root_device: false,
       is_read_only: false
     });
-    this.log(
+    logger3.log(
       `[VM ${this.config.vmId}] Network: ${this.networkConfig.tapDevice}`
     );
     await this.client.setNetworkInterface({
@@ -1226,7 +1247,7 @@ var FirecrackerVM = class {
       guest_mac: this.networkConfig.guestMac,
       host_dev_name: this.networkConfig.tapDevice
     });
-    this.log(`[VM ${this.config.vmId}] Vsock: ${this.vsockPath}`);
+    logger3.log(`[VM ${this.config.vmId}] Vsock: ${this.vsockPath}`);
     await this.client.setVsock({
       vsock_id: "vsock0",
       guest_cid: 3,
@@ -1238,15 +1259,15 @@ var FirecrackerVM = class {
    */
   async stop() {
     if (this.state !== "running") {
-      this.log(`[VM ${this.config.vmId}] Not running, state: ${this.state}`);
+      logger3.log(`[VM ${this.config.vmId}] Not running, state: ${this.state}`);
       return;
     }
     this.state = "stopping";
-    this.log(`[VM ${this.config.vmId}] Stopping...`);
+    logger3.log(`[VM ${this.config.vmId}] Stopping...`);
     try {
       if (this.client) {
         await this.client.sendCtrlAltDel().catch((error) => {
-          this.log(
+          logger3.log(
             `[VM ${this.config.vmId}] Graceful shutdown signal failed (VM may already be stopping): ${error instanceof Error ? error.message : error}`
           );
         });
@@ -1259,7 +1280,7 @@ var FirecrackerVM = class {
    * Force kill the VM
    */
   async kill() {
-    this.log(`[VM ${this.config.vmId}] Force killing...`);
+    logger3.log(`[VM ${this.config.vmId}] Force killing...`);
     await this.cleanup();
   }
   /**
@@ -1284,7 +1305,7 @@ var FirecrackerVM = class {
     }
     this.client = null;
     this.state = "stopped";
-    this.log(`[VM ${this.config.vmId}] Stopped`);
+    logger3.log(`[VM ${this.config.vmId}] Stopped`);
   }
   /**
    * Wait for the VM process to exit
@@ -1325,6 +1346,9 @@ var MSG_PING = 1;
 var MSG_PONG = 2;
 var MSG_EXEC = 3;
 var MSG_WRITE_FILE = 5;
+var MSG_SPAWN_WATCH = 7;
+var MSG_SPAWN_WATCH_RESULT = 8;
+var MSG_PROCESS_EXIT = 9;
 var MSG_ERROR = 255;
 var FLAG_SUDO = 1;
 function encode(type, seq, payload = Buffer.alloc(0)) {
@@ -1363,33 +1387,90 @@ function encodeWriteFilePayload(path6, content, sudo) {
   return payload;
 }
 function decodeExecResult(payload) {
-  if (payload.length < 8) {
-    return { exitCode: 1, stdout: "", stderr: "Invalid exec_result payload" };
+  if (payload.length < 12) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Invalid exec_result payload: too short"
+    };
   }
   const exitCode = payload.readInt32BE(0);
   const stdoutLen = payload.readUInt32BE(4);
-  const stdout = payload.subarray(8, 8 + stdoutLen).toString("utf-8");
   const stderrLenOffset = 8 + stdoutLen;
+  if (payload.length < stderrLenOffset + 4) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Invalid exec_result payload: stdout truncated"
+    };
+  }
+  const stdout = payload.subarray(8, 8 + stdoutLen).toString("utf-8");
   const stderrLen = payload.readUInt32BE(stderrLenOffset);
+  const expectedLen = stderrLenOffset + 4 + stderrLen;
+  if (payload.length < expectedLen) {
+    return {
+      exitCode: 1,
+      stdout,
+      stderr: "Invalid exec_result payload: stderr truncated"
+    };
+  }
   const stderr = payload.subarray(stderrLenOffset + 4, stderrLenOffset + 4 + stderrLen).toString("utf-8");
   return { exitCode, stdout, stderr };
 }
 function decodeWriteFileResult(payload) {
   if (payload.length < 3) {
-    return { success: false, error: "Invalid write_file_result payload" };
+    return {
+      success: false,
+      error: "Invalid write_file_result payload: too short"
+    };
   }
   const success = payload.readUInt8(0) === 1;
   const errorLen = payload.readUInt16BE(1);
+  if (payload.length < 3 + errorLen) {
+    return {
+      success: false,
+      error: "Invalid write_file_result payload: error truncated"
+    };
+  }
   const error = payload.subarray(3, 3 + errorLen).toString("utf-8");
   return { success, error };
 }
 function decodeError(payload) {
   if (payload.length < 2) {
-    return "Invalid error payload";
+    return "Invalid error payload: too short";
   }
   const errorLen = payload.readUInt16BE(0);
+  if (payload.length < 2 + errorLen) {
+    return "Invalid error payload: message truncated";
+  }
   return payload.subarray(2, 2 + errorLen).toString("utf-8");
 }
+function decodeSpawnWatchResult(payload) {
+  if (payload.length < 4) {
+    throw new Error("Invalid spawn_watch_result payload");
+  }
+  return { pid: payload.readUInt32BE(0) };
+}
+function decodeProcessExit(payload) {
+  if (payload.length < 16) {
+    throw new Error("Invalid process_exit payload: too short");
+  }
+  const pid = payload.readUInt32BE(0);
+  const exitCode = payload.readInt32BE(4);
+  const stdoutLen = payload.readUInt32BE(8);
+  const stderrLenOffset = 12 + stdoutLen;
+  if (payload.length < stderrLenOffset + 4) {
+    throw new Error("Invalid process_exit payload: stdout truncated");
+  }
+  const stdout = payload.subarray(12, 12 + stdoutLen).toString("utf-8");
+  const stderrLen = payload.readUInt32BE(stderrLenOffset);
+  const expectedLen = stderrLenOffset + 4 + stderrLen;
+  if (payload.length < expectedLen) {
+    throw new Error("Invalid process_exit payload: stderr truncated");
+  }
+  const stderr = payload.subarray(stderrLenOffset + 4, stderrLenOffset + 4 + stderrLen).toString("utf-8");
+  return { pid, exitCode, stdout, stderr };
+}
 var Decoder = class {
   buf = Buffer.alloc(0);
   decode(data) {
@@ -1421,6 +1502,9 @@ var VsockClient = class {
   connected = false;
   nextSeq = 1;
   pendingRequests = /* @__PURE__ */ new Map();
+  pendingExits = /* @__PURE__ */ new Map();
+  // Cache for exit events that arrive before waitForExit is called
+  cachedExits = /* @__PURE__ */ new Map();
   constructor(vsockPath) {
     this.vsockPath = vsockPath;
   }
@@ -1437,6 +1521,21 @@ var VsockClient = class {
    * Handle incoming message and route to pending request
    */
   handleMessage(msg) {
+    if (msg.type === MSG_PROCESS_EXIT && msg.seq === 0) {
+      const event = decodeProcessExit(msg.payload);
+      const pending2 = this.pendingExits.get(event.pid);
+      if (pending2) {
+        if (pending2.timeout) clearTimeout(pending2.timeout);
+        this.pendingExits.delete(event.pid);
+        pending2.resolve(event);
+      } else if (!this.cachedExits.has(event.pid)) {
+        this.cachedExits.set(event.pid, {
+          event,
+          timestamp: Date.now()
+        });
+      }
+      return;
+    }
     const pending = this.pendingRequests.get(msg.seq);
     if (pending) {
       clearTimeout(pending.timeout);
@@ -1640,7 +1739,11 @@ var VsockClient = class {
                 this.connected = true;
                 resolve();
               } else if (state === 2 /* Connected */) {
-                this.handleMessage(msg);
+                try {
+                  this.handleMessage(msg);
+                } catch (msgErr) {
+                  console.error(`[vsock] Error handling message: ${msgErr}`);
+                }
               }
             }
           } catch (e) {
@@ -1656,12 +1759,19 @@ var VsockClient = class {
           }
           this.connected = false;
           this.socket = null;
-          const pending = Array.from(this.pendingRequests.values());
+          const pendingReqs = Array.from(this.pendingRequests.values());
           this.pendingRequests.clear();
-          for (const req of pending) {
+          for (const req of pendingReqs) {
             clearTimeout(req.timeout);
             req.reject(new Error("Connection closed"));
           }
+          const pendingExits = Array.from(this.pendingExits.values());
+          this.pendingExits.clear();
+          for (const exit of pendingExits) {
+            if (exit.timeout) clearTimeout(exit.timeout);
+            exit.reject(new Error("Connection closed"));
+          }
+          this.cachedExits.clear();
         });
       });
       server.listen(listenerPath, () => {
@@ -1681,6 +1791,59 @@ var VsockClient = class {
     const result = await this.exec(`test -e '${remotePath}'`);
     return result.exitCode === 0;
   }
+  /**
+   * Spawn a process and monitor for exit (event-driven mode)
+   *
+   * Returns immediately with the PID. Use waitForExit() to wait for completion.
+   * When the process exits, the agent sends an unsolicited notification.
+   */
+  async spawnAndWatch(command, timeoutMs = 0) {
+    const payload = encodeExecPayload(command, timeoutMs);
+    const response = await this.request(
+      MSG_SPAWN_WATCH,
+      payload,
+      3e4
+      // 30s timeout for spawn acknowledgment
+    );
+    if (response.type === MSG_ERROR) {
+      throw new Error(`spawnAndWatch failed: ${decodeError(response.payload)}`);
+    }
+    if (response.type !== MSG_SPAWN_WATCH_RESULT) {
+      throw new Error(
+        `Unexpected response type: 0x${response.type.toString(16)}`
+      );
+    }
+    return decodeSpawnWatchResult(response.payload);
+  }
+  /**
+   * Wait for a spawned process to exit
+   *
+   * Blocks until the process exits or timeout is reached.
+   * The exit event is pushed by the guest agent (no polling).
+   */
+  async waitForExit(pid, timeoutMs = 0) {
+    if (!this.connected || !this.socket) {
+      throw new Error("Not connected - cannot wait for process exit");
+    }
+    if (this.pendingExits.has(pid)) {
+      throw new Error(`Already waiting for process ${pid} to exit`);
+    }
+    const cached = this.cachedExits.get(pid);
+    if (cached) {
+      this.cachedExits.delete(pid);
+      return cached.event;
+    }
+    return new Promise((resolve, reject) => {
+      const pending = { resolve, reject };
+      if (timeoutMs > 0) {
+        pending.timeout = setTimeout(() => {
+          this.pendingExits.delete(pid);
+          reject(new Error(`Timeout waiting for process ${pid} to exit`));
+        }, timeoutMs);
+      }
+      this.pendingExits.set(pid, pending);
+    });
+  }
   /**
    * Get the vsock path (for logging/debugging)
    */
@@ -1696,12 +1859,19 @@ var VsockClient = class {
       this.socket = null;
     }
     this.connected = false;
-    const pending = Array.from(this.pendingRequests.values());
+    const pendingRequests = Array.from(this.pendingRequests.values());
     this.pendingRequests.clear();
-    for (const req of pending) {
+    for (const req of pendingRequests) {
       clearTimeout(req.timeout);
       req.reject(new Error("Connection closed"));
     }
+    const pendingExits = Array.from(this.pendingExits.values());
+    this.pendingExits.clear();
+    for (const exit of pendingExits) {
+      if (exit.timeout) clearTimeout(exit.timeout);
+      exit.reject(new Error("Connection closed"));
+    }
+    this.cachedExits.clear();
   }
 };
 
@@ -7114,7 +7284,7 @@ var credentialsByNameContract = c10.router({
       name: credentialNameSchema
     }),
     responses: {
-      204: z16.undefined(),
+      204: c10.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -7210,7 +7380,7 @@ var modelProvidersByTypeContract = c11.router({
       type: modelProviderTypeSchema
     }),
     responses: {
-      204: z17.undefined(),
+      204: c11.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -7495,7 +7665,7 @@ var schedulesByNameContract = c13.router({
       composeId: z19.string().uuid("Compose ID required")
     }),
     responses: {
-      204: z19.undefined(),
+      204: c13.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema
     },
@@ -8340,6 +8510,7 @@ var ENV_LOADER_PATH = "/usr/local/bin/vm0-agent/env-loader.mjs";
 
 // src/lib/proxy/vm-registry.ts
 import fs5 from "fs";
+var logger4 = createLogger("VMRegistry");
 var DEFAULT_REGISTRY_PATH = "/tmp/vm0-vm-registry.json";
 var VMRegistry = class {
   registryPath;
@@ -8386,8 +8557,8 @@ var VMRegistry = class {
     this.save();
     const firewallInfo = options?.firewallRules ? ` with ${options.firewallRules.length} firewall rules` : "";
     const mitmInfo = options?.mitmEnabled ? ", MITM enabled" : "";
-    console.log(
-      `[VMRegistry] Registered VM ${vmIp} for run ${runId}${firewallInfo}${mitmInfo}`
+    logger4.log(
+      `Registered VM ${vmIp} for run ${runId}${firewallInfo}${mitmInfo}`
     );
   }
   /**
@@ -8398,9 +8569,7 @@ var VMRegistry = class {
       const registration = this.data.vms[vmIp];
       delete this.data.vms[vmIp];
       this.save();
-      console.log(
-        `[VMRegistry] Unregistered VM ${vmIp} (run ${registration.runId})`
-      );
+      logger4.log(`Unregistered VM ${vmIp} (run ${registration.runId})`);
     }
   }
   /**
@@ -8421,7 +8590,7 @@ var VMRegistry = class {
   clear() {
     this.data.vms = {};
     this.save();
-    console.log("[VMRegistry] Cleared all registrations");
+    logger4.log("Cleared all registrations");
   }
   /**
    * Get the path to the registry file
@@ -8654,7 +8823,10 @@ def tls_clienthello(data: tls.ClientHelloData) -> None:
 
     vm_info = get_vm_info(client_ip)
     if not vm_info:
-        return  # Not a registered VM, let it through
+        # Not a registered VM - pass through without MITM interception
+        # This is critical for CIDR-based rules where all VM traffic is redirected
+        data.ignore_connection = True
+        return
 
     # If MITM is enabled, let the normal flow handle it
     if vm_info.get("mitmEnabled", False):
@@ -8928,6 +9100,7 @@ addons = [tls_clienthello, request, response]
 `;
 
 // src/lib/proxy/proxy-manager.ts
+var logger5 = createLogger("ProxyManager");
 var DEFAULT_PROXY_OPTIONS = {
   port: 8080,
   registryPath: DEFAULT_REGISTRY_PATH,
@@ -8972,9 +9145,7 @@ var ProxyManager = class {
     fs6.writeFileSync(this.config.addonPath, RUNNER_MITM_ADDON_SCRIPT, {
       mode: 493
     });
-    console.log(
-      `[ProxyManager] Addon script written to ${this.config.addonPath}`
-    );
+    logger5.log(`Addon script written to ${this.config.addonPath}`);
   }
   /**
    * Validate proxy configuration
@@ -8994,7 +9165,7 @@ var ProxyManager = class {
    */
   async start() {
     if (this.isRunning) {
-      console.log("[ProxyManager] Proxy already running");
+      logger5.log("Proxy already running");
       return;
     }
     const mitmproxyInstalled = await this.checkMitmproxyInstalled();
@@ -9005,11 +9176,11 @@ var ProxyManager = class {
     }
     this.validateConfig();
     getVMRegistry();
-    console.log("[ProxyManager] Starting mitmproxy...");
-    console.log(`  Port: ${this.config.port}`);
-    console.log(`  CA Dir: ${this.config.caDir}`);
-    console.log(`  Addon: ${this.config.addonPath}`);
-    console.log(`  Registry: ${this.config.registryPath}`);
+    logger5.log("Starting mitmproxy...");
+    logger5.log(`  Port: ${this.config.port}`);
+    logger5.log(`  CA Dir: ${this.config.caDir}`);
+    logger5.log(`  Addon: ${this.config.addonPath}`);
+    logger5.log(`  Registry: ${this.config.registryPath}`);
     const args = [
       "--mode",
       "transparent",
@@ -9031,25 +9202,26 @@ var ProxyManager = class {
       stdio: ["ignore", "pipe", "pipe"],
       detached: false
     });
+    const mitmLogger = createLogger("mitmproxy");
     this.process.stdout?.on("data", (data) => {
-      console.log(`[mitmproxy] ${data.toString().trim()}`);
+      mitmLogger.log(data.toString().trim());
     });
     this.process.stderr?.on("data", (data) => {
-      console.error(`[mitmproxy] ${data.toString().trim()}`);
+      mitmLogger.log(data.toString().trim());
     });
     this.process.on("close", (code) => {
-      console.log(`[ProxyManager] mitmproxy exited with code ${code}`);
+      logger5.log(`mitmproxy exited with code ${code}`);
       this.isRunning = false;
       this.process = null;
     });
     this.process.on("error", (err) => {
-      console.error(`[ProxyManager] mitmproxy error: ${err.message}`);
+      logger5.error(`mitmproxy error: ${err.message}`);
       this.isRunning = false;
       this.process = null;
     });
     await this.waitForReady();
     this.isRunning = true;
-    console.log("[ProxyManager] mitmproxy started successfully");
+    logger5.log("mitmproxy started successfully");
   }
   /**
    * Wait for proxy to be ready
@@ -9075,24 +9247,24 @@ var ProxyManager = class {
    */
   async stop() {
     if (!this.process || !this.isRunning) {
-      console.log("[ProxyManager] Proxy not running");
+      logger5.log("Proxy not running");
       return;
     }
-    console.log("[ProxyManager] Stopping mitmproxy...");
+    logger5.log("Stopping mitmproxy...");
     return new Promise((resolve) => {
       if (!this.process) {
         resolve();
         return;
       }
       const timeout = setTimeout(() => {
-        console.log("[ProxyManager] Force killing mitmproxy...");
+        logger5.log("Force killing mitmproxy...");
         this.process?.kill("SIGKILL");
       }, 5e3);
       this.process.on("close", () => {
         clearTimeout(timeout);
         this.isRunning = false;
         this.process = null;
-        console.log("[ProxyManager] mitmproxy stopped");
+        logger5.log("mitmproxy stopped");
         resolve();
       });
       this.process.kill("SIGTERM");
@@ -9125,171 +9297,80 @@ function initProxyManager(config) {
   return globalProxyManager;
 }
 
-// src/lib/metrics/provider.ts
-import {
-  MeterProvider,
-  PeriodicExportingMetricReader
-} from "@opentelemetry/sdk-metrics";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
-import { Resource } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { metrics } from "@opentelemetry/api";
-var meterProvider = null;
-var initialized = false;
-var enabled = false;
-var _runnerLabel = "";
-function initMetrics(config) {
-  if (initialized) return;
-  initialized = true;
-  _runnerLabel = config.runnerLabel;
-  if (!config.axiomToken) {
-    console.log("[metrics] AXIOM_TOKEN not configured, metrics disabled");
-    return;
-  }
-  const env = config.environment ?? "dev";
-  const exporter = new OTLPMetricExporter({
-    url: "https://api.axiom.co/v1/metrics",
-    headers: {
-      Authorization: `Bearer ${config.axiomToken}`,
-      "X-Axiom-Dataset": `vm0-sandbox-op-log-${env}`
-    }
-  });
-  meterProvider = new MeterProvider({
-    resource: new Resource({
-      [ATTR_SERVICE_NAME]: config.serviceName,
-      "deployment.environment": env,
-      "runner.label": config.runnerLabel
-    }),
-    readers: [
-      new PeriodicExportingMetricReader({
-        exporter,
-        exportIntervalMillis: config.exportIntervalMs ?? 3e4
-      })
-    ]
-  });
-  metrics.setGlobalMeterProvider(meterProvider);
-  enabled = true;
-  console.log(
-    `[metrics] initialized for ${config.serviceName} (${env}), runner: ${config.runnerLabel}`
-  );
-}
-function isMetricsEnabled() {
-  return enabled;
-}
-function getRunnerLabel() {
-  return _runnerLabel;
-}
-function getMeter(name) {
-  return metrics.getMeter(name);
+// src/lib/metrics/instruments.ts
+var FLUSH_THRESHOLD_MS = 3e4;
+var sandboxContext = null;
+var pendingOps = [];
+var oldestPendingTime = null;
+function setSandboxContext(ctx) {
+  sandboxContext = ctx;
+  pendingOps = [];
+  oldestPendingTime = null;
 }
-async function flushMetrics() {
-  if (meterProvider) {
-    await meterProvider.forceFlush();
+async function clearSandboxContext() {
+  const ctx = sandboxContext;
+  const ops = pendingOps;
+  sandboxContext = null;
+  pendingOps = [];
+  oldestPendingTime = null;
+  if (ctx && ops.length > 0) {
+    await flushOpsWithContext(ctx, ops);
   }
 }
-async function shutdownMetrics() {
-  if (meterProvider) {
-    await meterProvider.shutdown();
-  }
+async function flushOps() {
+  if (!sandboxContext || pendingOps.length === 0) return;
+  const ctx = sandboxContext;
+  const ops = pendingOps;
+  pendingOps = [];
+  oldestPendingTime = null;
+  await flushOpsWithContext(ctx, ops);
 }
-
-// src/lib/metrics/instruments.ts
-var runnerOperationTotal = null;
-var runnerOperationErrorsTotal = null;
-var runnerOperationDuration = null;
-var sandboxOperationTotal = null;
-var sandboxOperationErrorsTotal = null;
-var sandboxOperationDuration = null;
-function getRunnerInstruments() {
-  if (!runnerOperationTotal) {
-    const meter = getMeter("vm0-runner");
-    runnerOperationTotal = meter.createCounter("runner_operation_total", {
-      description: "Total number of runner operations"
-    });
-    runnerOperationErrorsTotal = meter.createCounter(
-      "runner_operation_errors_total",
-      {
-        description: "Total number of runner operation errors"
-      }
-    );
-    runnerOperationDuration = meter.createHistogram(
-      "runner_operation_duration_ms",
-      {
-        description: "Runner operation duration in milliseconds",
-        unit: "ms"
-      }
-    );
-  }
-  return {
-    runnerOperationTotal,
-    runnerOperationErrorsTotal,
-    runnerOperationDuration
+async function flushOpsWithContext(ctx, ops) {
+  const { apiUrl, runId, sandboxToken } = ctx;
+  const headers = {
+    Authorization: `Bearer ${sandboxToken}`,
+    "Content-Type": "application/json"
   };
-}
-function getSandboxInstruments() {
-  if (!sandboxOperationTotal) {
-    const meter = getMeter("vm0-runner");
-    sandboxOperationTotal = meter.createCounter("sandbox_operation_total", {
-      description: "Total number of sandbox operations"
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  try {
+    const response = await fetch(`${apiUrl}/api/webhooks/agent/telemetry`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        runId,
+        sandboxOperations: ops
+      })
     });
-    sandboxOperationErrorsTotal = meter.createCounter(
-      "sandbox_operation_errors_total",
-      {
-        description: "Total number of sandbox operation errors"
-      }
-    );
-    sandboxOperationDuration = meter.createHistogram(
-      "sandbox_operation_duration_ms",
-      {
-        description: "Sandbox operation duration in milliseconds",
-        unit: "ms"
-      }
-    );
+    await response.text();
+    if (!response.ok) {
+      console.warn(
+        `[metrics] Failed to flush operations: HTTP ${response.status}`
+      );
+    }
+  } catch (err) {
+    console.warn(`[metrics] Failed to flush operations: ${err}`);
   }
-  return {
-    sandboxOperationTotal,
-    sandboxOperationErrorsTotal,
-    sandboxOperationDuration
-  };
 }
-function recordRunnerOperation(attrs) {
-  if (!isMetricsEnabled()) return;
-  const {
-    runnerOperationTotal: runnerOperationTotal2,
-    runnerOperationErrorsTotal: runnerOperationErrorsTotal2,
-    runnerOperationDuration: runnerOperationDuration2
-  } = getRunnerInstruments();
-  const labels = {
-    action_type: attrs.actionType,
-    runner_label: getRunnerLabel()
-  };
-  runnerOperationTotal2.add(1, labels);
-  if (!attrs.success) {
-    runnerOperationErrorsTotal2.add(1, labels);
+function recordOperation(attrs) {
+  if (!sandboxContext) {
+    return;
   }
-  runnerOperationDuration2.record(attrs.durationMs, {
-    ...labels,
-    success: String(attrs.success)
-  });
-}
-function recordSandboxOperation(attrs) {
-  if (!isMetricsEnabled()) return;
-  const {
-    sandboxOperationTotal: sandboxOperationTotal2,
-    sandboxOperationErrorsTotal: sandboxOperationErrorsTotal2,
-    sandboxOperationDuration: sandboxOperationDuration2
-  } = getSandboxInstruments();
-  const labels = {
-    sandbox_type: "runner",
-    action_type: attrs.actionType
-  };
-  sandboxOperationTotal2.add(1, labels);
-  if (!attrs.success) {
-    sandboxOperationErrorsTotal2.add(1, labels);
+  const now = Date.now();
+  if (oldestPendingTime && now - oldestPendingTime >= FLUSH_THRESHOLD_MS) {
+    flushOps().catch(() => {
+    });
+  }
+  if (oldestPendingTime === null) {
+    oldestPendingTime = now;
   }
-  sandboxOperationDuration2.record(attrs.durationMs, {
-    ...labels,
-    success: String(attrs.success)
+  pendingOps.push({
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    action_type: attrs.actionType,
+    duration_ms: attrs.durationMs,
+    success: attrs.success
   });
 }
 
@@ -9303,7 +9384,7 @@ async function withRunnerTiming(actionType, fn) {
     success = false;
     throw error;
   } finally {
-    recordRunnerOperation({
+    recordOperation({
       actionType,
       durationMs: Date.now() - startTime,
       success
@@ -9319,7 +9400,7 @@ async function withSandboxTiming(actionType, fn) {
     success = false;
     throw error;
   } finally {
-    recordSandboxOperation({
+    recordOperation({
       actionType,
       durationMs: Date.now() - startTime,
       success
@@ -9327,6 +9408,45 @@ async function withSandboxTiming(actionType, fn) {
   }
 }
 
+// src/lib/vm-setup/vm-setup.ts
+var logger6 = createLogger("VMSetup");
+var VM_PROXY_CA_PATH = "/usr/local/share/ca-certificates/vm0-proxy-ca.crt";
+async function downloadStorages(guest, manifest) {
+  const totalArchives = manifest.storages.filter((s) => s.archiveUrl).length + (manifest.artifact?.archiveUrl ? 1 : 0);
+  if (totalArchives === 0) {
+    logger6.log(`No archives to download`);
+    return;
+  }
+  logger6.log(`Downloading ${totalArchives} archive(s)...`);
+  const manifestJson = JSON.stringify(manifest);
+  await guest.writeFile("/tmp/storage-manifest.json", manifestJson);
+  const result = await guest.exec(
+    `node ${SCRIPT_PATHS.download} /tmp/storage-manifest.json`
+  );
+  if (result.exitCode !== 0) {
+    throw new Error(`Storage download failed: ${result.stderr}`);
+  }
+  logger6.log(`Storage download completed`);
+}
+async function restoreSessionHistory(guest, resumeSession, workingDir, cliAgentType) {
+  const { sessionId, sessionHistory } = resumeSession;
+  let sessionPath;
+  if (cliAgentType === "codex") {
+    logger6.log(`Codex resume session will be handled by checkpoint.py`);
+    return;
+  } else {
+    const projectName = workingDir.replace(/^\//, "").replace(/\//g, "-");
+    sessionPath = `/home/user/.claude/projects/-${projectName}/${sessionId}.jsonl`;
+  }
+  logger6.log(`Restoring session history to ${sessionPath}`);
+  const dirPath = sessionPath.substring(0, sessionPath.lastIndexOf("/"));
+  await guest.execOrThrow(`mkdir -p "${dirPath}"`);
+  await guest.writeFile(sessionPath, sessionHistory);
+  logger6.log(
+    `Session history restored (${sessionHistory.split("\n").length} lines)`
+  );
+}
+
 // src/lib/executor-env.ts
 var ENV_JSON_PATH = "/tmp/vm0-env.json";
 function buildEnvironmentVariables(context, apiUrl) {
@@ -9369,13 +9489,14 @@ function buildEnvironmentVariables(context, apiUrl) {
     }
   }
   if (context.experimentalFirewall?.experimental_mitm) {
-    envVars.NODE_EXTRA_CA_CERTS = "/usr/local/share/ca-certificates/vm0-proxy-ca.crt";
+    envVars.NODE_EXTRA_CA_CERTS = VM_PROXY_CA_PATH;
   }
   return envVars;
 }
 
 // src/lib/network-logs/network-logs.ts
 import fs7 from "fs";
+var logger7 = createLogger("NetworkLogs");
 function getNetworkLogPath(runId) {
   return `/tmp/vm0-network-${runId}.jsonl`;
 }
@@ -9389,8 +9510,8 @@ function readNetworkLogs(runId) {
     const lines = content.split("\n").filter((line) => line.trim());
     return lines.map((line) => JSON.parse(line));
   } catch (err) {
-    console.error(
-      `[Executor] Failed to read network logs: ${err instanceof Error ? err.message : "Unknown error"}`
+    logger7.error(
+      `Failed to read network logs: ${err instanceof Error ? err.message : "Unknown error"}`
     );
     return [];
   }
@@ -9402,19 +9523,19 @@ function cleanupNetworkLogs(runId) {
       fs7.unlinkSync(logPath);
     }
   } catch (err) {
-    console.error(
-      `[Executor] Failed to cleanup network logs: ${err instanceof Error ? err.message : "Unknown error"}`
+    logger7.error(
+      `Failed to cleanup network logs: ${err instanceof Error ? err.message : "Unknown error"}`
     );
   }
 }
 async function uploadNetworkLogs(apiUrl, sandboxToken, runId) {
   const networkLogs = readNetworkLogs(runId);
   if (networkLogs.length === 0) {
-    console.log(`[Executor] No network logs to upload for ${runId}`);
+    logger7.log(`No network logs to upload for ${runId}`);
     return;
   }
-  console.log(
-    `[Executor] Uploading ${networkLogs.length} network log entries for ${runId}`
+  logger7.log(
+    `Uploading ${networkLogs.length} network log entries for ${runId}`
   );
   const headers = {
     Authorization: `Bearer ${sandboxToken}`,
@@ -9434,71 +9555,15 @@ async function uploadNetworkLogs(apiUrl, sandboxToken, runId) {
   });
   if (!response.ok) {
     const errorText = await response.text();
-    console.error(`[Executor] Failed to upload network logs: ${errorText}`);
+    logger7.error(`Failed to upload network logs: ${errorText}`);
     return;
   }
-  console.log(`[Executor] Network logs uploaded successfully for ${runId}`);
+  logger7.log(`Network logs uploaded successfully for ${runId}`);
   cleanupNetworkLogs(runId);
 }
 
-// src/lib/vm-setup/vm-setup.ts
-import fs8 from "fs";
-async function downloadStorages(guest, manifest) {
-  const totalArchives = manifest.storages.filter((s) => s.archiveUrl).length + (manifest.artifact?.archiveUrl ? 1 : 0);
-  if (totalArchives === 0) {
-    console.log(`[Executor] No archives to download`);
-    return;
-  }
-  console.log(`[Executor] Downloading ${totalArchives} archive(s)...`);
-  const manifestJson = JSON.stringify(manifest);
-  await guest.writeFile("/tmp/storage-manifest.json", manifestJson);
-  const result = await guest.exec(
-    `node ${SCRIPT_PATHS.download} /tmp/storage-manifest.json`
-  );
-  if (result.exitCode !== 0) {
-    throw new Error(`Storage download failed: ${result.stderr}`);
-  }
-  console.log(`[Executor] Storage download completed`);
-}
-async function restoreSessionHistory(guest, resumeSession, workingDir, cliAgentType) {
-  const { sessionId, sessionHistory } = resumeSession;
-  let sessionPath;
-  if (cliAgentType === "codex") {
-    console.log(
-      `[Executor] Codex resume session will be handled by checkpoint.py`
-    );
-    return;
-  } else {
-    const projectName = workingDir.replace(/^\//, "").replace(/\//g, "-");
-    sessionPath = `/home/user/.claude/projects/-${projectName}/${sessionId}.jsonl`;
-  }
-  console.log(`[Executor] Restoring session history to ${sessionPath}`);
-  const dirPath = sessionPath.substring(0, sessionPath.lastIndexOf("/"));
-  await guest.execOrThrow(`mkdir -p "${dirPath}"`);
-  await guest.writeFile(sessionPath, sessionHistory);
-  console.log(
-    `[Executor] Session history restored (${sessionHistory.split("\n").length} lines)`
-  );
-}
-async function installProxyCA(guest, caCertPath) {
-  if (!fs8.existsSync(caCertPath)) {
-    throw new Error(
-      `Proxy CA certificate not found at ${caCertPath}. Run generate-proxy-ca.sh first.`
-    );
-  }
-  const caCert = fs8.readFileSync(caCertPath, "utf-8");
-  console.log(
-    `[Executor] Installing proxy CA certificate (${caCert.length} bytes)`
-  );
-  await guest.writeFileWithSudo(
-    "/usr/local/share/ca-certificates/vm0-proxy-ca.crt",
-    caCert
-  );
-  await guest.execOrThrow("sudo update-ca-certificates");
-  console.log(`[Executor] Proxy CA certificate installed successfully`);
-}
-
 // src/lib/executor.ts
+var logger8 = createLogger("Executor");
 function getVmIdFromRunId(runId) {
   return runId.split("-")[0] || runId.substring(0, 8);
 }
@@ -9544,20 +9609,31 @@ async function reportPreflightFailure(apiUrl, runId, sandboxToken, error, bypass
       })
     });
     if (!response.ok) {
-      console.error(
-        `[Executor] Failed to report preflight failure: HTTP ${response.status}`
+      logger8.error(
+        `Failed to report preflight failure: HTTP ${response.status}`
       );
     }
   } catch (err) {
-    console.error(`[Executor] Failed to report preflight failure: ${err}`);
+    logger8.error(`Failed to report preflight failure: ${err}`);
   }
 }
 async function executeJob(context, config, options = {}) {
+  setSandboxContext({
+    apiUrl: config.server.url,
+    runId: context.runId,
+    sandboxToken: context.sandboxToken
+  });
+  if (context.apiStartTime) {
+    recordOperation({
+      actionType: "api_to_vm_start",
+      durationMs: Date.now() - context.apiStartTime,
+      success: true
+    });
+  }
   const vmId = getVmIdFromRunId(context.runId);
   let vm = null;
   let guestIp = null;
-  const log = options.logger ?? ((msg) => console.log(msg));
-  log(`[Executor] Starting job ${context.runId} in VM ${vmId}`);
+  logger8.log(`Starting job ${context.runId} in VM ${vmId}`);
   try {
     const workspacesDir = path4.join(process.cwd(), "workspaces");
     const vmConfig = {
@@ -9567,46 +9643,44 @@ async function executeJob(context, config, options = {}) {
       kernelPath: config.firecracker.kernel,
       rootfsPath: config.firecracker.rootfs,
       firecrackerBinary: config.firecracker.binary,
-      workDir: path4.join(workspacesDir, `vm0-${vmId}`),
-      logger: log
+      workDir: path4.join(workspacesDir, `vm0-${vmId}`)
     };
-    log(`[Executor] Creating VM ${vmId}...`);
+    logger8.log(`Creating VM ${vmId}...`);
     vm = new FirecrackerVM(vmConfig);
     await withSandboxTiming("vm_create", () => vm.start());
     guestIp = vm.getGuestIp();
     if (!guestIp) {
       throw new Error("VM started but no IP address available");
     }
-    log(`[Executor] VM ${vmId} started, guest IP: ${guestIp}`);
+    logger8.log(`VM ${vmId} started, guest IP: ${guestIp}`);
     const vsockPath = vm.getVsockPath();
     const guest = new VsockClient(vsockPath);
-    log(`[Executor] Using vsock for guest communication: ${vsockPath}`);
-    log(`[Executor] Waiting for guest connection...`);
+    logger8.log(`Using vsock for guest communication: ${vsockPath}`);
+    logger8.log(`Waiting for guest connection...`);
     await withSandboxTiming(
       "guest_wait",
       () => guest.waitForGuestConnection(3e4)
     );
-    log(`[Executor] Guest client ready`);
+    logger8.log(`Guest client ready`);
     const firewallConfig = context.experimentalFirewall;
     if (firewallConfig?.enabled) {
       const mitmEnabled = firewallConfig.experimental_mitm ?? false;
       const sealSecretsEnabled = firewallConfig.experimental_seal_secrets ?? false;
-      log(
-        `[Executor] Setting up network security for VM ${guestIp} (mitm=${mitmEnabled}, sealSecrets=${sealSecretsEnabled})`
+      logger8.log(
+        `Setting up network security for VM ${guestIp} (mitm=${mitmEnabled}, sealSecrets=${sealSecretsEnabled})`
       );
-      await setupVMProxyRules(guestIp, config.proxy.port, config.name);
-      getVMRegistry().register(guestIp, context.runId, context.sandboxToken, {
-        firewallRules: firewallConfig?.rules,
-        mitmEnabled,
-        sealSecretsEnabled
-      });
-      if (mitmEnabled) {
-        const caCertPath = path4.join(
-          config.proxy.ca_dir,
-          "mitmproxy-ca-cert.pem"
+      await withSandboxTiming("network_setup", async () => {
+        getVMRegistry().register(
+          guestIp,
+          context.runId,
+          context.sandboxToken,
+          {
+            firewallRules: firewallConfig?.rules,
+            mitmEnabled,
+            sealSecretsEnabled
+          }
         );
-        await installProxyCA(guest, caCertPath);
-      }
+      });
     }
     if (context.storageManifest) {
       await withSandboxTiming(
@@ -9627,22 +9701,25 @@ async function executeJob(context, config, options = {}) {
     }
     const envVars = buildEnvironmentVariables(context, config.server.url);
     const envJson = JSON.stringify(envVars);
-    log(
-      `[Executor] Writing env JSON (${envJson.length} bytes) to ${ENV_JSON_PATH}`
+    logger8.log(
+      `Writing env JSON (${envJson.length} bytes) to ${ENV_JSON_PATH}`
     );
     await guest.writeFile(ENV_JSON_PATH, envJson);
     if (!options.benchmarkMode) {
-      log(`[Executor] Running preflight connectivity check...`);
+      logger8.log(`Running preflight connectivity check...`);
       const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-      const preflight = await runPreflightCheck(
-        guest,
-        config.server.url,
-        context.runId,
-        context.sandboxToken,
-        bypassSecret
+      const preflight = await withSandboxTiming(
+        "preflight_check",
+        () => runPreflightCheck(
+          guest,
+          config.server.url,
+          context.runId,
+          context.sandboxToken,
+          bypassSecret
+        )
       );
       if (!preflight.success) {
-        log(`[Executor] Preflight check failed: ${preflight.error}`);
+        logger8.log(`Preflight check failed: ${preflight.error}`);
         await reportPreflightFailure(
           config.server.url,
           context.runId,
@@ -9655,123 +9732,84 @@ async function executeJob(context, config, options = {}) {
           error: preflight.error
         };
       }
-      log(`[Executor] Preflight check passed`);
+      logger8.log(`Preflight check passed`);
     }
     const systemLogFile = `/tmp/vm0-main-${context.runId}.log`;
-    const exitCodeFile = `/tmp/vm0-exit-${context.runId}`;
     const startTime = Date.now();
+    const maxWaitMs = 2 * 60 * 60 * 1e3;
+    let command;
     if (options.benchmarkMode) {
-      log(`[Executor] Running command directly (benchmark mode)...`);
-      await guest.exec(
-        `nohup sh -c '${context.prompt}; echo $? > ${exitCodeFile}' > ${systemLogFile} 2>&1 &`
-      );
-      log(`[Executor] Command started in background`);
+      logger8.log(`Running command directly (benchmark mode)...`);
+      command = `${context.prompt} > ${systemLogFile} 2>&1`;
     } else {
-      log(`[Executor] Running agent via env-loader (background)...`);
-      await guest.exec(
-        `nohup sh -c 'node ${ENV_LOADER_PATH}; echo $? > ${exitCodeFile}' > ${systemLogFile} 2>&1 &`
-      );
-      log(`[Executor] Agent started in background`);
+      logger8.log(`Running agent via env-loader...`);
+      command = `node ${ENV_LOADER_PATH} > ${systemLogFile} 2>&1`;
     }
-    const pollIntervalMs = 2e3;
-    const maxWaitMs = 2 * 60 * 60 * 1e3;
+    const { pid } = await guest.spawnAndWatch(command, maxWaitMs);
+    logger8.log(`Process started with pid=${pid}`);
     let exitCode = 1;
-    let completed = false;
-    while (Date.now() - startTime < maxWaitMs) {
-      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      const checkResult = await guest.exec(`cat ${exitCodeFile} 2>/dev/null`);
-      if (checkResult.exitCode === 0 && checkResult.stdout.trim()) {
-        const parsed = parseInt(checkResult.stdout.trim(), 10);
-        exitCode = Number.isNaN(parsed) ? 1 : parsed;
-        completed = true;
-        break;
-      }
-      if (!options.benchmarkMode) {
-        const processCheck = await guest.exec(
-          `pgrep -f "env-loader.mjs" > /dev/null 2>&1 && echo "RUNNING" || echo "DEAD"`
-        );
-        if (processCheck.stdout.trim() === "DEAD") {
-          log(
-            `[Executor] Agent process died unexpectedly without writing exit code`
-          );
-          const logContent = await guest.exec(
-            `tail -50 ${systemLogFile} 2>/dev/null`
-          );
-          const dmesgCheck = await guest.exec(
-            `dmesg | tail -20 | grep -iE "killed|oom" 2>/dev/null`
-          );
-          let errorMsg = "Agent process terminated unexpectedly";
-          if (dmesgCheck.stdout.toLowerCase().includes("oom") || dmesgCheck.stdout.toLowerCase().includes("killed")) {
-            errorMsg = "Agent process killed by OOM killer";
-            log(`[Executor] OOM detected: ${dmesgCheck.stdout}`);
-          }
-          if (logContent.stdout) {
-            log(
-              `[Executor] Last log output: ${logContent.stdout.substring(0, 500)}`
-            );
-          }
-          const durationMs2 = Date.now() - startTime;
-          recordRunnerOperation({
-            actionType: "agent_execute",
-            durationMs: durationMs2,
-            success: false
-          });
-          return {
-            exitCode: 1,
-            error: errorMsg
-          };
-        }
-      }
-    }
-    const durationMs = Date.now() - startTime;
-    const duration = Math.round(durationMs / 1e3);
-    if (!completed) {
-      log(`[Executor] Agent timed out after ${duration}s`);
-      recordRunnerOperation({
+    let exitEvent;
+    try {
+      exitEvent = await guest.waitForExit(pid, maxWaitMs + 5e3);
+      exitCode = exitEvent.exitCode;
+    } catch {
+      const durationMs2 = Date.now() - startTime;
+      const duration2 = Math.round(durationMs2 / 1e3);
+      logger8.log(`Agent timed out after ${duration2}s`);
+      recordOperation({
         actionType: "agent_execute",
-        durationMs,
+        durationMs: durationMs2,
         success: false
       });
       return {
         exitCode: 1,
-        error: `Agent execution timed out after ${duration}s`
+        error: `Agent execution timed out after ${duration2}s`
       };
     }
-    recordRunnerOperation({
+    const durationMs = Date.now() - startTime;
+    const duration = Math.round(durationMs / 1e3);
+    if (exitCode === 137 || exitCode === 9) {
+      const dmesgCheck = await guest.exec(
+        `dmesg | tail -20 | grep -iE "killed|oom" 2>/dev/null`
+      );
+      if (dmesgCheck.stdout.toLowerCase().includes("oom") || dmesgCheck.stdout.toLowerCase().includes("killed")) {
+        logger8.log(`OOM detected: ${dmesgCheck.stdout}`);
+        recordOperation({
+          actionType: "agent_execute",
+          durationMs,
+          success: false
+        });
+        return {
+          exitCode: 1,
+          error: "Agent process killed by OOM killer"
+        };
+      }
+    }
+    recordOperation({
       actionType: "agent_execute",
       durationMs,
       success: exitCode === 0
     });
-    log(`[Executor] Agent finished in ${duration}s with exit code ${exitCode}`);
-    const logResult = await guest.exec(
-      `tail -100 ${systemLogFile} 2>/dev/null`
-    );
-    if (logResult.stdout) {
-      log(
-        `[Executor] Log output (${logResult.stdout.length} chars): ${logResult.stdout.substring(0, 500)}`
+    logger8.log(`Agent finished in ${duration}s with exit code ${exitCode}`);
+    if (exitEvent.stderr) {
+      logger8.log(
+        `Stderr (${exitEvent.stderr.length} chars): ${exitEvent.stderr.substring(0, 500)}`
       );
     }
     return {
       exitCode,
-      error: exitCode !== 0 ? logResult.stdout || void 0 : void 0
+      error: exitCode !== 0 ? exitEvent.stderr || void 0 : void 0
     };
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
-    console.error(`[Executor] Job ${context.runId} failed: ${errorMsg}`);
+    logger8.error(`Job ${context.runId} failed: ${errorMsg}`);
     return {
       exitCode: 1,
       error: errorMsg
     };
   } finally {
     if (context.experimentalFirewall?.enabled && guestIp) {
-      log(`[Executor] Cleaning up network security for VM ${guestIp}`);
-      try {
-        await removeVMProxyRules(guestIp, config.proxy.port, config.name);
-      } catch (err) {
-        console.error(
-          `[Executor] Failed to remove VM proxy rules: ${err instanceof Error ? err.message : "Unknown error"}`
-        );
-      }
+      logger8.log(`Cleaning up network security for VM ${guestIp}`);
       getVMRegistry().unregister(guestIp);
       if (!options.benchmarkMode) {
         try {
@@ -9781,21 +9819,23 @@ async function executeJob(context, config, options = {}) {
             context.runId
           );
         } catch (err) {
-          console.error(
-            `[Executor] Failed to upload network logs: ${err instanceof Error ? err.message : "Unknown error"}`
+          logger8.error(
+            `Failed to upload network logs: ${err instanceof Error ? err.message : "Unknown error"}`
           );
         }
       }
     }
     if (vm) {
-      log(`[Executor] Cleaning up VM ${vmId}...`);
+      logger8.log(`Cleaning up VM ${vmId}...`);
       await withSandboxTiming("cleanup", () => vm.kill());
     }
+    await clearSandboxContext();
   }
 }
 
 // src/lib/runner/status.ts
 import { writeFileSync as writeFileSync2 } from "fs";
+var logger9 = createLogger("Runner");
 function writeStatusFile(statusFilePath, mode, activeRuns, startedAt) {
   const status = {
     mode,
@@ -9807,7 +9847,7 @@ function writeStatusFile(statusFilePath, mode, activeRuns, startedAt) {
   try {
     writeFileSync2(statusFilePath, JSON.stringify(status, null, 2));
   } catch (err) {
-    console.error(
+    logger9.error(
       `Failed to write status file: ${err instanceof Error ? err.message : "Unknown error"}`
     );
   }
@@ -9824,37 +9864,26 @@ function createStatusUpdater(statusFilePath, state) {
 }
 
 // src/lib/runner/setup.ts
+var logger10 = createLogger("Runner");
 async function setupEnvironment(options) {
   const { config } = options;
-  const datasetSuffix = process.env.AXIOM_DATASET_SUFFIX;
-  if (!datasetSuffix) {
-    throw new Error(
-      "AXIOM_DATASET_SUFFIX is required. Set to 'dev' or 'prod'."
-    );
-  }
-  initMetrics({
-    serviceName: "vm0-runner",
-    runnerLabel: config.name,
-    axiomToken: process.env.AXIOM_TOKEN,
-    environment: datasetSuffix
-  });
   const networkCheck = checkNetworkPrerequisites();
   if (!networkCheck.ok) {
-    console.error("Network prerequisites not met:");
+    logger10.error("Network prerequisites not met:");
     for (const error of networkCheck.errors) {
-      console.error(`  - ${error}`);
+      logger10.error(`  - ${error}`);
     }
     process.exit(1);
   }
-  console.log("Setting up network bridge...");
+  logger10.log("Setting up network bridge...");
   await setupBridge();
-  console.log("Flushing bridge ARP cache...");
+  logger10.log("Flushing bridge ARP cache...");
   await flushBridgeArpCache();
-  console.log("Cleaning up orphaned proxy rules...");
+  logger10.log("Cleaning up orphaned proxy rules...");
   await cleanupOrphanedProxyRules(config.name);
-  console.log("Cleaning up orphaned IP allocations...");
+  logger10.log("Cleaning up orphaned IP allocations...");
   await cleanupOrphanedAllocations();
-  console.log("Initializing network proxy...");
+  logger10.log("Initializing network proxy...");
   initVMRegistry();
   const proxyManager = initProxyManager({
     apiUrl: config.server.url,
@@ -9865,45 +9894,49 @@ async function setupEnvironment(options) {
   try {
     await proxyManager.start();
     proxyEnabled = true;
-    console.log("Network proxy initialized successfully");
+    logger10.log("Network proxy initialized successfully");
+    logger10.log("Setting up CIDR proxy rules...");
+    await setupCIDRProxyRules(config.proxy.port);
   } catch (err) {
-    console.warn(
+    logger10.log(
       `Network proxy not available: ${err instanceof Error ? err.message : "Unknown error"}`
     );
-    console.warn(
+    logger10.log(
       "Jobs with experimentalFirewall enabled will run without network interception"
     );
   }
-  return { proxyEnabled };
+  return { proxyEnabled, proxyPort: config.proxy.port };
 }
 async function cleanupEnvironment(resources) {
   if (resources.proxyEnabled) {
-    console.log("Stopping network proxy...");
+    logger10.log("Cleaning up CIDR proxy rules...");
+    await cleanupCIDRProxyRules(resources.proxyPort);
+  }
+  if (resources.proxyEnabled) {
+    logger10.log("Stopping network proxy...");
     await getProxyManager().stop();
   }
-  console.log("Flushing metrics...");
-  await flushMetrics();
-  await shutdownMetrics();
 }
 
 // src/lib/runner/signals.ts
+var logger11 = createLogger("Runner");
 function setupSignalHandlers(state, handlers) {
   process.on("SIGINT", () => {
-    console.log("\nShutting down...");
+    logger11.log("\nShutting down...");
     handlers.onShutdown();
     state.mode = "stopped";
     handlers.updateStatus();
   });
   process.on("SIGTERM", () => {
-    console.log("\nShutting down...");
+    logger11.log("\nShutting down...");
     handlers.onShutdown();
     state.mode = "stopped";
     handlers.updateStatus();
   });
   process.on("SIGUSR1", () => {
     if (state.mode === "running") {
-      console.log("\n[Maintenance] Entering drain mode...");
-      console.log(
+      logger11.log("\n[Maintenance] Entering drain mode...");
+      logger11.log(
         `[Maintenance] Active jobs: ${state.activeRuns.size} (will wait for completion)`
       );
       state.mode = "draining";
@@ -9914,6 +9947,7 @@ function setupSignalHandlers(state, handlers) {
 }
 
 // src/lib/runner/runner.ts
+var logger12 = createLogger("Runner");
 var Runner = class _Runner {
   config;
   statusFilePath;
@@ -9952,41 +9986,41 @@ var Runner = class _Runner {
       onDrain: () => {
         this.pendingJobs.length = 0;
         if (this.state.activeRuns.size === 0) {
-          console.log("[Maintenance] No active jobs, exiting immediately");
+          logger12.log("[Maintenance] No active jobs, exiting immediately");
           this.resolveShutdown?.();
         }
       },
       updateStatus: this.updateStatus
     });
-    console.log(
+    logger12.log(
       `Starting runner '${this.config.name}' for group '${this.config.group}'...`
     );
-    console.log(`Max concurrent jobs: ${this.config.sandbox.max_concurrent}`);
-    console.log(`Status file: ${this.statusFilePath}`);
-    console.log("Press Ctrl+C to stop");
-    console.log("");
+    logger12.log(`Max concurrent jobs: ${this.config.sandbox.max_concurrent}`);
+    logger12.log(`Status file: ${this.statusFilePath}`);
+    logger12.log("Press Ctrl+C to stop");
+    logger12.log("");
     this.updateStatus();
-    console.log("Checking for pending jobs...");
+    logger12.log("Checking for pending jobs...");
     await this.pollFallback();
-    console.log("Connecting to realtime job notifications...");
+    logger12.log("Connecting to realtime job notifications...");
     this.subscription = await subscribeToJobs(
       this.config.server,
       this.config.group,
       (notification) => {
-        console.log(`Ably notification: ${notification.runId}`);
+        logger12.log(`Ably notification: ${notification.runId}`);
         this.processJob(notification.runId).catch(console.error);
       },
       (connectionState, reason) => {
-        console.log(
+        logger12.log(
           `Ably connection: ${connectionState}${reason ? ` (${reason})` : ""}`
         );
       }
     );
-    console.log("Connected to realtime job notifications");
+    logger12.log("Connected to realtime job notifications");
     this.pollInterval = setInterval(() => {
       this.pollFallback().catch(console.error);
     }, this.config.sandbox.poll_interval_ms);
-    console.log(
+    logger12.log(
       `Polling fallback enabled (every ${this.config.sandbox.poll_interval_ms / 1e3}s)`
     );
     await shutdownPromise;
@@ -9997,7 +10031,7 @@ var Runner = class _Runner {
       this.subscription.cleanup();
     }
     if (this.state.jobPromises.size > 0) {
-      console.log(
+      logger12.log(
         `Waiting for ${this.state.jobPromises.size} active job(s) to complete...`
       );
       await Promise.all(this.state.jobPromises);
@@ -10005,7 +10039,7 @@ var Runner = class _Runner {
     await cleanupEnvironment(this.resources);
     this.state.mode = "stopped";
     this.updateStatus();
-    console.log("Runner stopped");
+    logger12.log("Runner stopped");
     process.exit(0);
   }
   /**
@@ -10022,13 +10056,12 @@ var Runner = class _Runner {
         () => pollForJob(this.config.server, this.config.group)
       );
       if (job) {
-        console.log(`Poll fallback found job: ${job.runId}`);
+        logger12.log(`Poll fallback found job: ${job.runId}`);
         await this.processJob(job.runId);
       }
     } catch (error) {
-      console.error(
-        `Poll fallback error:`,
-        error instanceof Error ? error.message : "Unknown error"
+      logger12.error(
+        `Poll fallback error: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
@@ -10037,7 +10070,7 @@ var Runner = class _Runner {
    */
   async processJob(runId) {
     if (this.state.mode !== "running") {
-      console.log(`Not running (${this.state.mode}), ignoring job ${runId}`);
+      logger12.log(`Not running (${this.state.mode}), ignoring job ${runId}`);
       return;
     }
     if (this.state.activeRuns.has(runId)) {
@@ -10045,10 +10078,10 @@ var Runner = class _Runner {
     }
     if (this.state.activeRuns.size >= this.config.sandbox.max_concurrent) {
       if (!this.pendingJobs.includes(runId) && this.pendingJobs.length < _Runner.MAX_PENDING_QUEUE_SIZE) {
-        console.log(`At capacity, queueing job ${runId}`);
+        logger12.log(`At capacity, queueing job ${runId}`);
         this.pendingJobs.push(runId);
       } else if (this.pendingJobs.length >= _Runner.MAX_PENDING_QUEUE_SIZE) {
-        console.log(
+        logger12.log(
           `Pending queue full (${_Runner.MAX_PENDING_QUEUE_SIZE}), dropping job ${runId}`
         );
       }
@@ -10059,20 +10092,19 @@ var Runner = class _Runner {
         "claim",
         () => claimJob(this.config.server, runId)
       );
-      console.log(`Claimed job: ${context.runId}`);
+      logger12.log(`Claimed job: ${context.runId}`);
       this.state.activeRuns.add(context.runId);
       this.updateStatus();
       const jobPromise = this.executeJob(context).catch((error) => {
-        console.error(
-          `Job ${context.runId} failed:`,
-          error instanceof Error ? error.message : "Unknown error"
+        logger12.error(
+          `Job ${context.runId} failed: ${error instanceof Error ? error.message : "Unknown error"}`
         );
       }).finally(() => {
         this.state.activeRuns.delete(context.runId);
         this.state.jobPromises.delete(jobPromise);
         this.updateStatus();
         if (this.state.mode === "draining" && this.state.activeRuns.size === 0) {
-          console.log("[Maintenance] All jobs completed, exiting");
+          logger12.log("[Maintenance] All jobs completed, exiting");
           this.resolveShutdown?.();
           return;
         }
@@ -10085,34 +10117,33 @@ var Runner = class _Runner {
       });
       this.state.jobPromises.add(jobPromise);
     } catch (error) {
-      console.log(
-        `Could not claim job ${runId}:`,
-        error instanceof Error ? error.message : "Unknown error"
+      logger12.log(
+        `Could not claim job ${runId}: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   async executeJob(context) {
-    console.log(`  Executing job ${context.runId}...`);
-    console.log(`  Prompt: ${context.prompt.substring(0, 100)}...`);
-    console.log(`  Compose version: ${context.agentComposeVersionId}`);
+    logger12.log(`  Executing job ${context.runId}...`);
+    logger12.log(`  Prompt: ${context.prompt.substring(0, 100)}...`);
+    logger12.log(`  Compose version: ${context.agentComposeVersionId}`);
     try {
       const result = await executeJob(context, this.config);
-      console.log(
+      logger12.log(
         `  Job ${context.runId} execution completed with exit code ${result.exitCode}`
       );
       if (result.exitCode !== 0 && result.error) {
-        console.log(`  Job ${context.runId} failed: ${result.error}`);
+        logger12.error(`  Job ${context.runId} failed: ${result.error}`);
       }
     } catch (err) {
       const error = err instanceof Error ? err.message : "Unknown execution error";
-      console.error(`  Job ${context.runId} execution failed: ${error}`);
+      logger12.error(`  Job ${context.runId} execution failed: ${error}`);
       const result = await completeJob(
         this.config.server.url,
         context,
         1,
         error
       );
-      console.log(`  Job ${context.runId} reported as ${result.status}`);
+      logger12.log(`  Job ${context.runId} reported as ${result.status}`);
     }
   }
 };
@@ -10677,13 +10708,19 @@ function createBenchmarkContext(prompt, options) {
     environment: null,
     resumeSession: null,
     secretValues: null,
-    cliAgentType: options.agentType
+    cliAgentType: options.agentType,
+    // Enable firewall and MITM by default for benchmark to test proxy flow
+    experimentalFirewall: {
+      enabled: true,
+      experimental_mitm: true
+    }
   };
 }
 var benchmarkCommand = new Command4("benchmark").description(
   "Run a VM performance benchmark (executes bash command directly)"
 ).argument("<prompt>", "The bash command to execute in the VM").option("--config <path>", "Config file path", "./runner.yaml").option("--working-dir <path>", "Working directory in VM", "/home/user").option("--agent-type <type>", "Agent type", "claude-code").action(async (prompt, options) => {
   const timer = new Timer();
+  setGlobalLogger(timer.log.bind(timer));
   try {
     timer.log("Loading configuration...");
     const config = loadDebugConfig(options.config);
@@ -10702,8 +10739,7 @@ var benchmarkCommand = new Command4("benchmark").description(
     timer.log(`Executing command: ${prompt}`);
     const context = createBenchmarkContext(prompt, options);
     const result = await executeJob(context, config, {
-      benchmarkMode: true,
-      logger: timer.log.bind(timer)
+      benchmarkMode: true
     });
     timer.log(`Exit code: ${result.exitCode}`);
     if (result.error) {
@@ -10720,7 +10756,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.5.0" : "0.1.0";
+var version = true ? "3.6.1" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(doctorCommand);