@vm0/runner 2.6.1 → 2.7.0

package/index.js

@@ -37,6 +37,42 @@ var runnerConfigSchema = z.object({
     port: z.number().int().min(1024).max(65535).default(8080)
   }).default({})
 });
+var debugConfigSchema = z.object({
+  name: z.string().default("debug-runner"),
+  group: z.string().default("debug/local"),
+  server: z.object({
+    url: z.string().url().default("http://localhost:3000"),
+    token: z.string().default("debug-token")
+  }).default({}),
+  sandbox: z.object({
+    max_concurrent: z.number().int().min(1).default(1),
+    vcpu: z.number().int().min(1).default(2),
+    memory_mb: z.number().int().min(128).default(2048),
+    poll_interval_ms: z.number().int().min(1e3).default(5e3)
+  }).default({}),
+  firecracker: z.object({
+    binary: z.string().min(1, "Firecracker binary path is required"),
+    kernel: z.string().min(1, "Kernel path is required"),
+    rootfs: z.string().min(1, "Rootfs path is required")
+  }),
+  proxy: z.object({
+    port: z.number().int().min(1024).max(65535).default(8080)
+  }).default({})
+});
+function loadDebugConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  const raw = yaml.parse(content);
+  const result = debugConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
+  }
+  return result.data;
+}
 function loadConfig(configPath) {
   if (!fs.existsSync(configPath)) {
     throw new Error(`runner.yaml not found: ${configPath}`);
@@ -142,7 +178,7 @@ import path4 from "path";
 import fs6 from "fs";
 
 // src/lib/firecracker/vm.ts
-import { spawn } from "child_process";
+import { execSync as execSync2, spawn } from "child_process";
 import fs2 from "fs";
 import path from "path";
 import readline from "readline";
@@ -545,13 +581,13 @@ var FirecrackerVM = class {
   state = "created";
   workDir;
   socketPath;
-  vmRootfsPath;
-  // Per-VM copy of rootfs
+  vmOverlayPath;
+  // Per-VM sparse overlay for writes
   constructor(config) {
     this.config = config;
     this.workDir = config.workDir || `/tmp/vm0-vm-${config.vmId}`;
     this.socketPath = path.join(this.workDir, "firecracker.sock");
-    this.vmRootfsPath = path.join(this.workDir, "rootfs.ext4");
+    this.vmOverlayPath = path.join(this.workDir, "overlay.ext4");
   }
   /**
    * Get current VM state
@@ -590,8 +626,12 @@ var FirecrackerVM = class {
       if (fs2.existsSync(this.socketPath)) {
         fs2.unlinkSync(this.socketPath);
       }
-      console.log(`[VM ${this.config.vmId}] Copying rootfs for isolation...`);
-      fs2.copyFileSync(this.config.rootfsPath, this.vmRootfsPath);
+      console.log(`[VM ${this.config.vmId}] Creating sparse overlay file...`);
+      const overlaySize = 2 * 1024 * 1024 * 1024;
+      const fd = fs2.openSync(this.vmOverlayPath, "w");
+      fs2.ftruncateSync(fd, overlaySize);
+      fs2.closeSync(fd);
+      execSync2(`mkfs.ext4 -F -q "${this.vmOverlayPath}"`, { stdio: "ignore" });
       console.log(`[VM ${this.config.vmId}] Setting up network...`);
       this.networkConfig = await createTapDevice(this.config.vmId);
       console.log(`[VM ${this.config.vmId}] Starting Firecracker...`);
@@ -668,19 +708,27 @@ var FirecrackerVM = class {
       mem_size_mib: this.config.memoryMb
     });
     const networkBootArgs = generateNetworkBootArgs(this.networkConfig);
-    const bootArgs = `console=ttyS0 reboot=k panic=1 pci=off ${networkBootArgs}`;
+    const bootArgs = `console=ttyS0 reboot=k panic=1 pci=off init=/sbin/overlay-init ${networkBootArgs}`;
     console.log(`[VM ${this.config.vmId}] Boot args: ${bootArgs}`);
     await this.client.setBootSource({
       kernel_image_path: this.config.kernelPath,
       boot_args: bootArgs
     });
-    console.log(`[VM ${this.config.vmId}] Rootfs: ${this.vmRootfsPath}`);
+    console.log(
+      `[VM ${this.config.vmId}] Base rootfs: ${this.config.rootfsPath}`
+    );
     await this.client.setDrive({
       drive_id: "rootfs",
-      path_on_host: this.vmRootfsPath,
+      path_on_host: this.config.rootfsPath,
       is_root_device: true,
+      is_read_only: true
+    });
+    console.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
-      // Need write access for agent execution
     });
     console.log(
       `[VM ${this.config.vmId}] Network: ${this.networkConfig.tapDevice}`
@@ -770,7 +818,7 @@ var FirecrackerVM = class {
 };
 
 // src/lib/firecracker/guest.ts
-import { exec as exec2, execSync as execSync2 } from "child_process";
+import { exec as exec2, execSync as execSync3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import fs3 from "fs";
 import path2 from "path";
@@ -9955,6 +10003,208 @@ 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": `runner-metrics-${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);
+}
+async function flushMetrics() {
+  if (meterProvider) {
+    await meterProvider.forceFlush();
+  }
+}
+async function shutdownMetrics() {
+  if (meterProvider) {
+    await meterProvider.shutdown();
+  }
+}
+
+// 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
+  };
+}
+function getSandboxInstruments() {
+  if (!sandboxOperationTotal) {
+    const meter = getMeter("vm0-runner");
+    sandboxOperationTotal = meter.createCounter("sandbox_operation_total", {
+      description: "Total number of sandbox operations"
+    });
+    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"
+      }
+    );
+  }
+  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);
+  }
+  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);
+  }
+  sandboxOperationDuration2.record(attrs.durationMs, {
+    ...labels,
+    success: String(attrs.success)
+  });
+}
+
+// src/lib/metrics/timing.ts
+async function withRunnerTiming(actionType, fn) {
+  const startTime = Date.now();
+  let success = true;
+  try {
+    return await fn();
+  } catch (error) {
+    success = false;
+    throw error;
+  } finally {
+    recordRunnerOperation({
+      actionType,
+      durationMs: Date.now() - startTime,
+      success
+    });
+  }
+}
+async function withSandboxTiming(actionType, fn) {
+  const startTime = Date.now();
+  let success = true;
+  try {
+    return await fn();
+  } catch (error) {
+    success = false;
+    throw error;
+  } finally {
+    recordSandboxOperation({
+      actionType,
+      durationMs: Date.now() - startTime,
+      success
+    });
+  }
+}
+
 // src/lib/executor.ts
 function getVmIdFromRunId(runId) {
   return runId.split("-")[0] || runId.substring(0, 8);
@@ -10142,11 +10392,12 @@ nameserver 1.1.1.1`;
     `sudo sh -c 'rm -f /etc/resolv.conf && echo "${dnsConfig}" > /etc/resolv.conf'`
   );
 }
-async function executeJob(context, config) {
+async function executeJob(context, config, options = {}) {
   const vmId = getVmIdFromRunId(context.runId);
   let vm = null;
   let guestIp = null;
-  console.log(`[Executor] Starting job ${context.runId} in VM ${vmId}`);
+  const log = options.logger ?? ((msg) => console.log(msg));
+  log(`[Executor] Starting job ${context.runId} in VM ${vmId}`);
   try {
     const workspacesDir = path4.join(process.cwd(), "workspaces");
     const vmConfig = {
@@ -10158,24 +10409,27 @@ async function executeJob(context, config) {
       firecrackerBinary: config.firecracker.binary,
       workDir: path4.join(workspacesDir, `vm0-${vmId}`)
     };
-    console.log(`[Executor] Creating VM ${vmId}...`);
+    log(`[Executor] Creating VM ${vmId}...`);
     vm = new FirecrackerVM(vmConfig);
-    await vm.start();
+    await withSandboxTiming("vm_create", () => vm.start());
     guestIp = vm.getGuestIp();
     if (!guestIp) {
       throw new Error("VM started but no IP address available");
     }
-    console.log(`[Executor] VM ${vmId} started, guest IP: ${guestIp}`);
+    log(`[Executor] VM ${vmId} started, guest IP: ${guestIp}`);
     const privateKeyPath = getRunnerSSHKeyPath();
     const ssh = createVMSSHClient(guestIp, "user", privateKeyPath || void 0);
-    console.log(`[Executor] Waiting for SSH on ${guestIp}...`);
-    await ssh.waitUntilReachable(12e4, 2e3);
-    console.log(`[Executor] SSH ready on ${guestIp}`);
+    log(`[Executor] Waiting for SSH on ${guestIp}...`);
+    await withSandboxTiming(
+      "ssh_wait",
+      () => ssh.waitUntilReachable(12e4, 2e3)
+    );
+    log(`[Executor] SSH ready on ${guestIp}`);
     const firewallConfig = context.experimentalFirewall;
     if (firewallConfig?.enabled) {
       const mitmEnabled = firewallConfig.experimental_mitm ?? false;
       const sealSecretsEnabled = firewallConfig.experimental_seal_secrets ?? false;
-      console.log(
+      log(
         `[Executor] Setting up network security for VM ${guestIp} (mitm=${mitmEnabled}, sealSecrets=${sealSecretsEnabled})`
       );
       await setupVMProxyRules(guestIp, config.proxy.port);
@@ -10188,36 +10442,50 @@ async function executeJob(context, config) {
         await installProxyCA(ssh);
       }
     }
-    console.log(`[Executor] Configuring DNS...`);
+    log(`[Executor] Configuring DNS...`);
     await configureDNS(ssh);
-    console.log(`[Executor] Uploading scripts...`);
-    await uploadScripts(ssh);
-    console.log(`[Executor] Scripts uploaded to ${SCRIPT_PATHS.baseDir}`);
+    log(`[Executor] Uploading scripts...`);
+    await withSandboxTiming("script_upload", () => uploadScripts(ssh));
+    log(`[Executor] Scripts uploaded to ${SCRIPT_PATHS.baseDir}`);
     if (context.storageManifest) {
-      await downloadStorages(ssh, context.storageManifest);
+      await withSandboxTiming(
+        "storage_download",
+        () => downloadStorages(ssh, context.storageManifest)
+      );
     }
     if (context.resumeSession) {
-      await restoreSessionHistory(
-        ssh,
-        context.resumeSession,
-        context.workingDir,
-        context.cliAgentType || "claude-code"
+      await withSandboxTiming(
+        "session_restore",
+        () => restoreSessionHistory(
+          ssh,
+          context.resumeSession,
+          context.workingDir,
+          context.cliAgentType || "claude-code"
+        )
       );
     }
     const envVars = buildEnvironmentVariables(context, config.server.url);
     const envJson = JSON.stringify(envVars);
-    console.log(
+    log(
       `[Executor] Writing env JSON (${envJson.length} bytes) to ${ENV_JSON_PATH}`
     );
     await ssh.writeFile(ENV_JSON_PATH, envJson);
     const systemLogFile = `/tmp/vm0-main-${context.runId}.log`;
     const exitCodeFile = `/tmp/vm0-exit-${context.runId}`;
-    console.log(`[Executor] Running agent via env-loader (background)...`);
     const startTime = Date.now();
-    await ssh.exec(
-      `nohup sh -c 'python3 -u ${ENV_LOADER_PATH}; echo $? > ${exitCodeFile}' > ${systemLogFile} 2>&1 &`
-    );
-    console.log(`[Executor] Agent started in background`);
+    if (options.benchmarkMode) {
+      log(`[Executor] Running command directly (benchmark mode)...`);
+      await ssh.exec(
+        `nohup sh -c '${context.prompt}; echo $? > ${exitCodeFile}' > ${systemLogFile} 2>&1 &`
+      );
+      log(`[Executor] Command started in background`);
+    } else {
+      log(`[Executor] Running agent via env-loader (background)...`);
+      await ssh.exec(
+        `nohup sh -c 'python3 -u ${ENV_LOADER_PATH}; echo $? > ${exitCodeFile}' > ${systemLogFile} 2>&1 &`
+      );
+      log(`[Executor] Agent started in background`);
+    }
     const pollIntervalMs = 2e3;
     const maxWaitMs = 24 * 60 * 60 * 1e3;
     let exitCode = 1;
@@ -10226,25 +10494,35 @@ async function executeJob(context, config) {
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
       const checkResult = await ssh.exec(`cat ${exitCodeFile} 2>/dev/null`);
       if (checkResult.exitCode === 0 && checkResult.stdout.trim()) {
-        exitCode = parseInt(checkResult.stdout.trim(), 10) || 1;
+        const parsed = parseInt(checkResult.stdout.trim(), 10);
+        exitCode = Number.isNaN(parsed) ? 1 : parsed;
         completed = true;
         break;
       }
     }
-    const duration = Math.round((Date.now() - startTime) / 1e3);
+    const durationMs = Date.now() - startTime;
+    const duration = Math.round(durationMs / 1e3);
     if (!completed) {
-      console.log(`[Executor] Agent timed out after ${duration}s`);
+      log(`[Executor] Agent timed out after ${duration}s`);
+      recordRunnerOperation({
+        actionType: "agent_execute",
+        durationMs,
+        success: false
+      });
       return {
         exitCode: 1,
         error: `Agent execution timed out after ${duration}s`
       };
     }
-    console.log(
-      `[Executor] Agent finished in ${duration}s with exit code ${exitCode}`
-    );
+    recordRunnerOperation({
+      actionType: "agent_execute",
+      durationMs,
+      success: exitCode === 0
+    });
+    log(`[Executor] Agent finished in ${duration}s with exit code ${exitCode}`);
     const logResult = await ssh.exec(`tail -100 ${systemLogFile} 2>/dev/null`);
     if (logResult.stdout) {
-      console.log(
+      log(
         `[Executor] Log output (${logResult.stdout.length} chars): ${logResult.stdout.substring(0, 500)}`
       );
     }
@@ -10261,7 +10539,7 @@ async function executeJob(context, config) {
     };
   } finally {
     if (context.experimentalFirewall?.enabled && guestIp) {
-      console.log(`[Executor] Cleaning up network security for VM ${guestIp}`);
+      log(`[Executor] Cleaning up network security for VM ${guestIp}`);
       try {
         await removeVMProxyRules(guestIp, config.proxy.port);
       } catch (err) {
@@ -10270,21 +10548,23 @@ async function executeJob(context, config) {
         );
       }
       getVMRegistry().unregister(guestIp);
-      try {
-        await uploadNetworkLogs(
-          config.server.url,
-          context.sandboxToken,
-          context.runId
-        );
-      } catch (err) {
-        console.error(
-          `[Executor] Failed to upload network logs: ${err instanceof Error ? err.message : "Unknown error"}`
-        );
+      if (!options.benchmarkMode) {
+        try {
+          await uploadNetworkLogs(
+            config.server.url,
+            context.sandboxToken,
+            context.runId
+          );
+        } catch (err) {
+          console.error(
+            `[Executor] Failed to upload network logs: ${err instanceof Error ? err.message : "Unknown error"}`
+          );
+        }
       }
     }
     if (vm) {
-      console.log(`[Executor] Cleaning up VM ${vmId}...`);
-      await vm.kill();
+      log(`[Executor] Cleaning up VM ${vmId}...`);
+      await withSandboxTiming("cleanup", () => vm.kill());
     }
   }
 }
@@ -10331,6 +10611,18 @@ var startCommand = new Command("start").description("Start the runner").option("
     const config = loadConfig(options.config);
     validateFirecrackerPaths(config.firecracker);
     console.log("Config valid");
+    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:");
@@ -10419,7 +10711,10 @@ var startCommand = new Command("start").description("Start the runner").option("
         continue;
       }
       try {
-        const job = await pollForJob(config.server, config.group);
+        const job = await withRunnerTiming(
+          "poll",
+          () => pollForJob(config.server, config.group)
+        );
         if (!job) {
           await new Promise(
             (resolve) => setTimeout(resolve, config.sandbox.poll_interval_ms)
@@ -10428,7 +10723,10 @@ var startCommand = new Command("start").description("Start the runner").option("
         }
         console.log(`Found job: ${job.runId}`);
         try {
-          const context = await claimJob(config.server, job.runId);
+          const context = await withRunnerTiming(
+            "claim",
+            () => claimJob(config.server, job.runId)
+          );
           console.log(`Claimed job: ${context.runId}`);
           activeJobs.add(context.runId);
           updateStatus();
@@ -10467,6 +10765,9 @@ var startCommand = new Command("start").description("Start the runner").option("
       console.log("Stopping network proxy...");
       await getProxyManager().stop();
     }
+    console.log("Flushing metrics...");
+    await flushMetrics();
+    await shutdownMetrics();
     state.mode = "stopped";
     updateStatus();
     console.log("Runner stopped");
@@ -10505,10 +10806,102 @@ var statusCommand = new Command2("status").description("Check runner connectivit
   }
 });
 
+// src/commands/benchmark.ts
+import { Command as Command3 } from "commander";
+import crypto from "crypto";
+
+// src/lib/timing.ts
+var Timer = class {
+  startTime;
+  constructor() {
+    this.startTime = Date.now();
+  }
+  /**
+   * Get elapsed time formatted as [MM:SS.s]
+   */
+  elapsed() {
+    const ms = Date.now() - this.startTime;
+    const totalSeconds = ms / 1e3;
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = (totalSeconds % 60).toFixed(1);
+    return `[${String(minutes).padStart(2, "0")}:${seconds.padStart(4, "0")}]`;
+  }
+  /**
+   * Log message with timestamp
+   */
+  log(message) {
+    console.log(`${this.elapsed()} ${message}`);
+  }
+  /**
+   * Get total elapsed time in seconds
+   */
+  totalSeconds() {
+    return (Date.now() - this.startTime) / 1e3;
+  }
+};
+
+// src/commands/benchmark.ts
+function createBenchmarkContext(prompt, options) {
+  return {
+    runId: crypto.randomUUID(),
+    prompt,
+    agentComposeVersionId: "benchmark-local",
+    vars: null,
+    secretNames: null,
+    checkpointId: null,
+    sandboxToken: "benchmark-token-not-used",
+    workingDir: options.workingDir,
+    storageManifest: null,
+    environment: null,
+    resumeSession: null,
+    secretValues: null,
+    cliAgentType: options.agentType
+  };
+}
+var benchmarkCommand = new Command3("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();
+  try {
+    timer.log("Loading configuration...");
+    const config = loadDebugConfig(options.config);
+    validateFirecrackerPaths(config.firecracker);
+    timer.log("Checking network prerequisites...");
+    const networkCheck = checkNetworkPrerequisites();
+    if (!networkCheck.ok) {
+      console.error("Network prerequisites not met:");
+      for (const error of networkCheck.errors) {
+        console.error(`  - ${error}`);
+      }
+      process.exit(1);
+    }
+    timer.log("Setting up network bridge...");
+    await setupBridge();
+    timer.log(`Executing command: ${prompt}`);
+    const context = createBenchmarkContext(prompt, options);
+    const result = await executeJob(context, config, {
+      benchmarkMode: true,
+      logger: timer.log.bind(timer)
+    });
+    timer.log(`Exit code: ${result.exitCode}`);
+    if (result.error) {
+      timer.log(`Error: ${result.error}`);
+    }
+    timer.log(`Total time: ${timer.totalSeconds().toFixed(1)}s`);
+    process.exit(result.exitCode);
+  } catch (error) {
+    timer.log(
+      `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+});
+
 // src/index.ts
-var version = true ? "2.6.1" : "0.1.0";
+var version = true ? "2.7.0" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(statusCommand);
+program.addCommand(benchmarkCommand);
 program.parse();
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/runner",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",
@@ -15,6 +15,11 @@
     "."
   ],
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.52.0",
+    "@opentelemetry/resources": "^1.25.0",
+    "@opentelemetry/sdk-metrics": "^1.25.0",
+    "@opentelemetry/semantic-conventions": "^1.25.0",
     "commander": "^14.0.0",
     "yaml": "^2.3.4",
     "zod": "^3.25.64"