@vercel/python 6.0.0 → 6.0.1

package/dist/index.js

@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join5, delimiter, sep, posix } = require("path");
+    var { join: join6, delimiter, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join5(pathPart, cmd);
+      return prefix + join6(pathPart, cmd);
     };
     var which3 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2751,7 +2751,7 @@ module.exports = __toCommonJS(src_exports);
 var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path5 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
@@ -3066,7 +3066,7 @@ async function exportRequirementsFromPipfile({
 }
 
 // src/index.ts
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/version.ts
 var import_build_utils2 = require("@vercel/build-utils");
@@ -3199,12 +3199,13 @@ function isInstalled2({ pipPath, pythonPath }) {
 var import_child_process = require("child_process");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
 var import_fs2 = __toESM(require("fs"));
 var import_path2 = require("path");
 var import_build_utils3 = require("@vercel/build-utils");
+var import_build_utils4 = require("@vercel/build-utils");
 var FASTAPI_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
 var FASTAPI_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var FASTAPI_CONTENT_REGEX = /(from\s+fastapi\s+import\s+FastAPI|import\s+fastapi|FastAPI\s*\()/;
@@ -3287,6 +3288,43 @@ async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
     return null;
   }
 }
+async function getPyprojectEntrypoint(workPath) {
+  const pyprojectData = await (0, import_build_utils4.readConfigFile)((0, import_path2.join)(workPath, "pyproject.toml"));
+  if (!pyprojectData)
+    return null;
+  const scripts = pyprojectData.project?.scripts;
+  const appScript = scripts?.app;
+  if (typeof appScript !== "string")
+    return null;
+  const match = appScript.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
+  if (!match)
+    return null;
+  const modulePath = match[1];
+  const relPath = modulePath.replace(/\./g, "/");
+  try {
+    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
+    for (const candidate of candidates) {
+      if (fsFiles[candidate])
+        return candidate;
+    }
+    return null;
+  } catch {
+    (0, import_build_utils3.debug)("Failed to discover Python entrypoint from pyproject.toml");
+    return null;
+  }
+}
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
+  let entrypoint = null;
+  if (framework === "fastapi") {
+    entrypoint = await detectFastapiEntrypoint(workPath, configuredEntrypoint);
+  } else if (framework === "flask") {
+    entrypoint = await detectFlaskEntrypoint(workPath, configuredEntrypoint);
+  }
+  if (entrypoint)
+    return entrypoint;
+  return await getPyprojectEntrypoint(workPath);
+}
 
 // src/utils.ts
 var import_fs3 = __toESM(require("fs"));
