@vm0/runner 3.7.0 → 3.7.2

package/index.js

@@ -1072,133 +1072,192 @@ import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec3);
 var logger3 = createLogger("OverlayPool");
 var VM0_RUN_DIR2 = "/var/run/vm0";
-var POOL_DIR = path2.join(VM0_RUN_DIR2, "overlay-pool");
+var DEFAULT_POOL_DIR = path2.join(VM0_RUN_DIR2, "overlay-pool");
 var OVERLAY_SIZE = 2 * 1024 * 1024 * 1024;
-var poolState = {
-  initialized: false,
-  config: null,
-  queue: [],
-  replenishing: false
-};
-async function ensurePoolDir() {
-  if (!fs3.existsSync(VM0_RUN_DIR2)) {
-    await execAsync3(`sudo mkdir -p ${VM0_RUN_DIR2}`);
-    await execAsync3(`sudo chmod 777 ${VM0_RUN_DIR2}`);
-  }
-  if (!fs3.existsSync(POOL_DIR)) {
-    fs3.mkdirSync(POOL_DIR, { recursive: true });
-  }
-}
-async function createOverlayFile(filePath) {
+async function defaultCreateFile(filePath) {
   const fd = fs3.openSync(filePath, "w");
   fs3.ftruncateSync(fd, OVERLAY_SIZE);
   fs3.closeSync(fd);
   await execAsync3(`mkfs.ext4 -F -q "${filePath}"`);
 }
-function generateFileName() {
-  return `overlay-${randomUUID()}.ext4`;
-}
-function scanPoolDir() {
-  if (!fs3.existsSync(POOL_DIR)) {
-    return [];
+var OverlayPool = class {
+  initialized = false;
+  queue = [];
+  replenishing = false;
+  config;
+  constructor(config) {
+    this.config = {
+      size: config.size,
+      replenishThreshold: config.replenishThreshold,
+      poolDir: config.poolDir ?? DEFAULT_POOL_DIR,
+      createFile: config.createFile ?? defaultCreateFile
+    };
   }
-  return fs3.readdirSync(POOL_DIR).filter((f) => f.startsWith("overlay-") && f.endsWith(".ext4")).map((f) => path2.join(POOL_DIR, f));
-}
-async function replenishPool() {
-  if (poolState.replenishing || !poolState.initialized || !poolState.config) {
-    return;
+  /**
+   * Generate unique file name using UUID
+   */
+  generateFileName() {
+    return `overlay-${randomUUID()}.ext4`;
   }
-  const needed = poolState.config.size - poolState.queue.length;
-  if (needed <= 0) {
-    return;
+  /**
+   * Ensure the pool directory exists
+   */
+  async ensurePoolDir() {
+    const parentDir = path2.dirname(this.config.poolDir);
+    if (!fs3.existsSync(parentDir)) {
+      await execAsync3(`sudo mkdir -p ${parentDir}`);
+      await execAsync3(`sudo chmod 777 ${parentDir}`);
+    }
+    if (!fs3.existsSync(this.config.poolDir)) {
+      fs3.mkdirSync(this.config.poolDir, { recursive: true });
+    }
   }
-  poolState.replenishing = true;
-  logger3.log(`Replenishing pool: creating ${needed} overlay(s)...`);
-  try {
-    const promises = [];
-    for (let i = 0; i < needed; i++) {
-      const filePath = path2.join(POOL_DIR, generateFileName());
-      promises.push(
-        createOverlayFile(filePath).then(() => {
-          poolState.queue.push(filePath);
-        })
-      );
+  /**
+   * Scan pool directory for overlay files
+   */
+  scanPoolDir() {
+    if (!fs3.existsSync(this.config.poolDir)) {
+      return [];
     }
-    await Promise.all(promises);
-    logger3.log(`Pool replenished: ${poolState.queue.length} available`);
-  } catch (err) {
-    logger3.error(
-      `Replenish failed: ${err instanceof Error ? err.message : "Unknown"}`
-    );
-  } finally {
-    poolState.replenishing = false;
+    return fs3.readdirSync(this.config.poolDir).filter((f) => f.startsWith("overlay-") && f.endsWith(".ext4")).map((f) => path2.join(this.config.poolDir, f));
   }
-}
-async function initOverlayPool(config) {
-  poolState.config = config;
-  poolState.queue = [];
-  logger3.log(
-    `Initializing overlay pool (size=${config.size}, threshold=${config.replenishThreshold})...`
-  );
-  await ensurePoolDir();
-  const existing = scanPoolDir();
-  if (existing.length > 0) {
-    logger3.log(`Cleaning up ${existing.length} stale overlay(s)`);
-    for (const file of existing) {
-      fs3.unlinkSync(file);
+  /**
+   * Replenish the pool in background
+   */
+  async replenish() {
+    if (this.replenishing || !this.initialized) {
+      return;
+    }
+    const needed = this.config.size - this.queue.length;
+    if (needed <= 0) {
+      return;
+    }
+    this.replenishing = true;
+    logger3.log(`Replenishing pool: creating ${needed} overlay(s)...`);
+    try {
+      const promises = [];
+      for (let i = 0; i < needed; i++) {
+        const filePath = path2.join(
+          this.config.poolDir,
+          this.generateFileName()
+        );
+        promises.push(
+          this.config.createFile(filePath).then(() => {
+            this.queue.push(filePath);
+          })
+        );
+      }
+      await Promise.all(promises);
+      logger3.log(`Pool replenished: ${this.queue.length} available`);
+    } catch (err) {
+      logger3.error(
+        `Replenish failed: ${err instanceof Error ? err.message : "Unknown"}`
+      );
+    } finally {
+      this.replenishing = false;
     }
   }
-  poolState.initialized = true;
-  await replenishPool();
-  logger3.log("Overlay pool initialized");
-}
-async function acquireOverlay() {
-  const filePath = poolState.queue.shift();
-  if (filePath) {
+  /**
+   * Initialize the overlay pool
+   */
+  async init() {
+    this.queue = [];
     logger3.log(
-      `Acquired overlay from pool (${poolState.queue.length} remaining)`
+      `Initializing overlay pool (size=${this.config.size}, threshold=${this.config.replenishThreshold})...`
     );
-    if (poolState.config && poolState.queue.length < poolState.config.replenishThreshold) {
-      replenishPool().catch((err) => {
-        logger3.error(
-          `Background replenish failed: ${err instanceof Error ? err.message : "Unknown"}`
-        );
-      });
+    await this.ensurePoolDir();
+    const existing = this.scanPoolDir();
+    if (existing.length > 0) {
+      logger3.log(`Cleaning up ${existing.length} stale overlay(s)`);
+      for (const file of existing) {
+        fs3.unlinkSync(file);
+      }
     }
-    return filePath;
-  }
-  logger3.log("Pool exhausted, creating overlay on-demand");
-  const newPath = path2.join(POOL_DIR, generateFileName());
-  await createOverlayFile(newPath);
-  return newPath;
-}
-function cleanupOverlayPool() {
-  if (!poolState.initialized) {
-    return;
+    this.initialized = true;
+    await this.replenish();
+    logger3.log("Overlay pool initialized");
   }
-  logger3.log("Cleaning up overlay pool...");
-  for (const file of poolState.queue) {
-    try {
-      fs3.unlinkSync(file);
-    } catch (err) {
-      logger3.log(
-        `Failed to delete ${file}: ${err instanceof Error ? err.message : "Unknown"}`
-      );
+  /**
+   * Acquire an overlay file from the pool
+   *
+   * Returns the file path. Caller owns the file and must delete it when done.
+   * Falls back to on-demand creation if pool is exhausted.
+   */
+  async acquire() {
+    if (!this.initialized) {
+      throw new Error("Overlay pool not initialized");
+    }
+    const filePath = this.queue.shift();
+    if (filePath) {
+      logger3.log(`Acquired overlay from pool (${this.queue.length} remaining)`);
+      if (this.queue.length < this.config.replenishThreshold) {
+        this.replenish().catch((err) => {
+          logger3.error(
+            `Background replenish failed: ${err instanceof Error ? err.message : "Unknown"}`
+          );
+        });
+      }
+      return filePath;
     }
+    logger3.log("Pool exhausted, creating overlay on-demand");
+    const newPath = path2.join(this.config.poolDir, this.generateFileName());
+    await this.config.createFile(newPath);
+    return newPath;
   }
-  poolState.queue = [];
-  for (const file of scanPoolDir()) {
-    try {
-      fs3.unlinkSync(file);
-    } catch (err) {
-      logger3.log(
-        `Failed to delete ${file}: ${err instanceof Error ? err.message : "Unknown"}`
-      );
+  /**
+   * Clean up the overlay pool
+   */
+  cleanup() {
+    if (!this.initialized) {
+      return;
+    }
+    logger3.log("Cleaning up overlay pool...");
+    for (const file of this.queue) {
+      try {
+        fs3.unlinkSync(file);
+      } catch (err) {
+        logger3.log(
+          `Failed to delete ${file}: ${err instanceof Error ? err.message : "Unknown"}`
+        );
+      }
+    }
+    this.queue = [];
+    for (const file of this.scanPoolDir()) {
+      try {
+        fs3.unlinkSync(file);
+      } catch (err) {
+        logger3.log(
+          `Failed to delete ${file}: ${err instanceof Error ? err.message : "Unknown"}`
+        );
+      }
     }
+    this.initialized = false;
+    this.replenishing = false;
+    logger3.log("Overlay pool cleaned up");
+  }
+};
+var overlayPool = null;
+async function initOverlayPool(config) {
+  if (overlayPool) {
+    overlayPool.cleanup();
+  }
+  overlayPool = new OverlayPool(config);
+  await overlayPool.init();
+  return overlayPool;
+}
+function acquireOverlay() {
+  if (!overlayPool) {
+    throw new Error(
+      "Overlay pool not initialized. Call initOverlayPool() first."
+    );
+  }
+  return overlayPool.acquire();
+}
+function cleanupOverlayPool() {
+  if (overlayPool) {
+    overlayPool.cleanup();
+    overlayPool = null;
   }
-  poolState.initialized = false;
-  poolState.replenishing = false;
-  logger3.log("Overlay pool cleaned up");
 }
 
 // src/lib/firecracker/vm.ts
@@ -1212,7 +1271,7 @@ var FirecrackerVM = class {
   workDir;
   socketPath;
   vmOverlayPath = null;
-  // Set by acquireOverlay() during start
+  // Set during start()
   vsockPath;
   // Vsock UDS path for host-guest communication
   constructor(config) {
@@ -9709,56 +9768,6 @@ var logger9 = createLogger("Executor");
 function getVmIdFromRunId(runId) {
   return runId.split("-")[0] || runId.substring(0, 8);
 }
-var CURL_ERROR_MESSAGES = {
-  6: "DNS resolution failed",
-  7: "Connection refused",
-  28: "Connection timeout",
-  60: "TLS certificate error (proxy CA not trusted)",
-  22: "HTTP error from server"
-};
-async function runPreflightCheck(guest, apiUrl, runId, sandboxToken, bypassSecret) {
-  const heartbeatUrl = `${apiUrl}/api/webhooks/agent/heartbeat`;
-  const bypassHeader = bypassSecret ? ` -H "x-vercel-protection-bypass: ${bypassSecret}"` : "";
-  const curlCmd = `curl -sf --connect-timeout 5 --max-time 10 "${heartbeatUrl}" -X POST -H "Content-Type: application/json" -H "Authorization: Bearer ${sandboxToken}"${bypassHeader} -d '{"runId":"${runId}"}'`;
-  const result = await guest.exec(curlCmd, 2e4);
-  if (result.exitCode === 0) {
-    return { success: true };
-  }
-  const errorDetail = CURL_ERROR_MESSAGES[result.exitCode] ?? `curl exit code ${result.exitCode}`;
-  const stderrInfo = result.stderr?.trim() ? ` (${result.stderr.trim()})` : "";
-  return {
-    success: false,
-    error: `Preflight check failed: ${errorDetail}${stderrInfo} - VM cannot reach VM0 API at ${apiUrl}`
-  };
-}
-async function reportPreflightFailure(apiUrl, runId, sandboxToken, error, bypassSecret) {
-  const completeUrl = `${apiUrl}/api/webhooks/agent/complete`;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${sandboxToken}`
-  };
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  try {
-    const response = await fetch(completeUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        runId,
-        exitCode: 1,
-        error
-      })
-    });
-    if (!response.ok) {
-      logger9.error(
-        `Failed to report preflight failure: HTTP ${response.status}`
-      );
-    }
-  } catch (err) {
-    logger9.error(`Failed to report preflight failure: ${err}`);
-  }
-}
 async function executeJob(context, config, options = {}) {
   setSandboxContext({
     apiUrl: config.server.url,
@@ -9847,35 +9856,6 @@ async function executeJob(context, config, options = {}) {
       `Writing env JSON (${envJson.length} bytes) to ${ENV_JSON_PATH}`
     );
     await guest.writeFile(ENV_JSON_PATH, envJson);
-    if (!options.benchmarkMode) {
-      logger9.log(`Running preflight connectivity check...`);
-      const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-      const preflight = await withSandboxTiming(
-        "preflight_check",
-        () => runPreflightCheck(
-          guest,
-          config.server.url,
-          context.runId,
-          context.sandboxToken,
-          bypassSecret
-        )
-      );
-      if (!preflight.success) {
-        logger9.log(`Preflight check failed: ${preflight.error}`);
-        await reportPreflightFailure(
-          config.server.url,
-          context.runId,
-          context.sandboxToken,
-          preflight.error,
-          bypassSecret
-        );
-        return {
-          exitCode: 1,
-          error: preflight.error
-        };
-      }
-      logger9.log(`Preflight check passed`);
-    }
     const systemLogFile = `/tmp/vm0-main-${context.runId}.log`;
     const startTime = Date.now();
     const maxWaitMs = 2 * 60 * 60 * 1e3;
@@ -10094,7 +10074,6 @@ async function setupEnvironment(options) {
   await initOverlayPool({
     size: config.sandbox.max_concurrent + 2,
     replenishThreshold: config.sandbox.max_concurrent
-    // Start replenishing early to handle bursts
   });
   logger12.log("Initializing network proxy...");
   initVMRegistry();
@@ -10983,6 +10962,12 @@ var benchmarkCommand = new Command4("benchmark").description(
     }
     timer.log("Setting up network bridge...");
     await setupBridge();
+    timer.log("Initializing overlay pool...");
+    await initOverlayPool({
+      size: 2,
+      replenishThreshold: 1,
+      poolDir: "/var/run/vm0/overlay-pool-benchmark"
+    });
     timer.log(`Executing command: ${prompt}`);
     const context = createBenchmarkContext(prompt, options);
     const result = await executeJob(context, config, {
@@ -11003,7 +10988,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.7.0" : "0.1.0";
+var version = true ? "3.7.2" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(doctorCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/runner",
-  "version": "3.7.0",
+  "version": "3.7.2",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",