@vercel/go 3.9.0 → 3.9.2

package/dev-server.go

@@ -12,8 +12,11 @@ func main() {
 	// create a new handler
 	handler := http.HandlerFunc(__HANDLER_FUNC_NAME)
 
-	// https://stackoverflow.com/a/43425461/376773
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	addr := "127.0.0.1:0"
+	if devPort := os.Getenv("VERCEL_DEV_PORT"); devPort != "" {
+		addr = "127.0.0.1:" + devPort
+	}
+	listener, err := net.Listen("tcp", addr)
 	if err != nil {
 		panic(err)
 	}

package/dist/index.js

@@ -11025,7 +11025,7 @@ __export(src_exports, {
   diagnostics: () => diagnostics,
   getNewHandlerFunctionName: () => getNewHandlerFunctionName,
   prepareCache: () => prepareCache,
-  shouldServe: () => import_build_utils5.shouldServe,
+  shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
@@ -14804,6 +14804,7 @@ var detectEntrypoint = async ({ workPath }) => {
 
 // src/standalone-server.ts
 var import_child_process = require("child_process");
+var import_net = require("net");
 var import_path6 = require("path");
 var import_fs_extra3 = __toESM(require_lib2());
 var import_build_utils4 = require("@vercel/build-utils");
@@ -15008,69 +15009,194 @@ async function buildStandaloneServer({
   });
   return { output: lambda };
 }
-async function startStandaloneDevServer(opts, resolvedEntrypoint) {
-  const { workPath, meta = {} } = opts;
-  const port = Math.floor(Math.random() * (65535 - 49152) + 49152);
-  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
-    PORT: String(port)
-  });
-  const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
-  const devWrapper = (0, import_path6.join)(__dirname, "../bootstrap/vc-init-dev.go");
-  const devUtils = (0, import_path6.join)(__dirname, "../bootstrap/utils.go");
-  (0, import_build_utils4.debug)(
-    `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
-  );
-  const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
-    cwd: workPath,
-    env: {
-      ...env,
-      __VC_GO_DEV_RUN_TARGET: runTarget
-    },
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  child.stdout?.on("data", (data) => {
-    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    if (opts.onStdout) {
-      opts.onStdout(chunk);
+var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
+var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
+var PENDING_STARTS = /* @__PURE__ */ new Map();
+var cleanupHandlersInstalled = false;
+function killStandaloneDevServer(pid) {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, "SIGTERM");
     } else {
-      process.stdout.write(chunk.toString());
+      process.kill(-pid, "SIGTERM");
     }
-  });
-  child.stderr?.on("data", (data) => {
-    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    if (opts.onStderr) {
-      opts.onStderr(chunk);
-    } else {
-      process.stderr.write(chunk.toString());
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Error killing standalone Go dev server ${pid}: ${err}`);
+  }
+}
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const killAll = () => {
+    for (const [key, info] of PERSISTENT_SERVERS.entries()) {
+      killStandaloneDevServer(info.pid);
+      PERSISTENT_SERVERS.delete(key);
     }
+  };
+  process.on("SIGINT", () => {
+    killAll();
   });
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, 2e3);
-    const onExit = (code, signal) => {
-      cleanup();
-      reject(
-        new Error(
-          `Standalone Go dev server exited before startup completed (code: ${code}, signal: ${signal})`
-        )
-      );
-    };
-    const cleanup = () => {
-      clearTimeout(timeout);
-      child.removeListener("exit", onExit);
-    };
-    child.once("exit", onExit);
+  process.on("SIGTERM", () => {
+    killAll();
   });
