@vercel/rust 1.3.0 → 1.4.1

package/dist/index.js

@@ -158,6 +158,7 @@ async function gatherExtraFiles(globMatcher, workPath) {
 // src/lib/start-dev-server.ts
 var import_child_process = require("child_process");
 var import_events = require("events");
+var import_get_port = __toESM(require("get-port"));
 var import_build_utils5 = require("@vercel/build-utils");
 
 // src/lib/dev-build.ts
@@ -213,7 +214,7 @@ async function buildExecutableForDev(workPath, entrypoint) {
 
 // src/lib/dev-server.ts
 var import_build_utils4 = require("@vercel/build-utils");
-function createDevServerEnv(baseEnv, meta = {}) {
+function createDevServerEnv(baseEnv, meta = {}, port) {
   const devEnv = {
     // Base environment
     ...Object.fromEntries(
@@ -225,6 +226,9 @@ function createDevServerEnv(baseEnv, meta = {}) {
     // Runtime environment from meta
     ...meta.env || {}
   };
+  if (typeof port === "number" && Number.isInteger(port)) {
+    devEnv.VERCEL_DEV_PORT = String(port);
+  }
   Object.keys(devEnv).forEach((key) => {
     if (devEnv[key] === void 0) {
       delete devEnv[key];
@@ -235,49 +239,147 @@ function createDevServerEnv(baseEnv, meta = {}) {
 }
 
 // src/lib/start-dev-server.ts
+var SHUTDOWN_TIMEOUT = 35e3;
+var ADDR_IN_USE_RE = /address (already )?in use|AddrInUse|EADDRINUSE/i;
+var MAX_STDERR_CAPTURE = 8192;
+var RUNNING_DEV_SERVERS = /* @__PURE__ */ new Set();
+var cleanupHandlersInstalled = false;
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const onSignal = () => {
+    for (const child of RUNNING_DEV_SERVERS) {
+      try {
+        child.kill("SIGTERM");
+      } catch (err) {
+        (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server on signal: ${err}`);
+      }
+    }
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  process.on("SIGHUP", onSignal);
+  process.on("exit", () => {
+    for (const child of RUNNING_DEV_SERVERS) {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    RUNNING_DEV_SERVERS.clear();
+  });
+}
+function trackDevServer(child) {
+  installGlobalCleanupHandlers();
+  RUNNING_DEV_SERVERS.add(child);
+  const untrack = () => {
+    RUNNING_DEV_SERVERS.delete(child);
+  };
+  child.once("exit", untrack);
+  child.once("close", untrack);
+}
+var RustDevServerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RustDevServerError";
+  }
+};
+function terminate(child) {
+  return new Promise((resolve) => {
+    if (!child.pid || child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    let timer;
+    let settled = false;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve();
+    };
+    child.once("exit", done);
+    child.once("close", done);
+    try {
+      child.kill("SIGTERM");
+    } catch (err) {
+      (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server: ${err}`);
+      done();
+      return;
+    }
+    timer = setTimeout(() => {
+      (0, import_build_utils5.debug)(
+        `Rust dev server did not exit within ${SHUTDOWN_TIMEOUT}ms, sending SIGKILL`
+      );
+      try {
+        child.kill("SIGKILL");
+      } catch (err) {
+        (0, import_build_utils5.debug)(`Error sending SIGKILL to Rust dev server: ${err}`);
+      }
+    }, SHUTDOWN_TIMEOUT);
+    timer.unref?.();
+  });
+}
 var startDevServer = async (opts) => {
-  const { entrypoint, workPath, meta = {} } = opts;
+  const { entrypoint, workPath, meta = {}, onStdout, onStderr } = opts;
   try {
     await installRustToolchain();
     const executablePath = await buildExecutableForDev(workPath, entrypoint);
-    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath}`);
-    const devEnv = createDevServerEnv(process.env, meta);
+    const requestedPort = typeof meta.port === "number" ? meta.port : meta.env?.VERCEL_DEV_PORT ? Number(meta.env.VERCEL_DEV_PORT) : void 0;
+    const port = typeof requestedPort === "number" && Number.isInteger(requestedPort) ? requestedPort : await (0, import_get_port.default)();
+    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath} (port=${port})`);
+    const devEnv = createDevServerEnv(process.env, meta, port);
     const child = (0, import_child_process.spawn)(executablePath, [], {
       cwd: workPath,
       env: devEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     if (!child.pid) {
-      throw new Error("Failed to start dev server process");
+      throw new Error("Failed to start Rust dev server process");
     }
-    (0, import_build_utils5.debug)(`Dev server process started with PID: ${child.pid}`);
+    trackDevServer(child);
+    (0, import_build_utils5.debug)(`Rust dev server process started with PID: ${child.pid}`);
     let buffer = "";
     let portEmitted = false;
+    let stderrTail = "";
     child.stdout?.on("data", (data) => {
-      const output = data.toString();
-      buffer += output;
-      if (!portEmitted && buffer.includes("Dev server listening:")) {
-        const portMatch = buffer.match(/Dev server listening: (\d+)/);
-        if (portMatch) {
-          const port = parseInt(portMatch[1], 10);
-          (0, import_build_utils5.debug)(
-            `Rust dev server detected port ${port}, emitting message event`
-          );
-          child.emit("message", { port }, null);
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      buffer += chunk.toString();
+      if (!portEmitted) {
+        const match = buffer.match(/Dev server listening:\s*(\d+)/);
+        if (match) {
           portEmitted = true;
+          const reportedPort = parseInt(match[1], 10);
+          (0, import_build_utils5.debug)(`Rust dev server reported ready on port ${reportedPort}`);
+          child.emit("message", { port: reportedPort }, null);
+          buffer = "";
         }
-        buffer = "";
       }
-      console.log(output);
+      if (onStdout) {
+        onStdout(chunk);
+      } else {
+        process.stdout.write(chunk.toString());
+      }
     });
     child.stderr?.on("data", (data) => {
-      console.error(data.toString());
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      stderrTail = (stderrTail + chunk.toString()).slice(-MAX_STDERR_CAPTURE);
+      if (onStderr) {
+        onStderr(chunk);
+      } else {
+        process.stderr.write(chunk.toString());
+      }
     });
     child.on("error", (err) => {
-      (0, import_build_utils5.debug)(`Dev server error: ${err}`);
+      (0, import_build_utils5.debug)(`Rust dev server error: ${err}`);
     });
-    child.on("exit", (code, signal) => {
-      (0, import_build_utils5.debug)(`Dev server exited with code ${code}, signal ${signal}`);
+    child.on("exit", (code, signal2) => {
+      (0, import_build_utils5.debug)(`Rust dev server exited with code ${code}, signal ${signal2}`);
     });
     const onMessage = (0, import_events.once)(child, "message");
     const onExit = (0, import_events.once)(child, "close");
@@ -287,31 +389,41 @@ var startDevServer = async (opts) => {
         return { state: "message", value: messageData };
       }),
       onExit.then((args) => {
-        const [code, signal] = args;
-        return { state: "exit", value: [code, signal] };
+        const [code, signal2] = args;
+        return { state: "exit", value: [code, signal2] };
       })
     ]);
     if (result.state === "message") {
-      const { port } = result.value;
-      (0, import_build_utils5.debug)(`Rust dev server ready on port ${port}`);
+      const readyPort = typeof result.value?.port === "number" ? result.value.port : port;
+      (0, import_build_utils5.debug)(`Rust dev server ready on port ${readyPort} (pid ${child.pid})`);
       if (!child.pid) {
         throw new Error("Child process has no PID");
       }
-      const shutdown = async () => {
-        try {
-          process.kill(child.pid, "SIGTERM");
-        } catch (err) {
-          (0, import_build_utils5.debug)(`Error terminating Rust dev server: ${err}`);
-        }
+      return {
+        port: readyPort,
+        pid: child.pid,
+        // Wait for exit so the port is released before `vercel dev` continues.
+        shutdown: () => terminate(child)
       };
-      return { port, pid: child.pid, shutdown };
-    } else {
-      const [exitCode, signal] = result.value;
-      const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
-      throw new Error(`Rust dev server failed with ${reason}`);
     }
+    const [exitCode, signal] = result.value;
+    const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
+    const stderr = stderrTail.trim();
+    if (ADDR_IN_USE_RE.test(stderr)) {
+      throw new RustDevServerError(
+        `Rust dev server failed to bind port ${port} ("address already in use"). A previous dev server instance may not have shut down yet. Please retry, or ensure no other process is using that port.`
+      );
+    }
+    (0, import_build_utils5.debug)(
+      `Rust dev server exited before becoming ready (${reason}). Falling back to build-and-invoke mode.` + (stderr ? ` stderr:
+${stderr}` : "")
+    );
+    return null;
   } catch (error) {
-    (0, import_build_utils5.debug)(`Failed to start dev server: ${error}`);
+    (0, import_build_utils5.debug)(`Failed to start Rust dev server: ${error}`);
+    if (error instanceof RustDevServerError) {
+      throw error;
+    }
     return null;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/rust",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/rust",
@@ -14,7 +14,8 @@
   ],
   "dependencies": {
     "smol-toml": "1.5.2",
-    "execa": "5"
+    "execa": "5",
+    "get-port": "5.1.1"
   },
   "devDependencies": {
     "@types/ms": "^0.7.31",
@@ -26,8 +27,8 @@
     "prettier": "^2.8.4",
     "rimraf": "^4.1.1",
     "vitest": "2.0.3",
-    "@vercel/build-utils": "13.26.2",
-    "@vercel/routing-utils": "6.2.0"
+    "@vercel/build-utils": "14.0.1",
+    "@vercel/routing-utils": "6.4.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",