@vercel/go 3.4.5 → 3.4.7

package/dist/index.js

@@ -14171,6 +14171,32 @@ var goGlobalCachePath = (0, import_path4.join)(
   "golang"
 );
 var OUT_EXTENSION = process.platform === "win32" ? ".exe" : "";
+function getGoCommandOutput(error) {
+  const stderr = error.stderr?.trim();
+  const stdout = error.stdout?.trim();
+  const all = error.all?.trim();
+  if (stderr && stdout && stdout !== stderr) {
+    return `stderr:
+${stderr}
+
+stdout:
+${stdout}`;
+  }
+  return stderr || stdout || all;
+}
+function enrichGoCommandError(error) {
+  if (!(error instanceof Error)) {
+    return error;
+  }
+  const output = getGoCommandOutput(error);
+  if (!output || error.message.includes(output)) {
+    return error;
+  }
+  error.message = `${error.message}
+
+${output}`;
+  return error;
+}
 async function getAnalyzedEntrypoint({
   entrypoint,
   modulePath,
@@ -14233,7 +14259,7 @@ var GoWrapper = class {
     this.env = env;
     this.opts = opts;
   }
-  execute(...args) {
+  async execute(...args) {
     const { opts, env } = this;
     (0, import_build_utils.debug)(
       `Exec: go ${args.map((a) => a.includes(" ") ? `"${a}"` : a).join(" ")}`
@@ -14241,7 +14267,21 @@ var GoWrapper = class {
     (0, import_build_utils.debug)(`  CWD=${opts.cwd}`);
     (0, import_build_utils.debug)(`  GOROOT=${(env || opts.env).GOROOT}`);
     (0, import_build_utils.debug)(`  GO_BUILD_FLAGS=${(env || opts.env).GO_BUILD_FLAGS}`);
-    return (0, import_execa.default)("go", args, { stdio: "inherit", ...opts, env });
+    const captureAndForwardOutput = opts.stdio === void 0 || opts.stdio === "inherit";
+    const subprocess = (0, import_execa.default)("go", args, {
+      ...opts,
+      env,
+      stdio: captureAndForwardOutput ? "pipe" : opts.stdio
+    });
+    if (captureAndForwardOutput) {
+      subprocess.stdout?.pipe(process.stdout);
+      subprocess.stderr?.pipe(process.stderr);
+    }
+    try {
+      return await subprocess;
+    } catch (error) {
+      throw enrichGoCommandError(error);
+    }
   }
   mod() {
     return this.execute("mod", "tidy");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "3.4.5",
+  "version": "3.4.7",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -32,7 +32,7 @@
     "typescript": "4.9.5",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel/build-utils": "13.8.0"
+    "@vercel/build-utils": "13.12.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/vc-init.go

@@ -14,6 +14,7 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -53,6 +54,16 @@ type RequestContext struct {
 	RequestID    uint64 `json:"requestId"`
 }
 
+type UnrecoverableErrorMessage struct {
+	Type    string                    `json:"type"`
+	Payload UnrecoverableErrorPayload `json:"payload"`
+}
+
+type UnrecoverableErrorPayload struct {
+	ExitCode int    `json:"exitCode"`
+	Message  string `json:"message"`
+}
+
 var (
 	ipcConn   net.Conn
 	ipcMutex  sync.Mutex
@@ -78,6 +89,19 @@ func sendIPCMessage(msg interface{}) error {
 	return err
 }
 
+// fatal reports a fatal init error via IPC and exits.
+func fatal(exitCode int, msg string) {
+	fmt.Fprintln(os.Stderr, msg)
+	sendIPCMessage(UnrecoverableErrorMessage{
+		Type: "unrecoverable-error",
+		Payload: UnrecoverableErrorPayload{
+			ExitCode: exitCode,
+			Message:  msg,
+		},
+	})
+	os.Exit(exitCode)
+}
+
 func connectIPC() error {
 	ipcPath := os.Getenv("VERCEL_IPC_PATH")
 	if ipcPath == "" {
@@ -106,15 +130,13 @@ func main() {
 	// Find a free port for the user's server
 	userPort, err := findFreePort()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to find free port: %v\n", err)
-		os.Exit(1)
+		fatal(1, fmt.Sprintf("Failed to find free port: %v", err))
 	}
 
 	// Start the user's server binary
 	userBinary := "./user-server"
 	if _, err := os.Stat(userBinary); os.IsNotExist(err) {
-		fmt.Fprintf(os.Stderr, "User server binary not found: %s\n", userBinary)
-		os.Exit(1)
+		fatal(1, fmt.Sprintf("User server binary not found: %s", userBinary))
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -126,15 +148,30 @@ func main() {
 	cmd.Stderr = os.Stderr
 
 	if err := cmd.Start(); err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to start user server: %v\n", err)
-		os.Exit(1)
+		fatal(1, fmt.Sprintf("Failed to start user server: %v", err))
 	}
 
-	// Wait for user's server to be ready
-	if err := waitForServer(userPort, 30*time.Second); err != nil {
-		fmt.Fprintf(os.Stderr, "User server failed to start: %v\n", err)
-		cmd.Process.Kill()
-		os.Exit(1)
+	// Race server readiness against early child death.
+	childDone := make(chan error, 1)
+	go func() { childDone <- cmd.Wait() }()
+
+	serverReady := make(chan error, 1)
+	go func() { serverReady <- waitForServer(userPort, 30*time.Second) }()
+
+	select {
+	case waitErr := <-childDone:
+		// Child exited before the server became ready.
+		exitCode := 1
+		var exitErr *exec.ExitError
+		if errors.As(waitErr, &exitErr) {
+			exitCode = exitErr.ExitCode()
+		}
+		fatal(exitCode, "User server exited during startup")
+	case err := <-serverReady:
+		if err != nil {
+			cmd.Process.Kill()
+			fatal(1, fmt.Sprintf("User server failed to start: %v", err))
+		}
 	}
 
 	// Create reverse proxy to user's server

package/vc-utils.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"net"
-	"net/http"
 	"os"
 	"strings"
 	"time"
@@ -20,19 +19,46 @@ func findFreePort() (int, error) {
 }
 
 func waitForServer(port int, timeout time.Duration) error {
+	const (
+		dialTimeout  = 200 * time.Millisecond
+		pollInterval = 50 * time.Millisecond
+	)
+
+	addr := fmt.Sprintf("127.0.0.1:%d", port)
 	deadline := time.Now().Add(timeout)
-	url := fmt.Sprintf("http://127.0.0.1:%d/", port)
+	var lastErr error
 
 	for time.Now().Before(deadline) {
-		resp, err := http.Get(url)
+		remaining := time.Until(deadline)
+		if remaining <= 0 {
+			break
+		}
+
+		attemptTimeout := dialTimeout
+		if remaining < attemptTimeout {
+			attemptTimeout = remaining
+		}
+
+		conn, err := net.DialTimeout("tcp", addr, attemptTimeout)
 		if err == nil {
-			resp.Body.Close()
+			conn.Close()
 			return nil
 		}
-		time.Sleep(50 * time.Millisecond)
+
+		lastErr = err
+		time.Sleep(pollInterval)
+	}
+
+	if lastErr != nil {
+		return fmt.Errorf(
+			"server did not start listening on %s within %v: %w",
+			addr,
+			timeout,
+			lastErr,
+		)
 	}
 
-	return fmt.Errorf("server did not start within %v", timeout)
+	return fmt.Errorf("server did not start listening on %s within %v", addr, timeout)
 }
 
 func normalizeServiceRoutePrefix(rawPrefix string) string {