vercel-cli 48.2.6__py3-none-any.whl → 48.3.0__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/python/vc_init.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 import sys
 import os
 import site
@@ -6,19 +5,9 @@ import importlib
 import base64
 import json
 import inspect
-import threading
-import asyncio
-import http
-import time
 from importlib import util
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from http.server import BaseHTTPRequestHandler
 import socket
-import functools
-import logging
-import builtins
-from typing import Callable, Literal
-import contextvars
-import io
 
 _here = os.path.dirname(__file__)
 _vendor_rel = '__VC_HANDLER_VENDOR_DIR'
@@ -62,69 +51,72 @@ def format_headers(headers, decode=False):
         keyToList[key].append(value)
     return keyToList
 
-# Custom logging handler so logs are properly categorized
-class VCLogHandler(logging.Handler):
-    def __init__(self, send_message: Callable[[dict], None], context_getter: Callable[[], dict] | None = None):
-        super().__init__()
-        self._send_message = send_message
-        self._context_getter = context_getter
+if 'VERCEL_IPC_PATH' in os.environ:
+    from http.server import ThreadingHTTPServer
+    import http
+    import time
+    import contextvars
+    import functools
+    import builtins
+    import logging
 
-    def emit(self, record):
-        try:
-            message = record.getMessage()
-        except Exception:
-            try:
-                message = f"{record.msg}"
-            except Exception:
-                message = ""
-
-        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"
+    start_time = time.time()
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
 
-        ctx = None
-        try:
-            ctx = self._context_getter() if self._context_getter is not None else None
-        except Exception:
-            ctx = None
+    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
+    storage = contextvars.ContextVar('storage', default=None)
 
-        if ctx is not None:
-            try:
-                self._send_message({
-                    "type": "log",
-                    "payload": {
-                        "context": {
-                            "invocationId": ctx['invocationId'],
-                            "requestId": ctx['requestId'],
-                        },
-                        "message": base64.b64encode(message.encode()).decode(),
-                        "level": level,
-                    }
-                })
-            except Exception:
-                pass
-        else:
-            try:
-                sys.stdout.write(message + "\n")
-            except Exception:
-                pass
+    # Override urlopen from urllib3 (& requests) to send Request Metrics
+    try:
+        import urllib3
+        from urllib.parse import urlparse
 
+        def timed_request(func):
+            fetchId = 0
+            @functools.wraps(func)
+            def wrapper(self, method, url, *args, **kwargs):
+                nonlocal fetchId
+                fetchId += 1
+                start_time = int(time.time() * 1000)
+                result = func(self, method, url, *args, **kwargs)
+                elapsed_time = int(time.time() * 1000) - start_time
+                parsed_url = urlparse(url)
+                context = storage.get()
+                if context is not None:
+                    send_message({
+                        "type": "metric",
+                        "payload": {
+                            "context": {
+                                "invocationId": context['invocationId'],
+                                "requestId": context['requestId'],
+                            },
+                            "type": "fetch-metric",
+                            "payload": {
+                                "pathname": parsed_url.path,
+                                "search": parsed_url.query,
+                                "start": start_time,
+                                "duration": elapsed_time,
+                                "host": parsed_url.hostname or self.host,
+                                "statusCode": result.status,
+                                "method": method,
+                                "id": fetchId
+                            }
+                        }
+                    })
+                return result
+            return wrapper
+        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
+    except:
+        pass
 
-def setup_logging(send_message: Callable[[dict], None], storage: contextvars.ContextVar[dict | None]):
     # Override sys.stdout and sys.stderr to map logs to the correct request
     class StreamWrapper:
-        def __init__(self, stream: io.TextIOBase, stream_name: Literal["stdout", "stderr"]):
+        def __init__(self, stream, stream_name):
             self.stream = stream
             self.stream_name = stream_name
 