-  return {
-    port,
-    pid: child.pid
+  process.on("exit", () => {
+    killAll();
+  });
+}
+function isPortReachable(port) {
+  return new Promise((resolve) => {
+    const socket = (0, import_net.createConnection)({ port, host: "127.0.0.1" });
+    const done = (result) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(1e3);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+  });
+}
+function sleep(ms2) {
+  return new Promise((resolve) => setTimeout(resolve, ms2));
+}
+async function waitForPort(port, child, timeout) {
+  let exited = null;
+  let spawnError = null;
+  const onExit = (code, signal) => {
+    exited = { code, signal };
   };
+  const onError = (err) => {
+    spawnError = err;
+  };
+  child.once("exit", onExit);
+  child.once("error", onError);
+  try {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (spawnError) {
+        throw spawnError;
+      }
+      if (exited) {
+        const { code, signal } = exited;
+        throw new Error(
+          `Standalone Go dev server exited before startup completed (code: ${code}, signal: ${signal})`
+        );
+      }
+      if (await isPortReachable(port)) {
+        return;
+      }
+      await sleep(100);
+    }
+    throw new Error(
+      `Standalone Go dev server did not start within ${timeout}ms`
+    );
+  } finally {
+    child.removeListener("exit", onExit);
+    child.removeListener("error", onError);
+  }
+}
+async function startStandaloneDevServer(opts, resolvedEntrypoint) {
+  const { workPath, meta = {} } = opts;
+  const serverKey = `${workPath}::${resolvedEntrypoint}`;
+  const existing = PERSISTENT_SERVERS.get(serverKey);
+  if (existing) {
+    return {
+      port: existing.port,
+      pid: existing.pid,
+      shutdown: async () => {
+      }
+    };
+  }
+  const pending = PENDING_STARTS.get(serverKey);
+  if (pending) {
+    const { port, pid } = await pending;
+    return { port, pid, shutdown: async () => {
+    } };
+  }
+  const startPromise = (async () => {
+    const port = typeof meta.port === "number" ? meta.port : Math.floor(Math.random() * (65535 - 49152) + 49152);
+    const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
+      PORT: String(port)
+    });
+    const entrypointDir = (0, import_path6.dirname)((0, import_path6.join)(workPath, resolvedEntrypoint));
+    const { goModPath } = await findGoModPath(entrypointDir, workPath);
+    const modulePath = goModPath ? (0, import_path6.dirname)(goModPath) : workPath;
+    const go = await createGo({
+      modulePath,
+      opts: { cwd: workPath, env },
+      workPath
+    });
+    const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
+    const devWrapper = (0, import_path6.join)(__dirname, "../bootstrap/vc-init-dev.go");
+    const devUtils = (0, import_path6.join)(__dirname, "../bootstrap/utils.go");
+    (0, import_build_utils4.debug)(
+      `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
+    );
+    const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
+      cwd: workPath,
+      env: {
+        ...go.getEnv(),
+        __VC_GO_DEV_RUN_TARGET: runTarget
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    child.stdout?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStdout) {
+        opts.onStdout(chunk);
+      } else {
+        process.stdout.write(chunk.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStderr) {
+        opts.onStderr(chunk);
+      } else {
+        process.stderr.write(chunk.toString());
+      }
+    });
+    const pid = child.pid;
+    try {
+      await waitForPort(port, child, DEV_SERVER_STARTUP_TIMEOUT);
+    } catch (err) {
+      if (pid) {
+        killStandaloneDevServer(pid);
+      }
+      throw err;
+    }
+    if (!pid) {
+      throw new Error("Standalone Go dev server started without a PID");
+    }
+    PERSISTENT_SERVERS.set(serverKey, { port, pid, child });
+    child.once("exit", () => {
+      PERSISTENT_SERVERS.delete(serverKey);
+    });
+    installGlobalCleanupHandlers();
+    return { port, pid };
+  })();
+  PENDING_STARTS.set(serverKey, startPromise);
+  try {
+    const { port, pid } = await startPromise;
+    return { port, pid, shutdown: async () => {
+    } };
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
 }
 
 // src/index.ts
 var TMP = (0, import_os2.tmpdir)();
+var shouldServe = (opts) => {
+  const framework = opts.config.framework;
+  if (framework === "go" || framework === "services") {
+    return true;
+  }
+  return (0, import_build_utils5.shouldServe)(opts);
+};
 var MAIN_GO_FILENAME = "main__vc__go__.go";
 var HANDLER_FILENAME = `bootstrap${OUT_EXTENSION}`;
 async function initPrivateGit(credentials) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "3.9.0",
+  "version": "3.9.2",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -33,7 +33,7 @@
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
     "@vercel-internals/ipc-proxy": "1.0.0",
-    "@vercel/build-utils": "13.29.1"
+    "@vercel/build-utils": "13.31.1"
   },
   "scripts": {
     "build": "node build.mjs",