@vercel/python 5.0.9 → 5.0.10

package/dist/index.js

@@ -1631,7 +1631,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse2 = require_parse();
     var enoent = require_enoent();
-    function spawn3(command, args, options) {
+    function spawn2(command, args, options) {
       const parsed = parse2(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -1643,8 +1643,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn3;
-    module2.exports.spawn = spawn3;
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse2;
     module2.exports._enoent = enoent;
@@ -3196,7 +3196,7 @@ function isInstalled2({ pipPath, pythonPath }) {
 }
 
 // src/start-dev-server.ts
-var import_child_process2 = require("child_process");
+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");
@@ -3289,30 +3289,8 @@ async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
 }
 
 // src/utils.ts
-var import_child_process = require("child_process");
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = require("path");
-var tryImport = (pythonPath, mod) => new Promise((res) => {
-  const check = (0, import_child_process.spawn)(pythonPath, ["-c", `import ${mod}`], {
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  check.once("error", () => res(false));
-  check.once("exit", (code) => res(code === 0));
-});
-var detectAsgiServer = async (workPath, pythonPath) => new Promise((resolve, reject) => {
-  tryImport(pythonPath, "uvicorn").then((hasUvicorn) => {
-    if (hasUvicorn)
-      return resolve("uvicorn");
-    tryImport(pythonPath, "hypercorn").then((hasHypercorn) => {
-      if (hasHypercorn)
-        return resolve("hypercorn");
-      const { venvRoot } = useVirtualEnv(workPath, {}, pythonPath);
-      const baseErrorMessage = 'No ASGI server found. Please install either "uvicorn" or "hypercorn" (e.g. "pip install uvicorn").';
-      const errorMessage = !venvRoot ? `${baseErrorMessage} If you are using a virtual environment, please activate it and try again.` : baseErrorMessage;
-      reject(new Error(errorMessage));
-    });
-  });
-});
 var isInVirtualEnv = () => {
   return process.env.VIRTUAL_ENV;
 };
@@ -3363,6 +3341,7 @@ var ANSI_PATTERN = "[\\u001B\\u009B][[\\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[
 var ANSI_ESCAPE_RE = new RegExp(ANSI_PATTERN, "g");
 var stripAnsi = (s) => s.replace(ANSI_ESCAPE_RE, "");
 var ASGI_SHIM_MODULE = "vc_init_dev_asgi";
+var WSGI_SHIM_MODULE = "vc_init_dev_wsgi";
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var restoreWarnings = null;
@@ -3406,7 +3385,7 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevStaticShim(workPath, modulePath) {
+function createDevAsgiShim(workPath, modulePath) {
   try {
     const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
     (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
@@ -3422,24 +3401,55 @@ function createDevStaticShim(workPath, modulePath) {
     return null;
   }
 }
+function createDevWsgiShim(workPath, modulePath) {
+  try {
+    const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path4.join)(vercelPythonDir, `${WSGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path4.join)(__dirname, "..", `${WSGI_SHIM_MODULE}.py`);
+    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}`);
+    return WSGI_SHIM_MODULE;
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    return null;
+  }
+}
 var startDevServer = async (opts) => {
   const { entrypoint: rawEntrypoint, workPath, meta = {}, config } = opts;
-  if (config?.framework !== "fastapi") {
+  const framework = config?.framework;
+  if (framework !== "fastapi" && framework !== "flask") {
     return null;
   }
   if (!restoreWarnings)
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
-  const detected = await detectFastapiEntrypoint(workPath, rawEntrypoint);
-  if (!detected) {
-    throw new Error(
-      `No FastAPI entrypoint found. Searched for: ${FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ")}`
+  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 = detected;
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   const env = { ...process.env, ...meta.env || {} };
-  const serverKey = `${workPath}::${entry}`;
+  const serverKey = `${workPath}::${entry}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
     return {
@@ -3492,40 +3502,30 @@ var startDevServer = async (opts) => {
           (0, import_build_utils4.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
           (0, import_build_utils4.debug)("No virtualenv found");
+          try {
+            const yellow = "\x1B[33m";
+            const reset = "\x1B[0m";
+            const venvCmd = process.platform === "win32" ? "python -m venv .venv && .venv\\Scripts\\activate" : "python -m venv .venv && source .venv/bin/activate";
+            process.stderr.write(
+              `${yellow}Warning: no virtual environment detected in ${workPath}. Using system Python: ${pythonCmd}.${reset}
+If you are using a virtual environment, activate it before running "vercel dev", or create one: ${venvCmd}
+`
+            );
+          } catch (_) {
+          }
         }
       }
-      const devShimModule = createDevStaticShim(workPath, modulePath);
-      if (devShimModule) {
-        const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
-        const existingPythonPath = env.PYTHONPATH || "";
-        env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
-      }
-      detectAsgiServer(workPath, pythonCmd).then(async (serverKind) => {
-        if (resolved)
-          return;
-        const host = "127.0.0.1";
-        const argv = serverKind === "uvicorn" ? [
-          "-u",
-          "-m",
-          "uvicorn",
-          `${devShimModule || modulePath}:app`,
-          "--host",
-          host,
-          "--port",
-          "0",
-          "--use-colors"
-        ] : [
-          "-u",
-          "-m",
-          "hypercorn",
-          `${devShimModule || modulePath}:app`,
-          "-b",
-          `${host}:0`
-        ];
-        (0, import_build_utils4.debug)(
-          `Starting dev server (${serverKind}): ${pythonCmd} ${argv.join(" ")}`
-        );
-        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
+      if (framework === "fastapi") {
+        const devShimModule = createDevAsgiShim(workPath, modulePath);
+        if (devShimModule) {
+          const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+          const existingPythonPath = env.PYTHONPATH || "";
+          env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
+        }
+        const moduleToRun = devShimModule || modulePath;
+        const argv = ["-u", "-m", moduleToRun];
+        (0, import_build_utils4.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
+        const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
           stdio: ["inherit", "pipe", "pipe"]
@@ -3587,16 +3587,90 @@ var startDevServer = async (opts) => {
         child.once("exit", (code, signal) => {
           if (!resolved) {
             const err = new Error(
-              `${serverKind} server exited before binding (code=${code}, signal=${signal})`
+              `ASGI dev server exited before binding (code=${code}, signal=${signal})`
             );
             rejectChildReady(err);
             reject(err);
           }
         });
-      }).catch((err) => {
-        rejectChildReady(err);
-        reject(err);
-      });
+      } else {
+        const devShimModule = createDevWsgiShim(workPath, modulePath);
+        if (devShimModule) {
+          const vercelPythonDir = (0, import_path4.join)(workPath, ".vercel", "python");
+          const existingPythonPath = env.PYTHONPATH || "";
+          env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
+        }
+        const moduleToRun = devShimModule || modulePath;
+        const argv = ["-u", "-m", moduleToRun];
+        (0, import_build_utils4.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        const child = (0, import_child_process.spawn)(pythonCmd, argv, {
+          cwd: workPath,
+          env,
+          stdio: ["inherit", "pipe", "pipe"]
+        });
+        childProcess = child;
+        stdoutLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line) {
+              process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+            }
+          }
+        };
+        stderrLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line) {
+              process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+            }
+          }
+        };
+        child.stdout?.on("data", stdoutLogListener);
+        child.stderr?.on("data", stderrLogListener);
+        const readinessRegexes = [
+          /Werkzeug running on https?:\/\/(?:\[[^\]]+\]|[^:]+):(\d+)/i,
+          /(?:Running|Serving) on https?:\/\/(?:\[[^\]]+\]|[^:\s]+):(\d+)/i
+        ];
+        const onDetect = (chunk) => {
+          const text = chunk.toString();
+          const clean = stripAnsi(text);
+          let portMatch = null;
+          for (const rx of readinessRegexes) {
+            const m = clean.match(rx);
+            if (m) {
+              portMatch = m;
+              break;
+            }
+          }
+          if (portMatch && child.pid) {
+            if (!resolved) {
+              resolved = true;
+              child.stdout?.removeListener("data", onDetect);
+              child.stderr?.removeListener("data", onDetect);
+              const port2 = Number(portMatch[1]);
+              resolveChildReady({ port: port2, pid: child.pid });
+              resolve();
+            }
+          }
+        };
+        child.stdout?.on("data", onDetect);
+        child.stderr?.on("data", onDetect);
+        child.once("error", (err) => {
+          if (!resolved) {
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+        child.once("exit", (code, signal) => {
+          if (!resolved) {
+            const err = new Error(
+              `Flask dev server exited before binding (code=${code}, signal=${signal})`
+            );
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+      }
     });
     const { port, pid } = await childReady;
     PERSISTENT_SERVERS.set(serverKey, {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@vercel/python",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
   "files": [
     "dist",
     "vc_init.py",
-    "vc_init_dev_asgi.py"
+    "vc_init_dev_asgi.py",
+    "vc_init_dev_wsgi.py"
   ],
   "repository": {
     "type": "git",
@@ -20,7 +21,7 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "12.1.2",
+    "@vercel/build-utils": "12.1.3",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",

package/vc_init_dev_asgi.py

@@ -1,8 +1,23 @@
 # Auto-generated template used by vercel dev (Python, ASGI)
 # Serves static files from PUBLIC_DIR before delegating to the user ASGI app.
-from importlib import import_module
+import sys
 import os
 from os import path as _p
+from importlib import import_module
+
+
+# Simple ANSI coloring. Respect NO_COLOR environment variable.
+_NO_COLOR = 'NO_COLOR' in os.environ
+_RESET = "\x1b[0m"
+_YELLOW = "\x1b[33m"
+_GREEN = "\x1b[32m"
+_RED = "\x1b[31m"
+
+def _color(text: str, code: str) -> str:
+    if _NO_COLOR:
+        return text
+    return f"{code}{text}{_RESET}"
+
 
 # Optional StaticFiles import; tolerate missing deps
 StaticFiles = None
@@ -56,3 +71,29 @@ async def app(scope, receive, send):
         except Exception:
             pass
     await USER_ASGI_APP(scope, receive, send)
+
+
+if __name__ == '__main__':
+    # Development runner for ASGI: prefer uvicorn, then hypercorn.
+    # Bind to localhost on an ephemeral port and emit a recognizable log line
+    # so the caller can detect the bound port.
+    host = '127.0.0.1'
+    try:
+        import uvicorn
+        uvicorn.run('vc_init_dev_asgi:app', host=host, port=0, use_colors=True)
+    except Exception:
+        try:
+            import asyncio
+            from hypercorn.config import Config
+            from hypercorn.asyncio import serve
+
+            config = Config()
+            config.bind = [f'{host}:0']
+
+            async def _run():
+                await serve(app, config)
+
+            asyncio.run(_run())
+        except Exception:
+            print(_color('No ASGI server found. Please install either "uvicorn" or "hypercorn" (e.g. "pip install uvicorn").', _RED), file=sys.stderr)
+            sys.exit(1)

package/vc_init_dev_wsgi.py

@@ -0,0 +1,123 @@
+"""
+Auto-generated template used by vercel dev (Python, WSGI)
+Serves static files from PUBLIC_DIR before delegating to the user WSGI app.
+
+This file is written to the project at .vercel/python/vc_init_dev_wsgi.py
+and imported by the dev server launcher.
+"""
+from importlib import import_module
+from os import path as _p
+import os
+import mimetypes
+
+# Simple ANSI coloring. Respect NO_COLOR environment variable.
+_NO_COLOR = 'NO_COLOR' in os.environ
+_RESET = "\x1b[0m"
+_YELLOW = "\x1b[33m"
+_GREEN = "\x1b[32m"
+
+def _color(text: str, code: str) -> str:
+    if _NO_COLOR:
+        return text
+    return f"{code}{text}{_RESET}"
+
+USER_MODULE = "__VC_DEV_MODULE_PATH__"
+PUBLIC_DIR = "public"
+
+_mod = import_module(USER_MODULE)
+_app = getattr(_mod, "app", None)
+if _app is None:
+    raise RuntimeError(
+        f"Missing 'app' in module '{USER_MODULE}'. Define `app = ...` (WSGI app)."
+    )
+
+
+def _is_safe_file(base_dir: str, target: str) -> bool:
+    try:
+        base = _p.realpath(base_dir)
+        tgt = _p.realpath(target)
+        return (tgt == base or tgt.startswith(base + os.sep)) and _p.isfile(tgt)
+    except Exception:
+        return False
+
+
+def _static_wsgi_app(environ, start_response):
+    # Only handle GET/HEAD requests for static assets
+    if environ.get("REQUEST_METHOD", "GET") not in ("GET", "HEAD"):
+        return _not_found(start_response)
+
+    req_path = environ.get("PATH_INFO", "/") or "/"
+    safe = _p.normpath(req_path).lstrip("/")
+    full = _p.join(PUBLIC_DIR, safe)
+    if not _is_safe_file(PUBLIC_DIR, full):
+        return _not_found(start_response)
+
+    ctype, encoding = mimetypes.guess_type(full)
+    headers = [("Content-Type", ctype or "application/octet-stream")]
+    try:
+        # For HEAD requests, send headers only
+        if environ.get("REQUEST_METHOD") == "HEAD":
+            start_response("200 OK", headers)
+            return []
+        with open(full, "rb") as f:
+            data = f.read()
+        headers.append(("Content-Length", str(len(data))))
+        start_response("200 OK", headers)
+        return [data]
+    except Exception:
+        return _not_found(start_response)
+
+
+def _not_found(start_response):
+    start_response("404 Not Found", [("Content-Type", "text/plain; charset=utf-8")])
+    return [b"Not Found"]
+
+
+def _combined_app(environ, start_response):
+    # Try static first; if 404 then delegate to user app
+    captured_status = ""
+    captured_headers = tuple()
+    body_chunks = []
+
+    def capture_start_response(status, headers, exc_info=None):  # type: ignore[no-redef]
+        nonlocal captured_status, captured_headers
+        captured_status = status
+        captured_headers = tuple(headers)
+        # Return a writer that buffers the body
+        def write(chunk: bytes):
+            body_chunks.append(chunk)
+        return write
+
+    result = _static_wsgi_app(environ, capture_start_response)
+    # If static handler produced 200, forward its response
+    if captured_status.startswith("200 "):
+        # Send headers and any chunks collected
+        writer = start_response(captured_status, list(captured_headers))
+        for chunk in body_chunks:
+            writer(chunk)
+        return result
+
+    # Otherwise, delegate to user's WSGI app
+    return _app(environ, start_response)
+
+
+# Public WSGI application consumed by the dev runner
+app = _combined_app
+
+
+if __name__ == "__main__":
+    # Development runner: prefer Werkzeug, fall back to stdlib wsgiref.
+    # Bind to localhost on an ephemeral port and emit a recognizable log line
+    # so the caller can detect the bound port.
+    host = "127.0.0.1"
+    try:
+        from werkzeug.serving import run_simple
+        run_simple(host, 0, app, use_reloader=False)
+    except Exception:
+        import sys
+        print(_color("Werkzeug not installed; falling back to wsgiref (no reloader).", _YELLOW), file=sys.stderr)
+        from wsgiref.simple_server import make_server
+        httpd = make_server(host, 0, app)
+        port = httpd.server_port
+        print(_color(f"Serving on http://{host}:{port}", _GREEN))
+        httpd.serve_forever()