-        def write(self, message: str):
+        def write(self, message):
             context = storage.get()
             if context is not None:
                 send_message({
@@ -147,15 +139,19 @@ def setup_logging(send_message: Callable[[dict], None], storage: contextvars.Con
     sys.stdout = StreamWrapper(sys.stdout, "stdout")
     sys.stderr = StreamWrapper(sys.stderr, "stderr")
 
-    # Wrap top-level logging helpers to emit structured logs when a request
-    # context is available; otherwise fall back to the original behavior.
-    def logging_wrapper(func: Callable[..., None], level: str = "info") -> Callable[..., None]:
+    # Override the global print to log to stdout
+    def print_wrapper(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            try:
-                context = storage.get()
-            except Exception:
-                context = None
+            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",
@@ -172,77 +168,12 @@ def setup_logging(send_message: Callable[[dict], None], storage: contextvars.Con
                 func(*args, **kwargs)
         return wrapper
 
-    logging.basicConfig(level=logging.INFO, handlers=[VCLogHandler(send_message, storage.get)], force=True)
-    logging.debug = logging_wrapper(logging.debug, "debug")
-    logging.info = logging_wrapper(logging.info, "info")
+    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.fatal = logging_wrapper(logging.fatal, "fatal")
-    logging.critical = logging_wrapper(logging.critical, "fatal")
-
-    # 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, **kwargs):
-            sys.stdout.write(' '.join(map(str, args)) + '\n')
-        return wrapper
-
-    builtins.print = print_wrapper(builtins.print)
-
-
-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:
-        import urllib3
-        from urllib.parse import urlparse
-
-        def timed_request(func):
-            fetchId = 0
-            @functools.wraps(func)
-            def wrapper(self, method, url, *args, **kwargs):
-                nonlocal fetchId
-                fetchId += 1
-                start_time = int(time.time() * 1000)
-                result = func(self, method, url, *args, **kwargs)
-                elapsed_time = int(time.time() * 1000) - start_time
-                parsed_url = urlparse(url)
-                context = storage.get()
-                if context is not None:
-                    send_message({
-                        "type": "metric",
-                        "payload": {
-                            "context": {
-                                "invocationId": context['invocationId'],
-                                "requestId": context['requestId'],
-                            },
-                            "type": "fetch-metric",
-                            "payload": {
-                                "pathname": parsed_url.path,
-                                "search": parsed_url.query,
-                                "start": start_time,
-                                "duration": elapsed_time,
-                                "host": parsed_url.hostname or self.host,
-                                "statusCode": result.status,
-                                "method": method,
-                                "id": fetchId
-                            }
-                        }
-                    })
-                return result
-            return wrapper
-        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
-    except:
-        pass
-
-    setup_logging(send_message, storage)
+    logging.critical = logging_wrapper(logging.critical, "error")
 
     class BaseHandler(BaseHTTPRequestHandler):
         # Re-implementation of BaseHTTPRequestHandler's log_message method to
@@ -325,7 +256,6 @@ if 'VERCEL_IPC_PATH' in os.environ:
                 method()
                 self.wfile.flush()
     elif 'app' in __vc_variables:
-        # WSGI
         if (
             not inspect.iscoroutinefunction(__vc_module.app) and
             not inspect.iscoroutinefunction(__vc_module.app.__call__)
@@ -391,10 +321,10 @@ if 'VERCEL_IPC_PATH' in os.environ:
                     finally:
                         if hasattr(response, 'close'):
                             response.close()
-        # ASGI
         else:
             from urllib.parse import urlparse
             from io import BytesIO
+            import asyncio
 
             app = __vc_module.app
 
@@ -409,7 +339,6 @@ if 'VERCEL_IPC_PATH' in os.environ:
                             headers_encoded.append([k.lower().encode(), [i.encode() for i in v]])
                         else:
                             headers_encoded.append([k.lower().encode(), v.encode()])
-
                     scope = {
                         'server': (self.headers.get('host', 'lambda'), self.headers.get('x-forwarded-port', 80)),
                         'client': (self.headers.get(
@@ -432,96 +361,41 @@ if 'VERCEL_IPC_PATH' in os.environ:
                     else:
                         body = b''
 
-                    # Event to signal that the response has been fully sent
-                    response_done = threading.Event()
-                    # Event to signal the ASGI app has fully completed (incl. background tasks)
-                    app_done = threading.Event()
-
-                    # Propagate request context to background thread for logging & metrics
-                    request_context = storage.get()
+                    if _use_legacy_asyncio:
+                        loop = asyncio.new_event_loop()
+                        app_queue = asyncio.Queue(loop=loop)
+                    else:
+                        app_queue = asyncio.Queue()
+                    app_queue.put_nowait({'type': 'http.request', 'body': body, 'more_body': False})
+
+                    # Prepare ASGI receive function
+                    async def receive():
+                        message = await app_queue.get()
+                        return message
+
+                    # Prepare ASGI send function
+                    response_started = False
+                    async def send(event):
+                        nonlocal response_started
+                        if event['type'] == 'http.response.start':
+                            self.send_response(event['status'])
+                            if 'headers' in event:
+                                for name, value in event['headers']:
+                                    self.send_header(name.decode(), value.decode())
+                            self.end_headers()
+                            response_started = True
+                        elif event['type'] == 'http.response.body':
+                            self.wfile.write(event['body'])
+                            if not event.get('more_body', False):
+                                self.wfile.flush()
 
-                    def run_asgi():
-                        # Ensure request context is available in this thread
-                        if request_context is not None:
-                            token = storage.set(request_context)
-                        else:
-                            token = None
-                        # Track if headers were sent, so we can synthesize a 500 on early failure
-                        response_started = False
-                        try:
-                            async def runner():
-                                # Per-request app queue
-                                if _use_legacy_asyncio:
-                                    loop = asyncio.get_running_loop()
-                                    app_queue = asyncio.Queue(loop=loop)
-                                else:
-                                    app_queue = asyncio.Queue()
-
-                                await app_queue.put({'type': 'http.request', 'body': body, 'more_body': False})
-
-                                async def receive():
-                                    message = await app_queue.get()
-                                    return message
-
-                                async def send(event):
-                                    nonlocal response_started
-                                    if event['type'] == 'http.response.start':
-                                        self.send_response(event['status'])
-                                        if 'headers' in event:
-                                            for name, value in event['headers']:
-                                                self.send_header(name.decode(), value.decode())
-                                        self.end_headers()
-                                        response_started = True
-                                    elif event['type'] == 'http.response.body':
-                                        # Stream body as it is produced; flush on completion
-                                        body_bytes = event.get('body', b'') or b''
-                                        if body_bytes:
-                                            self.wfile.write(body_bytes)
-                                        if not event.get('more_body', False):
-                                            try:
-                                                self.wfile.flush()
-                                            finally:
-                                                response_done.set()
-                                                try:
-                                                    app_queue.put_nowait({'type': 'http.disconnect'})
-                                                except Exception:
-                                                    pass
-
-                                # Run ASGI app (includes background tasks)
-                                asgi_instance = app(scope, receive, send)
-                                await asgi_instance
-                                # Mark app completion when the ASGI callable returns
-                                app_done.set()
-
-                            asyncio.run(runner())
-                        except Exception:
-                            # If the app raised before starting the response, synthesize a 500
-                            try:
-                                if not response_started:
-                                    self.send_response(500)
-                                    self.end_headers()
-                                try:
-                                    self.wfile.flush()
-                                except Exception:
-                                    pass
-                            except Exception:
-                                pass
-                        finally:
-                            # Always unblock the waiting thread to avoid hangs
-                            response_done.set()
-                            # Ensure app completion is always signaled
-                            app_done.set()
-                            if token is not None:
-                                storage.reset(token)
-
-                    # Run ASGI in background thread to allow returning after final flush
-                    t = threading.Thread(target=run_asgi, daemon=True)
-                    t.start()
-
-                    # Wait until final body chunk has been flushed to client
-                    response_done.wait()
-                    # Also wait until the ASGI app finishes (includes background tasks)
-                    app_done.wait()
+                    # Run the ASGI application
+                    asgi_instance = app(scope, receive, send)
+                    if _use_legacy_asyncio:
+                        asgi_task = loop.create_task(asgi_instance)
+                        loop.run_until_complete(asgi_task)
+                    else:
+                        asyncio.run(asgi_instance)
 
     if 'Handler' in locals():
         server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)

vercel_cli/vendor/node_modules/@vercel/python/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)

vercel_cli/vendor/node_modules/@vercel/python/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()

vercel_cli/vendor/package.json

@@ -4,9 +4,9 @@
     "vercel": "./dist/vc.js"
   },
   "dependencies": {
-    "@vercel/build-utils": "12.1.2",
+    "@vercel/build-utils": "12.1.3",
     "@vercel/detect-agent": "1.0.0",
-    "@vercel/python": "5.0.8"
+    "@vercel/python": "5.0.10"
   },
   "description": "The command-line interface for Vercel",
   "engines": {
@@ -37,5 +37,5 @@
     "vitest-run": "vitest --config ./vitest.config.mts",
     "vitest-unit": "jest test/unit/ --listTests"
   },
-  "version": "48.2.6"
+  "version": "48.3.0"
 }

{vercel_cli-48.2.6.dist-info → vercel_cli-48.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vercel-cli
-Version: 48.2.6
+Version: 48.3.0
 Summary: Vercel CLI packaged for Python (bundled Node.js, vendored npm)
 Project-URL: Homepage, https://github.com/nuage-studio/vercel-cli-python
 Project-URL: Repository, https://github.com/nuage-studio/vercel-cli-python