@vm0/runner 3.9.4 → 3.10.1

package/index.js

@@ -13,6 +13,16 @@ import yaml from "yaml";
 
 // src/lib/paths.ts
 import path from "path";
+
+// src/lib/firecracker/vm-id.ts
+function createVmId(runId) {
+  return runId.substring(0, 8).padStart(8, "0");
+}
+function vmIdValue(vmId) {
+  return vmId;
+}
+
+// src/lib/paths.ts
 var VM0_RUN_DIR = "/var/run/vm0";
 var VM0_TMP_PREFIX = "/tmp/vm0";
 var runtimePaths = {
@@ -34,7 +44,7 @@ var runnerPaths = {
   /** Check if a directory name is a VM workspace */
   isVmWorkspace: (dirname) => dirname.startsWith(VM_WORKSPACE_PREFIX),
   /** Extract vmId from workspace directory name */
-  extractVmId: (dirname) => dirname.replace(VM_WORKSPACE_PREFIX, "")
+  extractVmId: (dirname) => createVmId(dirname.replace(VM_WORKSPACE_PREFIX, ""))
 };
 var vmPaths = {
   /** Firecracker config file (used with --config-file --no-api) */
@@ -360,7 +370,7 @@ function hashString(str) {
   return Math.abs(hash);
 }
 function generateMacAddress(vmId) {
-  const hash = hashString(vmId);
+  const hash = hashString(vmIdValue(vmId));
   const b1 = hash >> 16 & 255;
   const b2 = hash >> 8 & 255;
   const b3 = hash & 255;
@@ -1089,7 +1099,7 @@ var IPRegistry = class {
     return this.withIPLock(async () => {
       const registry = this.readRegistry();
       if (registry.allocations[ip]) {
-        registry.allocations[ip].vmId = vmId;
+        registry.allocations[ip].vmId = vmIdValue(vmId);
         this.writeRegistry(registry);
       }
     });
@@ -1102,7 +1112,7 @@ var IPRegistry = class {
   async clearVmIdFromIP(ip, expectedVmId) {
     return this.withIPLock(async () => {
       const registry = this.readRegistry();
-      if (registry.allocations[ip] && registry.allocations[ip].vmId === expectedVmId) {
+      if (registry.allocations[ip] && registry.allocations[ip].vmId === vmIdValue(expectedVmId)) {
         registry.allocations[ip].vmId = null;
         this.writeRegistry(registry);
       }
@@ -1122,8 +1132,9 @@ var IPRegistry = class {
    */
   getIPForVm(vmId) {
     const registry = this.readRegistry();
+    const vmIdStr = vmIdValue(vmId);
     for (const [ip, allocation] of Object.entries(registry.allocations)) {
-      if (allocation.vmId === vmId) {
+      if (allocation.vmId === vmIdStr) {
         return ip;
       }
     }
@@ -1352,12 +1363,15 @@ var TapPool = class {
     }
     const guestMac = generateMacAddress(vmId);
     try {
-      await this.config.setMac(resource.tapDevice, guestMac);
+      await Promise.all([
+        this.config.setMac(resource.tapDevice, guestMac),
+        clearArpEntry(resource.guestIp)
+      ]);
     } catch (err) {
       if (fromPool) {
         this.queue.push(resource);
         logger4.log(
-          `Returned pair to pool after MAC set failure: ${resource.tapDevice}`
+          `Returned pair to pool after MAC/ARP failure: ${resource.tapDevice}`
         );
       } else {
         await releaseIP(resource.guestIp).catch(() => {
@@ -1367,14 +1381,11 @@ var TapPool = class {
       }
       throw err;
     }
-    await clearArpEntry(resource.guestIp);
-    try {
-      await assignVmIdToIP(resource.guestIp, vmId);
-    } catch (err) {
+    assignVmIdToIP(resource.guestIp, vmId).catch((err) => {
       logger4.error(
         `Failed to assign vmId to IP registry: ${err instanceof Error ? err.message : "Unknown"}`
       );
-    }
+    });
     logger4.log(
       `Acquired: TAP ${resource.tapDevice}, MAC ${guestMac}, IP ${resource.guestIp}`
     );
@@ -1695,12 +1706,9 @@ var FirecrackerVM = class {
   /**
    * Stop the VM
    *
-   * Note: With --no-api mode, we can only force kill the process.
-   * The VM doesn't have an API endpoint for graceful shutdown.
-   *
-   * TODO(#2118): Implement graceful shutdown via vsock command to guest agent.
-   * This would allow the guest to clean up before termination without
-   * adding the startup latency of API mode.
+   * Note: With --no-api mode, we force kill the Firecracker process.
+   * Graceful shutdown (filesystem sync) should be done via vsock
+   * before calling this method.
    */
   async stop() {
     if (this.state !== "running") {
@@ -1794,6 +1802,8 @@ var MSG_WRITE_FILE = 5;
 var MSG_SPAWN_WATCH = 7;
 var MSG_SPAWN_WATCH_RESULT = 8;
 var MSG_PROCESS_EXIT = 9;
+var MSG_SHUTDOWN = 10;
+var MSG_SHUTDOWN_ACK = 11;
 var MSG_ERROR = 255;
 var FLAG_SUDO = 1;
 function encode(type, seq, payload = Buffer.alloc(0)) {
@@ -2295,6 +2305,30 @@ var VsockClient = class {
   getVsockPath() {
     return this.vsockPath;
   }
+  /**
+   * Request graceful shutdown from guest
+   *
+   * Sends shutdown command to guest agent, which syncs filesystems
+   * and returns acknowledgment. Falls back gracefully on timeout.
+   *
+   * @param timeoutMs Maximum time to wait for acknowledgment (default: 2000ms)
+   * @returns true if guest acknowledged, false on timeout/error
+   */
+  async shutdown(timeoutMs = 2e3) {
+    if (!this.connected || !this.socket) {
+      return false;
+    }
+    try {
+      const response = await this.request(
+        MSG_SHUTDOWN,
+        Buffer.alloc(0),
+        timeoutMs
+      );
+      return response.type === MSG_SHUTDOWN_ACK;
+    } catch {
+      return false;
+    }
+  }
   /**
    * Close the connection
    */
@@ -7744,7 +7778,9 @@ var c11 = initContract();
 var modelProviderTypeSchema = z17.enum([
   "claude-code-oauth-token",
   "anthropic-api-key",
-  "moonshot-api-key"
+  "openrouter-api-key",
+  "moonshot-api-key",
+  "minimax-api-key"
 ]);
 var modelProviderFrameworkSchema = z17.enum(["claude-code", "codex"]);
 var modelProviderResponseSchema = z17.object({
@@ -7873,6 +7909,27 @@ var modelProvidersSetDefaultContract = c11.router({
     summary: "Set a model provider as default for its framework"
   }
 });
+var updateModelRequestSchema = z17.object({
+  selectedModel: z17.string().optional()
+});
+var modelProvidersUpdateModelContract = c11.router({
+  updateModel: {
+    method: "PATCH",
+    path: "/api/model-providers/:type/model",
+    headers: authHeadersSchema,
+    pathParams: z17.object({
+      type: modelProviderTypeSchema
+    }),
+    body: updateModelRequestSchema,
+    responses: {
+      200: modelProviderResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Update model selection for an existing provider"
+  }
+});
 
 // ../../packages/core/src/contracts/sessions.ts
 import { z as z18 } from "zod";
@@ -8308,7 +8365,10 @@ var platformLogStatusSchema = z22.enum([
   "cancelled"
 ]);
 var platformLogEntrySchema = z22.object({
-  id: z22.string().uuid()
+  id: z22.string().uuid(),
+  agentName: z22.string(),
+  status: platformLogStatusSchema,
+  createdAt: z22.string()
 });
 var platformLogsListResponseSchema = z22.object({
   data: z22.array(platformLogEntrySchema),
@@ -10014,9 +10074,6 @@ async function uploadNetworkLogs(apiUrl, sandboxToken, runId) {
 
 // src/lib/executor.ts
 var logger10 = createLogger("Executor");
-function getVmIdFromRunId(runId) {
-  return runId.split("-")[0] || runId.substring(0, 8);
-}
 async function executeJob(context, config, options = {}) {
   setSandboxContext({
     apiUrl: config.server.url,
@@ -10030,9 +10087,10 @@ async function executeJob(context, config, options = {}) {
       success: true
     });
   }
-  const vmId = getVmIdFromRunId(context.runId);
+  const vmId = createVmId(context.runId);
   let vm = null;
   let guestIp = null;
+  let vsockClient = null;
   logger10.log(`Starting job ${context.runId} in VM ${vmId}`);
   try {
     const vmConfig = {
@@ -10053,14 +10111,12 @@ async function executeJob(context, config, options = {}) {
     }
     logger10.log(`VM ${vmId} started, guest IP: ${guestIp}`);
     const vsockPath = vm.getVsockPath();
-    const guest = new VsockClient(vsockPath);
+    vsockClient = new VsockClient(vsockPath);
+    const guest = vsockClient;
     logger10.log(`Using vsock for guest communication: ${vsockPath}`);
-    logger10.log(`Waiting for guest connection...`);
-    await withSandboxTiming(
-      "guest_wait",
-      () => guest.waitForGuestConnection(3e4)
+    const envJson = JSON.stringify(
+      buildEnvironmentVariables(context, config.server.url)
     );
-    logger10.log(`Guest client ready`);
     const firewallConfig = context.experimentalFirewall;
     if (firewallConfig?.enabled) {
       const mitmEnabled = firewallConfig.experimental_mitm ?? false;
@@ -10068,19 +10124,18 @@ async function executeJob(context, config, options = {}) {
       logger10.log(
         `Setting up network security for VM ${guestIp} (mitm=${mitmEnabled}, sealSecrets=${sealSecretsEnabled})`
       );
-      await withSandboxTiming("network_setup", async () => {
-        getVMRegistry().register(
-          guestIp,
-          context.runId,
-          context.sandboxToken,
-          {
-            firewallRules: firewallConfig?.rules,
-            mitmEnabled,
-            sealSecretsEnabled
-          }
-        );
+      getVMRegistry().register(guestIp, context.runId, context.sandboxToken, {
+        firewallRules: firewallConfig?.rules,
+        mitmEnabled,
+        sealSecretsEnabled
       });
     }
+    logger10.log(`Waiting for guest connection...`);
+    await withSandboxTiming(
+      "guest_wait",
+      () => guest.waitForGuestConnection(3e4)
+    );
+    logger10.log(`Guest client ready`);
     if (context.storageManifest) {
       await withSandboxTiming(
         "storage_download",
@@ -10098,8 +10153,6 @@ async function executeJob(context, config, options = {}) {
         )
       );
     }
-    const envVars = buildEnvironmentVariables(context, config.server.url);
-    const envJson = JSON.stringify(envVars);
     logger10.log(
       `Writing env JSON (${envJson.length} bytes) to ${ENV_JSON_PATH}`
     );
@@ -10196,6 +10249,15 @@ async function executeJob(context, config, options = {}) {
       }
     }
     if (vm) {
+      if (vsockClient) {
+        const acked = await vsockClient.shutdown(2e3);
+        if (acked) {
+          logger10.log(`Guest acknowledged shutdown`);
+        } else {
+          logger10.log(`Guest shutdown timeout, proceeding with SIGKILL`);
+        }
+        vsockClient.close();
+      }
       logger10.log(`Cleaning up VM ${vmId}...`);
       await withSandboxTiming("cleanup", () => vm.kill());
     }
@@ -10667,7 +10729,7 @@ function parseFirecrackerCmdline(cmdline) {
   if (sockIdx === -1 || !socketPath) return null;
   const match = socketPath.match(/vm0-([a-f0-9]+)\/firecracker\.sock$/);
   if (!match?.[1]) return null;
-  return { vmId: match[1], socketPath };
+  return { vmId: createVmId(match[1]), socketPath };
 }
 function parseMitmproxyCmdline(cmdline) {
   if (!cmdline.includes("mitmproxy") && !cmdline.includes("mitmdump")) {
@@ -10707,7 +10769,8 @@ function findFirecrackerProcesses() {
 }
 function findProcessByVmId(vmId) {
   const processes = findFirecrackerProcesses();
-  return processes.find((p) => p.vmId === vmId) || null;
+  const vmIdStr = vmIdValue(vmId);
+  return processes.find((p) => vmIdValue(p.vmId) === vmIdStr) || null;
 }
 function isProcessRunning3(pid) {
   try {
@@ -10842,8 +10905,7 @@ var doctorCommand = new Command2("doctor").description("Diagnose runner health,
       const allocations = getAllocations();
       if (status?.active_run_ids) {
         for (const runId of status.active_run_ids) {
-          const vmId = runId.split("-")[0];
-          if (!vmId) continue;
+          const vmId = createVmId(runId);
           statusVmIds.add(vmId);
           const proc = processes.find((p) => p.vmId === vmId);
           const ip = getIPForVm(vmId) ?? "not allocated";
@@ -11088,8 +11150,7 @@ var killCommand = new Command3("kill").description("Force terminate a run and cl
 );
 function resolveRunId(input, statusFilePath) {
   if (input.includes("-")) {
-    const vmId = input.split("-")[0];
-    return { vmId: vmId ?? input, runId: input };
+    return { vmId: createVmId(input), runId: input };
   }
   if (existsSync5(statusFilePath)) {
     try {
@@ -11100,12 +11161,12 @@ function resolveRunId(input, statusFilePath) {
         (id) => id.startsWith(input)
       );
       if (match) {
-        return { vmId: input, runId: match };
+        return { vmId: createVmId(match), runId: match };
       }
     } catch {
     }
   }
-  return { vmId: input, runId: null };
+  return { vmId: createVmId(input), runId: null };
 }
 async function confirm(message) {
   const rl = readline2.createInterface({
@@ -11232,7 +11293,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.9.4" : "0.1.0";
+var version = true ? "3.10.1" : "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.9.4",
+  "version": "3.10.1",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",