@vm0/runner 3.0.1 → 3.0.2

package/index.js

@@ -1226,7 +1226,6 @@ import * as net from "net";
 import * as fs4 from "fs";
 import * as crypto from "crypto";
 var VSOCK_PORT = 1e3;
-var CONNECT_TIMEOUT_MS = 5e3;
 var HEADER_SIZE = 4;
 var MAX_MESSAGE_SIZE = 1024 * 1024;
 var DEFAULT_EXEC_TIMEOUT_MS = 3e5;
@@ -1261,90 +1260,6 @@ var VsockClient = class {
   constructor(vsockPath) {
     this.vsockPath = vsockPath;
   }
-  /**
-   * Connect to the guest agent via vsock
-   */
-  async connect() {
-    if (this.connected && this.socket) {
-      return;
-    }
-    return new Promise((resolve, reject) => {
-      if (!fs4.existsSync(this.vsockPath)) {
-        reject(new Error(`Vsock socket not found: ${this.vsockPath}`));
-        return;
-      }
-      const socket = net.createConnection(this.vsockPath);
-      const decoder = new Decoder();
-      let fcConnected = false;
-      let gotReady = false;
-      let pingId = null;
-      let connectionEstablished = false;
-      const timeout = setTimeout(() => {
-        socket.destroy();
-        reject(new Error("Vsock connection timeout"));
-      }, CONNECT_TIMEOUT_MS);
-      socket.on("connect", () => {
-        socket.write(`CONNECT ${VSOCK_PORT}
-`);
-      });
-      socket.on("data", (data) => {
-        if (!fcConnected) {
-          const str = data.toString();
-          if (str.startsWith("OK ")) {
-            fcConnected = true;
-          } else {
-            clearTimeout(timeout);
-            socket.destroy();
-            reject(new Error(`Firecracker connect failed: ${str.trim()}`));
-          }
-          return;
-        }
-        try {
-          for (const msg of decoder.decode(data)) {
-            if (!connectionEstablished) {
-              if (!gotReady && msg.type === "ready") {
-                gotReady = true;
-                pingId = crypto.randomUUID();
-                const ping = { type: "ping", id: pingId, payload: {} };
-                socket.write(encode(ping));
-              } else if (msg.type === "pong" && msg.id === pingId) {
-                clearTimeout(timeout);
-                this.socket = socket;
-                this.connected = true;
-                connectionEstablished = true;
-                resolve();
-              }
-            } else {
-              this.handleMessage(msg);
-            }
-          }
-        } catch (e) {
-          clearTimeout(timeout);
-          socket.destroy();
-          reject(new Error(`Failed to parse message: ${e}`));
-        }
-      });
-      socket.on("error", (err) => {
-        clearTimeout(timeout);
-        this.connected = false;
-        this.socket = null;
-        reject(new Error(`Vsock error: ${err.message}`));
-      });
-      socket.on("close", () => {
-        clearTimeout(timeout);
-        this.connected = false;
-        this.socket = null;
-        if (!gotReady) {
-          reject(new Error("Vsock closed before ready"));
-        }
-        for (const [id, req] of this.pendingRequests) {
-          clearTimeout(req.timeout);
-          req.reject(new Error("Connection closed"));
-          this.pendingRequests.delete(id);
-        }
-      });
-    });
-  }
   /**
    * Handle incoming message and route to pending request
    */
@@ -1360,9 +1275,8 @@ var VsockClient = class {
    * Send a request and wait for response
    */
   async request(type, payload, timeoutMs) {
-    await this.connect();
-    if (!this.socket) {
-      throw new Error("Not connected");
+    if (!this.connected || !this.socket) {
+      throw new Error("Not connected - call waitForGuestConnection() first");
     }
     const id = crypto.randomUUID();
     const msg = { type, id, payload };
@@ -1486,24 +1400,113 @@ var VsockClient = class {
     }
   }
   /**
-   * Wait for vsock to become available
+   * Wait for guest to connect (Guest-initiated mode)
+   *
+   * Instead of polling, this listens on "{vsockPath}_{port}" and waits
+   * for the guest to actively connect. This provides zero-latency
+   * notification when the guest is ready.
+   *
+   * Flow:
+   * 1. Host creates UDS server at "{vsockPath}_{port}"
+   * 2. Guest boots and vsock-agent connects to CID=2, port
+   * 3. Firecracker forwards connection to Host's UDS
+   * 4. Host accepts, receives "ready", sends ping/pong
    */
-  async waitUntilReachable(timeoutMs = 12e4, intervalMs = 2e3) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-      if (await this.isReachable()) {
-        return;
-      }
-      await new Promise((resolve) => {
-        const remaining = timeoutMs - (Date.now() - start);
-        if (remaining > 0) {
-          setTimeout(resolve, Math.min(intervalMs, remaining));
-        } else {
-          resolve();
+  async waitForGuestConnection(timeoutMs = 3e4) {
+    if (this.connected && this.socket) {
+      return;
+    }
+    const listenerPath = `${this.vsockPath}_${VSOCK_PORT}`;
+    if (fs4.existsSync(listenerPath)) {
+      fs4.unlinkSync(listenerPath);
+    }
+    return new Promise((resolve, reject) => {
+      const server = net.createServer();
+      const decoder = new Decoder();
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          server.close();
+          if (fs4.existsSync(listenerPath)) {
+            fs4.unlinkSync(listenerPath);
+          }
+          reject(new Error(`Guest connection timeout after ${timeoutMs}ms`));
         }
+      }, timeoutMs);
+      const cleanup = (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timeout);
+          server.close();
+          if (fs4.existsSync(listenerPath)) {
+            fs4.unlinkSync(listenerPath);
+          }
+          reject(err);
+        }
+      };
+      server.on("error", (err) => {
+        cleanup(new Error(`Server error: ${err.message}`));
       });
-    }
-    throw new Error(`Vsock not reachable after ${timeoutMs}ms`);
+      server.on("connection", (socket) => {
+        server.close();
+        let State;
+        ((State2) => {
+          State2[State2["WaitingForReady"] = 0] = "WaitingForReady";
+          State2[State2["WaitingForPong"] = 1] = "WaitingForPong";
+          State2[State2["Connected"] = 2] = "Connected";
+        })(State || (State = {}));
+        let state = 0 /* WaitingForReady */;
+        let pingId = null;
+        socket.on("data", (data) => {
+          try {
+            for (const msg of decoder.decode(data)) {
+              if (state === 0 /* WaitingForReady */ && msg.type === "ready") {
+                state = 1 /* WaitingForPong */;
+                pingId = crypto.randomUUID();
+                socket.write(encode({ type: "ping", id: pingId, payload: {} }));
+              } else if (state === 1 /* WaitingForPong */ && msg.type === "pong" && msg.id === pingId) {
+                if (settled) {
+                  socket.destroy();
+                  return;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                if (fs4.existsSync(listenerPath)) {
+                  fs4.unlinkSync(listenerPath);
+                }
+                state = 2 /* Connected */;
+                this.socket = socket;
+                this.connected = true;
+                resolve();
+              } else if (state === 2 /* Connected */) {
+                this.handleMessage(msg);
+              }
+            }
+          } catch (e) {
+            cleanup(new Error(`Failed to parse message: ${e}`));
+          }
+        });
+        socket.on("error", (err) => {
+          cleanup(new Error(`Socket error: ${err.message}`));
+        });
+        socket.on("close", () => {
+          if (!settled) {
+            cleanup(new Error("Guest disconnected before ready"));
+          }
+          this.connected = false;
+          this.socket = null;
+          const pending = Array.from(this.pendingRequests.values());
+          this.pendingRequests.clear();
+          for (const req of pending) {
+            clearTimeout(req.timeout);
+            req.reject(new Error("Connection closed"));
+          }
+        });
+      });
+      server.listen(listenerPath, () => {
+      });
+    });
   }
   /**
    * Create a directory on the remote VM
@@ -1533,10 +1536,11 @@ var VsockClient = class {
       this.socket = null;
     }
     this.connected = false;
-    for (const [id, req] of this.pendingRequests) {
+    const pending = Array.from(this.pendingRequests.values());
+    this.pendingRequests.clear();
+    for (const req of pending) {
       clearTimeout(req.timeout);
       req.reject(new Error("Connection closed"));
-      this.pendingRequests.delete(id);
     }
   }
 };
@@ -5542,9 +5546,6 @@ var appStringSchema = z5.string().superRefine((val, ctx) => {
     });
   }
 });
-var nonEmptyStringArraySchema = z5.array(
-  z5.string().min(1, "Array entries cannot be empty strings")
-);
 var agentDefinitionSchema = z5.object({
   description: z5.string().optional(),
   /**
@@ -5589,17 +5590,7 @@ var agentDefinitionSchema = z5.object({
    * Requires experimental_runner to be configured.
    * When enabled, filters outbound traffic by domain/IP rules.
    */
-  experimental_firewall: experimentalFirewallSchema.optional(),
-  /**
-   * Array of secret names to inject from the scope's secret store.
-   * Each entry must be a non-empty string.
-   */
-  experimental_secrets: nonEmptyStringArraySchema.optional(),
-  /**
-   * Array of variable names to inject from the scope's variable store.
-   * Each entry must be a non-empty string.
-   */
-  experimental_vars: nonEmptyStringArraySchema.optional()
+  experimental_firewall: experimentalFirewallSchema.optional()
 });
 var agentComposeContentSchema = z5.object({
   version: z5.string().min(1, "Version is required"),
@@ -9213,10 +9204,10 @@ async function executeJob(context, config, options = {}) {
     const vsockPath = vm.getVsockPath();
     const guest = new VsockClient(vsockPath);
     log(`[Executor] Using vsock for guest communication: ${vsockPath}`);
-    log(`[Executor] Verifying vsock connectivity...`);
+    log(`[Executor] Waiting for guest connection...`);
     await withSandboxTiming(
       "guest_wait",
-      () => guest.waitUntilReachable(3e4, 1e3)
+      () => guest.waitForGuestConnection(3e4)
     );
     log(`[Executor] Guest client ready`);
     const firewallConfig = context.experimentalFirewall;
@@ -10240,7 +10231,7 @@ var benchmarkCommand = new Command4("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "3.0.1" : "0.1.0";
+var version = true ? "3.0.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.0.1",
+  "version": "3.0.2",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",