@vercel/go 3.4.1 → 3.4.2

package/dist/index.js

@@ -17201,11 +17201,13 @@ async function buildStandaloneServer({
     throw err;
   }
   const bootstrapSrc = (0, import_path6.join)(__dirname, "../vc-init.go");
+  const utilsSrc = (0, import_path6.join)(__dirname, "../vc-utils.go");
   (0, import_build_utils3.debug)(`Building bootstrap wrapper: ${bootstrapSrc} -> ${bootstrapPath}`);
   try {
     const bootstrapBuildDir = await (0, import_build_utils3.getWriteableDirectory)();
     const bootstrapGoFile = (0, import_path6.join)(bootstrapBuildDir, "main.go");
     await (0, import_fs_extra3.copy)(bootstrapSrc, bootstrapGoFile);
+    await (0, import_fs_extra3.copy)(utilsSrc, (0, import_path6.join)(bootstrapBuildDir, "vc-utils.go"));
     const bootstrapGoMod = (0, import_path6.join)(bootstrapBuildDir, "go.mod");
     await (0, import_fs_extra3.writeFile)(bootstrapGoMod, "module vc-init\n\ngo 1.21\n");
     const bootstrapGo = await createGo({
@@ -17256,12 +17258,17 @@ async function startStandaloneDevServer(opts, resolvedEntrypoint) {
     PORT: String(port)
   });
   const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
+  const devWrapper = (0, import_path6.join)(__dirname, "../vc-init-dev.go");
+  const devUtils = (0, import_path6.join)(__dirname, "../vc-utils.go");
   (0, import_build_utils3.debug)(
-    `Starting standalone Go dev server: go run ${runTarget} (port ${port})`
+    `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
   );
-  const child = (0, import_child_process.spawn)("go", ["run", runTarget], {
+  const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
     cwd: workPath,
-    env,
+    env: {
+      ...env,
+      __VC_GO_DEV_RUN_TARGET: runTarget
+    },
     stdio: ["ignore", "pipe", "pipe"]
   });
   child.stdout?.on("data", (data) => {
@@ -17280,7 +17287,25 @@ async function startStandaloneDevServer(opts, resolvedEntrypoint) {
       process.stderr.write(chunk.toString());
     }
   });
-  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, 2e3);
+    const onExit = (code2, signal) => {
+      cleanup();
+      reject(
+        new Error(
+          `Standalone Go dev server exited before startup completed (code: ${code2}, signal: ${signal})`
+        )
+      );
+    };
+    const cleanup = () => {
+      clearTimeout(timeout);
+      child.removeListener("exit", onExit);
+    };
+    child.once("exit", onExit);
+  });
   return {
     port,
     pid: child.pid

package/package.json

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

package/vc-init-dev.go

@@ -0,0 +1,147 @@
+//go:build vcdev
+// +build vcdev
+
+// vc-init-dev.go - Dev wrapper for standalone Go servers on Vercel
+//
+// This wrapper is used by `vercel dev` for standalone Go mode. It:
+// 1. Starts the user's server (`go run <target>`) on an internal port
+// 2. Proxies requests from the external dev port to the internal server
+// 3. Optionally strips generated services route prefixes before forwarding
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+func mustEnv(name string) string {
+	value := strings.TrimSpace(os.Getenv(name))
+	if value == "" {
+		fmt.Fprintf(os.Stderr, "%s is not set\n", name)
+		os.Exit(1)
+	}
+	return value
+}
+
+func withEnvOverride(env []string, key, value string) []string {
+	prefix := key + "="
+	filtered := make([]string, 0, len(env)+1)
+	for _, item := range env {
+		if !strings.HasPrefix(item, prefix) {
+			filtered = append(filtered, item)
+		}
+	}
+	filtered = append(filtered, prefix+value)
+	return filtered
+}
+
+func main() {
+	listenPortRaw := mustEnv("PORT")
+	listenPort, err := strconv.Atoi(listenPortRaw)
+	if err != nil || listenPort <= 0 {
+		fmt.Fprintf(os.Stderr, "Invalid PORT value: %q\n", listenPortRaw)
+		os.Exit(1)
+	}
+
+	runTarget := mustEnv("__VC_GO_DEV_RUN_TARGET")
+	serviceRoutePrefix := resolveServiceRoutePrefix()
+
+	userPort, err := findFreePort()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to find free port: %v\n", err)
+		os.Exit(1)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, "go", "run", runTarget)
+	cmd.Env = withEnvOverride(os.Environ(), "PORT", strconv.Itoa(userPort))
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Start(); err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to start Go dev server: %v\n", err)
+		os.Exit(1)
+	}
+
+	if err := waitForServer(userPort, 30*time.Second); err != nil {
+		fmt.Fprintf(os.Stderr, "Go dev server failed to start: %v\n", err)
+		_ = cmd.Process.Kill()
+		os.Exit(1)
+	}
+
+	targetURL, _ := url.Parse(fmt.Sprintf("http://127.0.0.1:%d", userPort))
+	proxy := httputil.NewSingleHostReverseProxy(targetURL)
+	originalDirector := proxy.Director
+	proxy.Director = func(req *http.Request) {
+		originalDirector(req)
+		if host := req.Header.Get("X-Forwarded-Host"); host != "" {
+			req.Host = host
+		}
+	}
+
+	server := &http.Server{
+		Addr: fmt.Sprintf("127.0.0.1:%d", listenPort),
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/_vercel/ping" {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("OK"))
+				return
+			}
+
+			if r.URL != nil {
+				originalPath := r.URL.Path
+				r.URL.Path = stripServiceRoutePrefix(r.URL.Path, serviceRoutePrefix)
+				if r.URL.Path != originalPath {
+					r.URL.RawPath = ""
+				}
+			}
+
+			proxy.ServeHTTP(w, r)
+		}),
+	}
+
+	var closeOnce sync.Once
+	stop := func() {
+		closeOnce.Do(func() {
+			cancel()
+			_ = server.Close()
+			if cmd.Process != nil {
+				_ = cmd.Process.Kill()
+			}
+		})
+	}
+
+	go func() {
+		_ = cmd.Wait()
+		stop()
+	}()
+
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigCh
+		stop()
+	}()
+
+	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		fmt.Fprintf(os.Stderr, "Dev proxy server error: %v\n", err)
+		stop()
+		os.Exit(1)
+	}
+
+	stop()
+}

package/vc-init.go

@@ -94,34 +94,9 @@ func connectIPC() error {
 	return nil
 }
 
-func findFreePort() (int, error) {
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		return 0, err
-	}
-	port := listener.Addr().(*net.TCPAddr).Port
-	listener.Close()
-	return port, nil
-}
-
-func waitForServer(port int, timeout time.Duration) error {
-	deadline := time.Now().Add(timeout)
-	url := fmt.Sprintf("http://127.0.0.1:%d/", port)
-
-	for time.Now().Before(deadline) {
-		resp, err := http.Get(url)
-		if err == nil {
-			resp.Body.Close()
-			return nil
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-
-	return fmt.Errorf("server did not start within %v", timeout)
-}
-
 func main() {
 	startTime = time.Now()
+	serviceRoutePrefix := resolveServiceRoutePrefix()
 
 	// Connect to IPC socket
 	if err := connectIPC(); err != nil {
@@ -202,6 +177,15 @@ func main() {
 				}
 			}
 
+			if r.URL != nil {
+				originalPath := r.URL.Path
+				r.URL.Path = stripServiceRoutePrefix(r.URL.Path, serviceRoutePrefix)
+				if r.URL.Path != originalPath {
+					// Keep URL path encoding fields consistent after rewrite.
+					r.URL.RawPath = ""
+				}
+			}
+
 			// Forward request to user's server
 			proxy.ServeHTTP(w, r)
 
@@ -251,9 +235,3 @@ func main() {
 	// Clean up
 	cmd.Process.Kill()
 }
-
-// Ensure we close IPC connection on exit
-func init() {
-	// Note: Using a deferred cleanup in main() is preferred,
-	// but this provides a fallback
-}

package/vc-utils.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+func findFreePort() (int, error) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return 0, err
+	}
+	port := listener.Addr().(*net.TCPAddr).Port
+	listener.Close()
+	return port, nil
+}
+
+func waitForServer(port int, timeout time.Duration) error {
+	deadline := time.Now().Add(timeout)
+	url := fmt.Sprintf("http://127.0.0.1:%d/", port)
+
+	for time.Now().Before(deadline) {
+		resp, err := http.Get(url)
+		if err == nil {
+			resp.Body.Close()
+			return nil
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	return fmt.Errorf("server did not start within %v", timeout)
+}
+
+func normalizeServiceRoutePrefix(rawPrefix string) string {
+	if rawPrefix == "" {
+		return ""
+	}
+
+	prefix := strings.TrimSpace(rawPrefix)
+	if prefix == "" {
+		return ""
+	}
+
+	if !strings.HasPrefix(prefix, "/") {
+		prefix = "/" + prefix
+	}
+
+	if prefix != "/" {
+		prefix = strings.TrimRight(prefix, "/")
+		if prefix == "" {
+			prefix = "/"
+		}
+	}
+
+	if prefix == "/" {
+		return ""
+	}
+
+	return prefix
+}
+
+func serviceRoutePrefixStripEnabled() bool {
+	raw := strings.TrimSpace(os.Getenv("VERCEL_SERVICE_ROUTE_PREFIX_STRIP"))
+	if raw == "" {
+		return false
+	}
+
+	normalized := strings.ToLower(raw)
+	return normalized == "1" || normalized == "true"
+}
+
+func resolveServiceRoutePrefix() string {
+	if !serviceRoutePrefixStripEnabled() {
+		return ""
+	}
+
+	return normalizeServiceRoutePrefix(os.Getenv("VERCEL_SERVICE_ROUTE_PREFIX"))
+}
+
+func stripServiceRoutePrefix(pathValue string, prefix string) string {
+	if pathValue == "*" {
+		return pathValue
+	}
+
+	normalizedPath := pathValue
+	if normalizedPath == "" {
+		normalizedPath = "/"
+	} else if !strings.HasPrefix(normalizedPath, "/") {
+		normalizedPath = "/" + normalizedPath
+	}
+
+	if prefix == "" {
+		return normalizedPath
+	}
+
+	if normalizedPath == prefix {
+		return "/"
+	}
+
+	prefixWithSlash := prefix + "/"
+	if strings.HasPrefix(normalizedPath, prefixWithSlash) {
+		stripped := normalizedPath[len(prefix):]
+		if stripped == "" {
+			return "/"
+		}
+		return stripped
+	}
+
+	return normalizedPath
+}