@vm0/runner 3.0.6 → 3.2.0

package/index.js

@@ -192,10 +192,11 @@ async function completeJob(apiUrl, context, exitCode, error) {
 import path4 from "path";
 
 // src/lib/firecracker/vm.ts
-import { execSync as execSync2, spawn } from "child_process";
+import { exec as exec3, spawn } from "child_process";
 import fs3 from "fs";
 import path2 from "path";
 import readline from "readline";
+import { promisify as promisify3 } from "util";
 
 // src/lib/firecracker/client.ts
 import http from "http";
@@ -706,23 +707,24 @@ async function clearStaleIptablesRulesForIP(ip) {
   } catch {
   }
 }
-async function createTapDevice(vmId) {
+async function createTapDevice(vmId, logger) {
+  const log = logger ?? console.log;
   const tapDevice = `tap${vmId.substring(0, 8)}`;
   const guestMac = generateMacAddress(vmId);
   const guestIp = await allocateIP(vmId);
+  log(`[VM ${vmId}] IP allocated: ${guestIp}`);
   await clearStaleIptablesRulesForIP(guestIp);
-  console.log(`Creating TAP device ${tapDevice} for VM ${vmId}...`);
-  await setupBridge();
+  log(`[VM ${vmId}] Stale iptables cleared`);
   if (await tapDeviceExists(tapDevice)) {
-    console.log(`TAP device ${tapDevice} already exists, deleting it first...`);
+    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`);
   await execCommand(`ip link set ${tapDevice} master ${BRIDGE_NAME2}`);
+  log(`[VM ${vmId}] TAP added to bridge`);
   await execCommand(`ip link set ${tapDevice} up`);
-  console.log(
-    `TAP ${tapDevice} created: guest MAC ${guestMac}, guest IP ${guestIp}`
-  );
+  log(`[VM ${vmId}] TAP created: ${tapDevice}, MAC ${guestMac}, IP ${guestIp}`);
   return {
     tapDevice,
     guestMac,
@@ -959,6 +961,7 @@ async function cleanupOrphanedProxyRules(runnerName) {
 }
 
 // src/lib/firecracker/vm.ts
+var execAsync3 = promisify3(exec3);
 var FirecrackerVM = class {
   config;
   process = null;
@@ -978,6 +981,9 @@ 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
    */
@@ -1021,15 +1027,21 @@ var FirecrackerVM = class {
       if (fs3.existsSync(this.socketPath)) {
         fs3.unlinkSync(this.socketPath);
       }
-      console.log(`[VM ${this.config.vmId}] Creating sparse overlay file...`);
-      const overlaySize = 2 * 1024 * 1024 * 1024;
-      const fd = fs3.openSync(this.vmOverlayPath, "w");
-      fs3.ftruncateSync(fd, overlaySize);
-      fs3.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...`);
+      this.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`);
+      };
+      const [, networkConfig] = await Promise.all([
+        createOverlay(),
+        createTapDevice(this.config.vmId, this.log.bind(this))
+      ]);
+      this.networkConfig = networkConfig;
+      this.log(`[VM ${this.config.vmId}] Starting Firecracker...`);
       this.process = spawn(
         this.config.firecrackerBinary,
         ["--api-sock", this.socketPath],
@@ -1040,11 +1052,11 @@ var FirecrackerVM = class {
         }
       );
       this.process.on("error", (err) => {
-        console.error(`[VM ${this.config.vmId}] Firecracker error:`, err);
+        this.log(`[VM ${this.config.vmId}] Firecracker error: ${err}`);
         this.state = "error";
       });
       this.process.on("exit", (code, signal) => {
-        console.log(
+        this.log(
           `[VM ${this.config.vmId}] Firecracker exited: code=${code}, signal=${signal}`
         );
         if (this.state !== "stopped") {
@@ -1057,7 +1069,7 @@ var FirecrackerVM = class {
         });
         stdoutRL.on("line", (line) => {
           if (line.trim()) {
-            console.log(`[VM ${this.config.vmId}] ${line}`);
+            this.log(`[VM ${this.config.vmId}] ${line}`);
           }
         });
       }
@@ -1067,19 +1079,19 @@ var FirecrackerVM = class {
         });
         stderrRL.on("line", (line) => {
           if (line.trim()) {
-            console.error(`[VM ${this.config.vmId}] stderr: ${line}`);
+            this.log(`[VM ${this.config.vmId}] stderr: ${line}`);
           }
         });
       }
       this.client = new FirecrackerClient(this.socketPath);
-      console.log(`[VM ${this.config.vmId}] Waiting for API...`);
+      this.log(`[VM ${this.config.vmId}] Waiting for API...`);
       await this.client.waitUntilReady(1e4, 100);
       this.state = "configuring";
       await this.configure();
-      console.log(`[VM ${this.config.vmId}] Booting...`);
+      this.log(`[VM ${this.config.vmId}] Booting...`);
       await this.client.start();
       this.state = "running";
-      console.log(
+      this.log(
         `[VM ${this.config.vmId}] Running at ${this.networkConfig.guestIp}`
       );
     } catch (error) {
@@ -1095,7 +1107,7 @@ var FirecrackerVM = class {
     if (!this.client || !this.networkConfig) {
       throw new Error("VM not properly initialized");
     }
-    console.log(
+    this.log(
       `[VM ${this.config.vmId}] Configuring: ${this.config.vcpus} vCPUs, ${this.config.memoryMb}MB RAM`
     );
     await this.client.setMachineConfig({
@@ -1104,28 +1116,26 @@ 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}`;
-    console.log(`[VM ${this.config.vmId}] Boot args: ${bootArgs}`);
+    this.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}] Base rootfs: ${this.config.rootfsPath}`
-    );
+    this.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
     });
-    console.log(`[VM ${this.config.vmId}] Overlay: ${this.vmOverlayPath}`);
+    this.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
     });
-    console.log(
+    this.log(
       `[VM ${this.config.vmId}] Network: ${this.networkConfig.tapDevice}`
     );
     await this.client.setNetworkInterface({
@@ -1133,7 +1143,7 @@ var FirecrackerVM = class {
       guest_mac: this.networkConfig.guestMac,
       host_dev_name: this.networkConfig.tapDevice
     });
-    console.log(`[VM ${this.config.vmId}] Vsock: ${this.vsockPath}`);
+    this.log(`[VM ${this.config.vmId}] Vsock: ${this.vsockPath}`);
     await this.client.setVsock({
       vsock_id: "vsock0",
       guest_cid: 3,
@@ -1145,17 +1155,16 @@ var FirecrackerVM = class {
    */
   async stop() {
     if (this.state !== "running") {
-      console.log(`[VM ${this.config.vmId}] Not running, state: ${this.state}`);
+      this.log(`[VM ${this.config.vmId}] Not running, state: ${this.state}`);
       return;
     }
     this.state = "stopping";
-    console.log(`[VM ${this.config.vmId}] Stopping...`);
+    this.log(`[VM ${this.config.vmId}] Stopping...`);
     try {
       if (this.client) {
         await this.client.sendCtrlAltDel().catch((error) => {
-          console.log(
-            `[VM ${this.config.vmId}] Graceful shutdown signal failed (VM may already be stopping):`,
-            error instanceof Error ? error.message : error
+          this.log(
+            `[VM ${this.config.vmId}] Graceful shutdown signal failed (VM may already be stopping): ${error instanceof Error ? error.message : error}`
           );
         });
       }
@@ -1167,7 +1176,7 @@ var FirecrackerVM = class {
    * Force kill the VM
    */
   async kill() {
-    console.log(`[VM ${this.config.vmId}] Force killing...`);
+    this.log(`[VM ${this.config.vmId}] Force killing...`);
     await this.cleanup();
   }
   /**
@@ -1192,7 +1201,7 @@ var FirecrackerVM = class {
     }
     this.client = null;
     this.state = "stopped";
-    console.log(`[VM ${this.config.vmId}] Stopped`);
+    this.log(`[VM ${this.config.vmId}] Stopped`);
   }
   /**
    * Wait for the VM process to exit
@@ -5626,11 +5635,6 @@ var appStringSchema = z6.string().superRefine((val, ctx) => {
 });
 var agentDefinitionSchema = z6.object({
   description: z6.string().optional(),
-  /**
-   * @deprecated Use `apps` field instead for pre-installed tools.
-   * This field will be removed in a future version.
-   */
-  image: z6.string().optional(),
   framework: z6.string().min(1, "Framework is required"),
   /**
    * Array of pre-installed apps/tools for the agent environment.
@@ -5640,8 +5644,6 @@ var agentDefinitionSchema = z6.object({
    */
   apps: z6.array(appStringSchema).optional(),
   volumes: z6.array(z6.string()).optional(),
-  working_dir: z6.string().optional(),
-  // Optional when provider supports auto-config
   environment: z6.record(z6.string(), z6.string()).optional(),
   /**
    * Path to instructions file (e.g., AGENTS.md).
@@ -5668,7 +5670,17 @@ var agentDefinitionSchema = z6.object({
    * Requires experimental_runner to be configured.
    * When enabled, filters outbound traffic by domain/IP rules.
    */
-  experimental_firewall: experimentalFirewallSchema.optional()
+  experimental_firewall: experimentalFirewallSchema.optional(),
+  /**
+   * @deprecated Server-resolved field. User input is ignored.
+   * @internal
+   */
+  image: z6.string().optional(),
+  /**
+   * @deprecated Server-resolved field. User input is ignored.
+   * @internal
+   */
+  working_dir: z6.string().optional()
 });
 var agentComposeContentSchema = z6.object({
   version: z6.string().min(1, "Version is required"),
@@ -6800,13 +6812,11 @@ var scopeResponseSchema = z14.object({
   id: z14.string().uuid(),
   slug: z14.string(),
   type: scopeTypeSchema,
-  displayName: z14.string().nullable(),
   createdAt: z14.string(),
   updatedAt: z14.string()
 });
 var createScopeRequestSchema = z14.object({
-  slug: scopeSlugSchema,
-  displayName: z14.string().max(128).optional()
+  slug: scopeSlugSchema
 });
 var updateScopeRequestSchema = z14.object({
   slug: scopeSlugSchema,
@@ -7453,6 +7463,9 @@ var realtimeTokenContract = c14.router({
   }
 });
 
+// ../../packages/core/src/contracts/platform.ts
+import { z as z21 } from "zod";
+
 // ../../packages/core/src/contracts/public/common.ts
 import { z as z20 } from "zod";
 var publicApiErrorTypeSchema = z20.enum([
@@ -7493,29 +7506,92 @@ var listQuerySchema = z20.object({
 var requestIdSchema = z20.string().uuid();
 var timestampSchema = z20.string().datetime();
 
-// ../../packages/core/src/contracts/public/agents.ts
-import { z as z21 } from "zod";
+// ../../packages/core/src/contracts/platform.ts
 var c15 = initContract();
-var publicAgentSchema = z21.object({
-  id: z21.string(),
-  name: z21.string(),
-  current_version_id: z21.string().nullable(),
+var platformLogStatusSchema = z21.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "timeout",
+  "cancelled"
+]);
+var platformLogEntrySchema = z21.object({
+  id: z21.string().uuid()
+});
+var platformLogsListResponseSchema = createPaginatedResponseSchema(
+  platformLogEntrySchema
+);
+var artifactSchema = z21.object({
+  name: z21.string().nullable(),
+  version: z21.string().nullable()
+});
+var platformLogDetailSchema = z21.object({
+  id: z21.string().uuid(),
+  sessionId: z21.string().nullable(),
+  agentName: z21.string(),
+  provider: z21.string(),
+  status: platformLogStatusSchema,
+  prompt: z21.string(),
+  error: z21.string().nullable(),
+  createdAt: z21.string(),
+  startedAt: z21.string().nullable(),
+  completedAt: z21.string().nullable(),
+  artifact: artifactSchema
+});
+var platformLogsListContract = c15.router({
+  list: {
+    method: "GET",
+    path: "/api/platform/logs",
+    query: listQuerySchema.extend({
+      search: z21.string().optional()
+    }),
+    responses: {
+      200: platformLogsListResponseSchema,
+      401: apiErrorSchema
+    },
+    summary: "List agent run logs with pagination"
+  }
+});
+var platformLogsByIdContract = c15.router({
+  getById: {
+    method: "GET",
+    path: "/api/platform/logs/:id",
+    pathParams: z21.object({
+      id: z21.string().uuid("Invalid log ID")
+    }),
+    responses: {
+      200: platformLogDetailSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get agent run log details by ID"
+  }
+});
+
+// ../../packages/core/src/contracts/public/agents.ts
+import { z as z22 } from "zod";
+var c16 = initContract();
+var publicAgentSchema = z22.object({
+  id: z22.string(),
+  name: z22.string(),
+  current_version_id: z22.string().nullable(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var agentVersionSchema = z21.object({
-  id: z21.string(),
-  agent_id: z21.string(),
-  version_number: z21.number(),
+var agentVersionSchema = z22.object({
+  id: z22.string(),
+  agent_id: z22.string(),
+  version_number: z22.number(),
   created_at: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z21.string().optional()
+  name: z22.string().optional()
 });
-var publicAgentsListContract = c15.router({
+var publicAgentsListContract = c16.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -7530,13 +7606,13 @@ var publicAgentsListContract = c15.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c15.router({
+var publicAgentByIdContract = c16.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z21.object({
-      id: z21.string().min(1, "Agent ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -7548,13 +7624,13 @@ var publicAgentByIdContract = c15.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c15.router({
+var publicAgentVersionsContract = c16.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z21.object({
-      id: z21.string().min(1, "Agent ID is required")
+    pathParams: z22.object({
+      id: z22.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7569,9 +7645,9 @@ var publicAgentVersionsContract = c15.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z22 } from "zod";
-var c16 = initContract();
-var publicRunStatusSchema = z22.enum([
+import { z as z23 } from "zod";
+var c17 = initContract();
+var publicRunStatusSchema = z23.enum([
   "pending",
   "running",
   "completed",
@@ -7579,56 +7655,56 @@ var publicRunStatusSchema = z22.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z22.object({
-  id: z22.string(),
-  agent_id: z22.string(),
-  agent_name: z22.string(),
+var publicRunSchema = z23.object({
+  id: z23.string(),
+  agent_id: z23.string(),
+  agent_name: z23.string(),
   status: publicRunStatusSchema,
-  prompt: z22.string(),
+  prompt: z23.string(),
   created_at: timestampSchema,
   started_at: timestampSchema.nullable(),
   completed_at: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z22.string().nullable(),
-  execution_time_ms: z22.number().nullable(),
-  checkpoint_id: z22.string().nullable(),
-  session_id: z22.string().nullable(),
-  artifact_name: z22.string().nullable(),
-  artifact_version: z22.string().nullable(),
-  volumes: z22.record(z22.string(), z22.string()).optional()
+  error: z23.string().nullable(),
+  execution_time_ms: z23.number().nullable(),
+  checkpoint_id: z23.string().nullable(),
+  session_id: z23.string().nullable(),
+  artifact_name: z23.string().nullable(),
+  artifact_version: z23.string().nullable(),
+  volumes: z23.record(z23.string(), z23.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z22.object({
+var createRunRequestSchema = z23.object({
   // Agent identification (one of: agent, agent_id, session_id, checkpoint_id)
-  agent: z22.string().optional(),
+  agent: z23.string().optional(),
   // Agent name
-  agent_id: z22.string().optional(),
+  agent_id: z23.string().optional(),
   // Agent ID
-  agent_version: z22.string().optional(),
+  agent_version: z23.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  session_id: z22.string().optional(),
+  session_id: z23.string().optional(),
   // Resume from checkpoint
-  checkpoint_id: z22.string().optional(),
+  checkpoint_id: z23.string().optional(),
   // Required
-  prompt: z22.string().min(1, "Prompt is required"),
+  prompt: z23.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z22.record(z22.string(), z22.string()).optional(),
-  secrets: z22.record(z22.string(), z22.string()).optional(),
-  artifact_name: z22.string().optional(),
+  variables: z23.record(z23.string(), z23.string()).optional(),
+  secrets: z23.record(z23.string(), z23.string()).optional(),
+  artifact_name: z23.string().optional(),
   // Artifact name to mount
-  artifact_version: z22.string().optional(),
+  artifact_version: z23.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z22.record(z22.string(), z22.string()).optional()
+  volumes: z23.record(z23.string(), z23.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
-  agent_id: z22.string().optional(),
+  agent_id: z23.string().optional(),
   status: publicRunStatusSchema.optional(),
   since: timestampSchema.optional()
 });
-var publicRunsListContract = c16.router({
+var publicRunsListContract = c17.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -7659,13 +7735,13 @@ var publicRunsListContract = c16.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c16.router({
+var publicRunByIdContract = c17.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -7677,15 +7753,15 @@ var publicRunByIdContract = c16.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c16.router({
+var publicRunCancelContract = c17.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
-    body: z22.undefined(),
+    body: z23.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -7698,27 +7774,27 @@ var publicRunCancelContract = c16.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z22.object({
+var logEntrySchema = z23.object({
   timestamp: timestampSchema,
-  type: z22.enum(["agent", "system", "network"]),
-  level: z22.enum(["debug", "info", "warn", "error"]),
-  message: z22.string(),
-  metadata: z22.record(z22.string(), z22.unknown()).optional()
+  type: z23.enum(["agent", "system", "network"]),
+  level: z23.enum(["debug", "info", "warn", "error"]),
+  message: z23.string(),
+  metadata: z23.record(z23.string(), z23.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z22.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z23.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z22.enum(["asc", "desc"]).default("asc")
+  order: z23.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c16.router({
+var publicRunLogsContract = c17.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -7731,30 +7807,30 @@ var publicRunLogsContract = c16.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z22.object({
+var metricPointSchema = z23.object({
   timestamp: timestampSchema,
-  cpu_percent: z22.number(),
-  memory_used_mb: z22.number(),
-  memory_total_mb: z22.number(),
-  disk_used_mb: z22.number(),
-  disk_total_mb: z22.number()
-});
-var metricsSummarySchema = z22.object({
-  avg_cpu_percent: z22.number(),
-  max_memory_used_mb: z22.number(),
-  total_duration_ms: z22.number().nullable()
-});
-var metricsResponseSchema2 = z22.object({
-  data: z22.array(metricPointSchema),
+  cpu_percent: z23.number(),
+  memory_used_mb: z23.number(),
+  memory_total_mb: z23.number(),
+  disk_used_mb: z23.number(),
+  disk_total_mb: z23.number()
+});
+var metricsSummarySchema = z23.object({
+  avg_cpu_percent: z23.number(),
+  max_memory_used_mb: z23.number(),
+  total_duration_ms: z23.number().nullable()
+});
+var metricsResponseSchema2 = z23.object({
+  data: z23.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c16.router({
+var publicRunMetricsContract = c17.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -7766,7 +7842,7 @@ var publicRunMetricsContract = c16.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z22.enum([
+var sseEventTypeSchema = z23.enum([
   "status",
   // Run status change
   "output",
@@ -7778,26 +7854,26 @@ var sseEventTypeSchema = z22.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z22.object({
+var sseEventSchema = z23.object({
   event: sseEventTypeSchema,
-  data: z22.unknown(),
-  id: z22.string().optional()
+  data: z23.unknown(),
+  id: z23.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c16.router({
+var publicRunEventsContract = c17.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z22.object({
-      id: z22.string().min(1, "Run ID is required")
+    pathParams: z23.object({
+      id: z23.string().min(1, "Run ID is required")
     }),
-    query: z22.object({
-      last_event_id: z22.string().optional()
+    query: z23.object({
+      last_event_id: z23.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z22.any(),
+      200: z23.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -7809,28 +7885,28 @@ var publicRunEventsContract = c16.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z23 } from "zod";
-var c17 = initContract();
-var publicArtifactSchema = z23.object({
-  id: z23.string(),
-  name: z23.string(),
-  current_version_id: z23.string().nullable(),
-  size: z23.number(),
+import { z as z24 } from "zod";
+var c18 = initContract();
+var publicArtifactSchema = z24.object({
+  id: z24.string(),
+  name: z24.string(),
+  current_version_id: z24.string().nullable(),
+  size: z24.number(),
   // Total size in bytes
-  file_count: z23.number(),
+  file_count: z24.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var artifactVersionSchema = z23.object({
-  id: z23.string(),
+var artifactVersionSchema = z24.object({
+  id: z24.string(),
   // SHA-256 content hash
-  artifact_id: z23.string(),
-  size: z23.number(),
+  artifact_id: z24.string(),
+  size: z24.number(),
   // Size in bytes
-  file_count: z23.number(),
-  message: z23.string().nullable(),
+  file_count: z24.number(),
+  message: z24.string().nullable(),
   // Optional commit message
-  created_by: z23.string(),
+  created_by: z24.string(),
   created_at: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -7840,7 +7916,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c17.router({
+var publicArtifactsListContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -7855,13 +7931,13 @@ var publicArtifactsListContract = c17.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c17.router({
+var publicArtifactByIdContract = c18.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -7873,13 +7949,13 @@ var publicArtifactByIdContract = c17.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c17.router({
+var publicArtifactVersionsContract = c18.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7892,20 +7968,20 @@ var publicArtifactVersionsContract = c17.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c17.router({
+var publicArtifactDownloadContract = c18.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Artifact ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Artifact ID is required")
     }),
-    query: z23.object({
-      version_id: z23.string().optional()
+    query: z24.object({
+      version_id: z24.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z23.undefined(),
+      302: z24.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -7917,28 +7993,28 @@ var publicArtifactDownloadContract = c17.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z24 } from "zod";
-var c18 = initContract();
-var publicVolumeSchema = z24.object({
-  id: z24.string(),
-  name: z24.string(),
-  current_version_id: z24.string().nullable(),
-  size: z24.number(),
+import { z as z25 } from "zod";
+var c19 = initContract();
+var publicVolumeSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  current_version_id: z25.string().nullable(),
+  size: z25.number(),
   // Total size in bytes
-  file_count: z24.number(),
+  file_count: z25.number(),
   created_at: timestampSchema,
   updated_at: timestampSchema
 });
-var volumeVersionSchema = z24.object({
-  id: z24.string(),
+var volumeVersionSchema = z25.object({
+  id: z25.string(),
   // SHA-256 content hash
-  volume_id: z24.string(),
-  size: z24.number(),
+  volume_id: z25.string(),
+  size: z25.number(),
   // Size in bytes
-  file_count: z24.number(),
-  message: z24.string().nullable(),
+  file_count: z25.number(),
+  message: z25.string().nullable(),
   // Optional commit message
-  created_by: z24.string(),
+  created_by: z25.string(),
   created_at: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -7946,7 +8022,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c18.router({
+var publicVolumesListContract = c19.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -7961,13 +8037,13 @@ var publicVolumesListContract = c18.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c18.router({
+var publicVolumeByIdContract = c19.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -7979,13 +8055,13 @@ var publicVolumeByIdContract = c18.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c18.router({
+var publicVolumeVersionsContract = c19.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -7998,20 +8074,20 @@ var publicVolumeVersionsContract = c18.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c18.router({
+var publicVolumeDownloadContract = c19.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Volume ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Volume ID is required")
     }),
-    query: z24.object({
-      version_id: z24.string().optional()
+    query: z25.object({
+      version_id: z25.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z24.undefined(),
+      302: z25.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -9299,7 +9375,8 @@ async function executeJob(context, config, options = {}) {
       kernelPath: config.firecracker.kernel,
       rootfsPath: config.firecracker.rootfs,
       firecrackerBinary: config.firecracker.binary,
-      workDir: path4.join(workspacesDir, `vm0-${vmId}`)
+      workDir: path4.join(workspacesDir, `vm0-${vmId}`),
+      logger: log
     };
     log(`[Executor] Creating VM ${vmId}...`);
     vm = new FirecrackerVM(vmConfig);
@@ -10253,14 +10330,14 @@ var Timer = class {
     this.startTime = Date.now();
   }
   /**
-   * Get elapsed time formatted as [MM:SS.s]
+   * Get elapsed time formatted as [MM:SS.mmm]
    */
   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")}]`;
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = Math.floor(ms % 6e4 / 1e3);
+    const millis = ms % 1e3;
+    return `[${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(millis).padStart(3, "0")}]`;
   }
   /**
    * Log message with timestamp
@@ -10334,7 +10411,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.0.6" : "0.1.0";
+var version = true ? "3.2.0" : "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.0.6",
+  "version": "3.2.0",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",