@@ -3355,12 +3393,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils5.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils5.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -3368,7 +3406,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils4.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils5.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -3394,10 +3432,10 @@ function createDevAsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils4.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_build_utils5.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils4.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils5.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3410,10 +3448,10 @@ function createDevWsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils4.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_build_utils5.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils4.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils5.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3426,26 +3464,19 @@ var startDevServer = async (opts) => {
   if (!restoreWarnings)
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
-  let entry = null;
-  if (framework === "fastapi") {
-    const detectedFastapi = await detectFastapiEntrypoint(
-      workPath,
-      rawEntrypoint
-    );
-    if (!detectedFastapi) {
-      throw new Error(
-        `No FastAPI entrypoint found. Searched for: ${FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ")}`
-      );
-    }
-    entry = detectedFastapi;
-  } else {
-    const detectedFlask = await detectFlaskEntrypoint(workPath, rawEntrypoint);
-    if (!detectedFlask) {
-      throw new Error(
-        `No Flask entrypoint found. Searched for: ${FLASK_CANDIDATE_ENTRYPOINTS.join(", ")}`
-      );
-    }
-    entry = detectedFlask;
+  const entry = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    rawEntrypoint
+  );
+  if (!entry) {
+    const searched = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
+    throw new import_build_utils5.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searched} or add an 'app' script in pyproject.toml.`,
+      link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
+      action: "Learn More"
+    });
   }
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   const env = { ...process.env, ...meta.env || {} };
@@ -3490,7 +3521,7 @@ var startDevServer = async (opts) => {
       let pythonCmd = systemPython;
       const venv = isInVirtualEnv();
       if (venv) {
-        (0, import_build_utils4.debug)(`Running in virtualenv at ${venv}`);
+        (0, import_build_utils5.debug)(`Running in virtualenv at ${venv}`);
       } else {
         const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
           workPath,
@@ -3499,9 +3530,9 @@ var startDevServer = async (opts) => {
         );
         pythonCmd = venvPythonCmd;
         if (venvRoot) {
-          (0, import_build_utils4.debug)(`Using virtualenv at ${venvRoot}`);
+          (0, import_build_utils5.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
-          (0, import_build_utils4.debug)("No virtualenv found");
+          (0, import_build_utils5.debug)("No virtualenv found");
           try {
             const yellow = "\x1B[33m";
             const reset = "\x1B[0m";
@@ -3524,7 +3555,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils4.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils5.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3602,7 +3633,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils4.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils5.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3712,13 +3743,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils5.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils5.download)(files, workPath, meta);
+  (0, import_build_utils6.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
   if (meta.isDev) {
     const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
     const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
-    await (0, import_build_utils5.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils5.glob)("**", destCache);
+    await (0, import_build_utils6.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils6.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -3730,6 +3761,7 @@ var build = async ({
   meta = {},
   config
 }) => {
+  const framework = config?.framework;
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3745,33 +3777,25 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils5.glob)("**", workPath);
-  if (!fsFiles[entrypoint] && config?.framework === "fastapi") {
-    const detected = await detectFastapiEntrypoint(workPath, entrypoint);
-    if (detected) {
-      (0, import_build_utils5.debug)(
-        `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = detected;
-    } else {
-      const searchedList = FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils5.NowBuildError({
-        code: "FASTAPI_ENTRYPOINT_NOT_FOUND",
-        message: `No FastAPI entrypoint found. Searched for: ${searchedList}`
-      });
-    }
-  } else if (!fsFiles[entrypoint] && config?.framework === "flask") {
-    const detected = await detectFlaskEntrypoint(workPath, entrypoint);
+  let fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+  if ((framework === "fastapi" || framework === "flask") && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+    const detected = await detectPythonEntrypoint(
+      config.framework,
+      workPath,
+      entrypoint
+    );
     if (detected) {
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils6.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
-      const searchedList = FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils5.NowBuildError({
-        code: "FLASK_ENTRYPOINT_NOT_FOUND",
-        message: `No Flask entrypoint found. Searched for: ${searchedList}`
+      const searchedList = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
+      throw new import_build_utils6.NowBuildError({
+        code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
+        message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searchedList} or add an 'app' script in pyproject.toml.`,
+        link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
+        action: "Learn More"
       });
     }
   }
@@ -3796,20 +3820,20 @@ var build = async ({
   if (pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils7.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils5.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils6.debug)("Failed to parse pyproject.toml", err);
     }
     const VERSION_REGEX = /\b\d+\.\d+\b/;
     const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
     if (exact) {
       declaredPythonVersion = { version: exact, source: "pyproject.toml" };
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils6.debug)(
         `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
       );
     } else if (requiresPython) {
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils6.debug)(
         `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
       );
     }
@@ -3819,7 +3843,7 @@ var build = async ({
       const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -3827,14 +3851,14 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils5.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils6.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils5.glob)("**", workPath);
+  fsFiles = await (0, import_build_utils6.glob)("**", workPath);
   const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
   const vendorBaseDir = (0, import_path5.join)(
     workPath,
@@ -3879,7 +3903,7 @@ var build = async ({
         `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    (0, import_build_utils5.debug)("Failed to install uv", err);
+    (0, import_build_utils6.debug)("Failed to install uv", err);
   }
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
@@ -3893,7 +3917,7 @@ var build = async ({
   });
   let installedFromProjectFiles = false;
   if (uvLockDir) {
-    (0, import_build_utils5.debug)('Found "uv.lock"');
+    (0, import_build_utils6.debug)('Found "uv.lock"');
     if (pyprojectDir) {
       const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
         locked: true
@@ -3909,10 +3933,10 @@ var build = async ({
       });
       installedFromProjectFiles = true;
     } else {
-      (0, import_build_utils5.debug)('Skipping uv export because "pyproject.toml" was not found');
+      (0, import_build_utils6.debug)('Skipping uv export because "pyproject.toml" was not found');
     }
   } else if (pyprojectDir) {
-    (0, import_build_utils5.debug)('Found "pyproject.toml"');
+    (0, import_build_utils6.debug)('Found "pyproject.toml"');
     if (hasReqLocal || hasReqGlobal) {
       console.log(
         "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
@@ -3932,9 +3956,9 @@ var build = async ({
     });
     installedFromProjectFiles = true;
   } else if (pipfileLockDir || pipfileDir) {
-    (0, import_build_utils5.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
+    (0, import_build_utils6.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
     if (hasReqLocal || hasReqGlobal) {
-      (0, import_build_utils5.debug)('Skipping Pipfile export because "requirements.txt" exists');
+      (0, import_build_utils6.debug)('Skipping Pipfile export because "requirements.txt" exists');
     } else {
       const exportedReq = await exportRequirementsFromPipfile({
         pythonPath: pythonVersion.pythonPath,
@@ -3956,7 +3980,7 @@ var build = async ({
     }
   }
   if (!installedFromProjectFiles && fsFiles[requirementsTxt]) {
-    (0, import_build_utils5.debug)('Found local "requirements.txt"');
+    (0, import_build_utils6.debug)('Found local "requirements.txt"');
     const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -3968,7 +3992,7 @@ var build = async ({
       meta
     });
   } else if (!installedFromProjectFiles && fsFiles["requirements.txt"]) {
-    (0, import_build_utils5.debug)('Found global "requirements.txt"');
+    (0, import_build_utils6.debug)('Found global "requirements.txt"');
     const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -3982,12 +4006,12 @@ var build = async ({
   }
   const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils5.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils6.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils5.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils6.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
@@ -4000,6 +4024,8 @@ var build = async ({
     "**/.venv/**",
     "**/venv/**",
     "**/__pycache__/**",
+    "**/.mypy_cache/**",
+    "**/.ruff_cache/**",
     "**/public/**"
   ];
   const lambdaEnv = {};
@@ -4008,11 +4034,11 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils5.glob)("**", globOptions);
+  const files = await (0, import_build_utils6.glob)("**", globOptions);
   try {
     const cachedVendorAbs = (0, import_path5.join)(vendorBaseDir, resolveVendorDir());
     if (import_fs5.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils5.glob)("**", cachedVendorAbs, resolveVendorDir());
+      const vendorFiles = await (0, import_build_utils6.glob)("**", cachedVendorAbs, resolveVendorDir());
       for (const [p, f] of Object.entries(vendorFiles)) {
         files[p] = f;
       }
@@ -4022,12 +4048,12 @@ var build = async ({
     throw err;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils5.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils6.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils5.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils6.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils5.Lambda({
+  const output = new import_build_utils6.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -21,7 +21,7 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "12.2.3",
+    "@vercel/build-utils": "12.2.4",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",

package/vc_init.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import os
 import site
@@ -5,9 +6,19 @@ import importlib
 import base64
 import json
 import inspect
+import asyncio
+import http
+import time
 from importlib import util
-from http.server import BaseHTTPRequestHandler
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 import socket
+import functools
+import logging
+import builtins
+from typing import Callable, Literal, TextIO
+import contextvars
+import contextlib
+
 
 _here = os.path.dirname(__file__)
 _vendor_rel = '__VC_HANDLER_VENDOR_DIR'
@@ -30,6 +41,153 @@ if os.path.isdir(_vendor):
 
     importlib.invalidate_caches()
 
+
+def setup_logging(send_message: Callable[[dict], None], storage: contextvars.ContextVar[dict | None]):
+    # Override logging.Handler to send logs to the platform when a request context is available.
+    class VCLogHandler(logging.Handler):
+        def emit(self, record: logging.LogRecord):
+            try:
+                message = record.getMessage()
+            except Exception:
+                message = repr(getattr(record, "msg", ""))
+
+            if record.levelno >= logging.CRITICAL:
+                level = "fatal"
+            elif record.levelno >= logging.ERROR:
+                level = "error"
+            elif record.levelno >= logging.WARNING:
+                level = "warn"
+            elif record.levelno >= logging.INFO:
+                level = "info"
+            else:
+                level = "debug"
+
+            context = storage.get()
+            if context is not None:
+                send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": context['invocationId'],
+                            "requestId": context['requestId'],
+                        },
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "level": level,
+                    }
+                })
+            else:
+                # If IPC is not ready, enqueue the message to be sent later.
+                enqueue_or_send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {"invocationId": "0", "requestId": 0},
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "level": level,
+                    }
+                })
+
+    # Override sys.stdout and sys.stderr to map logs to the correct request
+    class StreamWrapper:
+        def __init__(self, stream: TextIO, stream_name: Literal["stdout", "stderr"]):
+            self.stream = stream
+            self.stream_name = stream_name
+
+        def write(self, message: str):
+            context = storage.get()
+            if context is not None:
+                send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": context['invocationId'],
+                            "requestId": context['requestId'],
+                        },
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "stream": self.stream_name,
+                    }
+                })
+            else:
+                enqueue_or_send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {"invocationId": "0", "requestId": 0},
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "stream": self.stream_name,
+                    }
+                })
+
+        def __getattr__(self, name):
+            return getattr(self.stream, name)
+
+    sys.stdout = StreamWrapper(sys.stdout, "stdout")
+    sys.stderr = StreamWrapper(sys.stderr, "stderr")
+
+    logging.basicConfig(level=logging.INFO, handlers=[VCLogHandler()], force=True)
+
+    # Ensure built-in print funnels through stdout wrapper so prints are
+    # attributed to the current request context.
+    def print_wrapper(func: Callable[..., None]) -> Callable[..., None]:
+        @functools.wraps(func)
+        def wrapper(*args, sep=' ', end='\n', file=None, flush=False):
+            if file is None:
+                file = sys.stdout
+            if file in (sys.stdout, sys.stderr):
+                file.write(sep.join(map(str, args)) + end)
+                if flush:
+                    file.flush()
+            else:
+                # User specified a different file, use original print behavior
+                func(*args, sep=sep, end=end, file=file, flush=flush)
+        return wrapper
+
+    builtins.print = print_wrapper(builtins.print)
+
+
+# If running in the platform (IPC present), logging must be setup before importing user code so that
+# logs happening outside the request context are emitted correctly.
+ipc_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+storage: contextvars.ContextVar[dict | None] = contextvars.ContextVar('storage', default=None)
+send_message = lambda m: None
+_original_stderr = sys.stderr
+
+
+# Buffer for pre-handshake logs (to avoid blocking IPC on startup)
+_ipc_ready = False
+_init_log_buf: list[dict] = []
+_INIT_LOG_BUF_MAX_BYTES = 1_000_000
+_init_log_buf_bytes = 0
+
+
+def enqueue_or_send_message(msg: dict):
+    global _init_log_buf_bytes
+    if _ipc_ready:
+        send_message(msg)
+        return
+
+    enc_len = len(json.dumps(msg))
+
+    if _init_log_buf_bytes + enc_len <= _INIT_LOG_BUF_MAX_BYTES:
+        _init_log_buf.append(msg)
+        _init_log_buf_bytes += enc_len
+    else:
+        # Fallback so message is not lost if buffer is full
+        with contextlib.suppress(Exception):
+            payload = msg.get("payload", {})
+            decoded = base64.b64decode(payload.get("message", "")).decode(errors="ignore")
+            _original_stderr.write(decoded + "\n")
+
+
+if 'VERCEL_IPC_PATH' in os.environ:
+    with contextlib.suppress(Exception):
+        ipc_sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+
+        def send_message(message: dict):
+            with contextlib.suppress(Exception):
+                ipc_sock.sendall((json.dumps(message) + '\0').encode())
+
+        setup_logging(send_message, storage)
+
+
 # Import relative path https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
 user_mod_path = os.path.join(_here, "__VC_HANDLER_ENTRYPOINT")  # absolute
 __vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", user_mod_path)
@@ -51,21 +209,9 @@ def format_headers(headers, decode=False):
         keyToList[key].append(value)
     return keyToList
 
-if 'VERCEL_IPC_PATH' in os.environ:
-    from http.server import ThreadingHTTPServer
-    import http
-    import time
-    import contextvars
-    import functools
-    import builtins
-    import logging
 
+if 'VERCEL_IPC_PATH' in os.environ:
     start_time = time.time()
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
-
-    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
-    storage = contextvars.ContextVar('storage', default=None)
 
     # Override urlopen from urllib3 (& requests) to send Request Metrics
     try:
@@ -110,71 +256,6 @@ if 'VERCEL_IPC_PATH' in os.environ:
     except:
         pass
 
-    # Override sys.stdout and sys.stderr to map logs to the correct request
-    class StreamWrapper:
-        def __init__(self, stream, stream_name):
-            self.stream = stream
-            self.stream_name = stream_name
-
-        def write(self, message):
-            context = storage.get()
-            if context is not None:
-                send_message({
-                    "type": "log",
-                    "payload": {
-                        "context": {
-                            "invocationId": context['invocationId'],
-                            "requestId": context['requestId'],
-                        },
-                        "message": base64.b64encode(message.encode()).decode(),
-                        "stream": self.stream_name,
-                    }
-                })
-            else:
-                self.stream.write(message)
-
-        def __getattr__(self, name):
-            return getattr(self.stream, name)
-
-    sys.stdout = StreamWrapper(sys.stdout, "stdout")
-    sys.stderr = StreamWrapper(sys.stderr, "stderr")
-
-    # Override the global print to log to stdout
-    def print_wrapper(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            sys.stdout.write(' '.join(map(str, args)) + '\n')
-        return wrapper
-    builtins.print = print_wrapper(builtins.print)
-
-    # Override logging to maps logs to the correct request
-    def logging_wrapper(func, level="info"):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            context = storage.get()
-            if context is not None:
-                send_message({
-                    "type": "log",
-                    "payload": {
-                        "context": {
-                            "invocationId": context['invocationId'],
-                            "requestId": context['requestId'],
-                        },
-                        "message": base64.b64encode(f"{args[0]}".encode()).decode(),
-                        "level": level,
-                    }
-                })
-            else:
-                func(*args, **kwargs)
-        return wrapper
-
-    logging.basicConfig(level=logging.INFO)
-    logging.debug = logging_wrapper(logging.debug)
-    logging.info = logging_wrapper(logging.info)
-    logging.warning = logging_wrapper(logging.warning, "warn")
-    logging.error = logging_wrapper(logging.error, "error")
-    logging.critical = logging_wrapper(logging.critical, "error")
-
     class BaseHandler(BaseHTTPRequestHandler):
         # Re-implementation of BaseHTTPRequestHandler's log_message method to
         # log to stdout instead of stderr.
@@ -406,6 +487,11 @@ if 'VERCEL_IPC_PATH' in os.environ:
                 "httpPort": server.server_address[1],
             }
         })
+        # Mark IPC as ready and flush any buffered init logs
+        _ipc_ready = True
+        for m in _init_log_buf:
+            send_message(m)
+        _init_log_buf.clear()
         server.serve_forever()
 
     print('Missing variable `handler` or `app` in file "__VC_HANDLER_ENTRYPOINT".')