vercel-cli 48.6.6__py3-none-any.whl → 50.4.6__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/python/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "5.0.10",
+  "version": "6.1.6",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -21,12 +21,12 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "12.1.3",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",
     "jest-junit": "16.0.0",
-    "which": "3.0.0"
+    "which": "3.0.0",
+    "@vercel/build-utils": "13.2.4"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import os
 import site
@@ -5,9 +6,21 @@ import importlib
 import base64
 import json
 import inspect
+import asyncio
+import http
+import time
+import traceback
 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
+import atexit
+
 
 _here = os.path.dirname(__file__)
 _vendor_rel = '__VC_HANDLER_VENDOR_DIR'
@@ -30,13 +43,209 @@ 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", ""))
+
+            with contextlib.suppress(Exception):
+                if record.exc_info:
+                    # logging allows exc_info=True or a (type, value, tb) tuple
+                    exc_info = record.exc_info
+                    if exc_info is True:
+                        exc_info = sys.exc_info()
+                    if isinstance(exc_info, tuple):
+                        tb = ''.join(traceback.format_exception(*exc_info))
+                        if tb:
+                            if message:
+                                message = f"{message}\n{tb}"
+                            else:
+                                message = tb
+
+            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)
+
+
+def _stderr(message: str):
+    with contextlib.suppress(Exception):
+        _original_stderr.write(message + "\n")
+        _original_stderr.flush()
+
+
+# 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")
+
+
+def flush_init_log_buf_to_stderr():
+    global _init_log_buf, _init_log_buf_bytes
+    try:
+        combined: list[str] = []
+        for m in _init_log_buf:
+            payload = m.get("payload", {})
+            msg = payload.get("message")
+            if not msg:
+                continue
+            with contextlib.suppress(Exception):
+                decoded = base64.b64decode(msg).decode(errors="ignore")
+                combined.append(decoded)
+        if combined:
+            _stderr("".join(combined))
+    except Exception:
+        pass
+    finally:
+        _init_log_buf.clear()
+        _init_log_buf_bytes = 0
+
+
+atexit.register(flush_init_log_buf_to_stderr)
+
+
+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)
-__vc_module = util.module_from_spec(__vc_spec)
-sys.modules["__VC_HANDLER_MODULE_NAME"] = __vc_module
-__vc_spec.loader.exec_module(__vc_module)
-__vc_variables = dir(__vc_module)
+try:
+    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)
+    __vc_module = util.module_from_spec(__vc_spec)
+    sys.modules["__VC_HANDLER_MODULE_NAME"] = __vc_module
+    __vc_spec.loader.exec_module(__vc_module)
+    __vc_variables = dir(__vc_module)
+except Exception:
+    _stderr(f'Error importing __VC_HANDLER_ENTRYPOINT:')
+    _stderr(traceback.format_exc())
+    exit(1)
 
 _use_legacy_asyncio = sys.version_info < (3, 10)
 
@@ -51,21 +260,98 @@ 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
 
-    start_time = time.time()
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+class ASGIMiddleware:
+    """
+    ASGI middleware that preserves Vercel IPC semantics for request lifecycle:
+    - Handles /_vercel/ping
+    - Extracts x-vercel-internal-* headers and removes them from downstream app
+    - Sets request context into `storage` for logging/metrics
+    - Emits handler-started and end IPC messages
+    """
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope.get('type') != 'http':
+            # Non-HTTP traffic is forwarded verbatim
+            await self.app(scope, receive, send)
+            return
+
+        if scope.get('path') == '/_vercel/ping':
+            await send({
+                'type': 'http.response.start',
+                'status': 200,
+                'headers': [],
+            })
+            await send({
+                'type': 'http.response.body',
+                'body': b'',
+                'more_body': False,
+            })
+            return
+
+        # Extract internal headers and set per-request context
+        headers_list = scope.get('headers', []) or []
+        new_headers = []
+        invocation_id = "0"
+        request_id = 0
+
+        def _b2s(b: bytes) -> str:
+            try:
+                return b.decode()
+            except Exception:
+                return ''
+
+        for k, v in headers_list:
+            key = _b2s(k).lower()
+            val = _b2s(v)
+            if key == 'x-vercel-internal-invocation-id':
+                invocation_id = val
+                continue
+            if key == 'x-vercel-internal-request-id':
+                request_id = int(val) if val.isdigit() else 0
+                continue
+            if key in ('x-vercel-internal-span-id', 'x-vercel-internal-trace-id'):
+                continue
+            new_headers.append((k, v))
+
+        new_scope = dict(scope)
+        new_scope['headers'] = new_headers
+
+        # Announce handler start and set context for logging/metrics
+        send_message({
+            "type": "handler-started",
+            "payload": {
+                "handlerStartedAt": int(time.time() * 1000),
+                "context": {
+                    "invocationId": invocation_id,
+                    "requestId": request_id,
+                }
+            }
+        })
 
-    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
-    storage = contextvars.ContextVar('storage', default=None)
+        token = storage.set({
+            "invocationId": invocation_id,
+            "requestId": request_id,
+        })
+
+        try:
+            await self.app(new_scope, receive, send)
+        finally:
+            storage.reset(token)
+            send_message({
+                "type": "end",
+                "payload": {
+                    "context": {
+                        "invocationId": invocation_id,
+                        "requestId": request_id,
+                    }
+                }
+            })
+
+if 'VERCEL_IPC_PATH' in os.environ:
+    start_time = time.time()
 
     # Override urlopen from urllib3 (& requests) to send Request Metrics
     try:
@@ -110,71 +396,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.
@@ -240,8 +461,8 @@ if 'VERCEL_IPC_PATH' in os.environ:
     if 'handler' in __vc_variables or 'Handler' in __vc_variables:
         base = __vc_module.handler if ('handler' in __vc_variables) else  __vc_module.Handler
         if not issubclass(base, BaseHTTPRequestHandler):
-            print('Handler must inherit from BaseHTTPRequestHandler')
-            print('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
+            _stderr('Handler must inherit from BaseHTTPRequestHandler')
+            _stderr('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
             exit(1)
 
         class Handler(BaseHandler, base):
@@ -322,80 +543,53 @@ if 'VERCEL_IPC_PATH' in os.environ:
                         if hasattr(response, 'close'):
                             response.close()
         else:
-            from urllib.parse import urlparse
-            from io import BytesIO
-            import asyncio
-
-            app = __vc_module.app
-
-            class Handler(BaseHandler):
-                def handle_request(self):
-                    # Prepare ASGI scope
-                    url = urlparse(self.path)
-                    headers_encoded = []
-                    for k, v in self.headers.items():
-                        # Cope with repeated headers in the encoding.
-                        if isinstance(v, list):
-                            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(
-                            'x-forwarded-for', self.headers.get(
-                                'x-real-ip')), 0),
-                        'scheme': self.headers.get('x-forwarded-proto', 'http'),
-                        'root_path': '',
-                        'query_string': url.query.encode(),
-                        'headers': headers_encoded,
-                        'type': 'http',
-                        'http_version': '1.1',
-                        'method': self.command,
-                        'path': url.path,
-                        'raw_path': url.path.encode(),
-                    }
+            # ASGI: Run with Uvicorn so we get proper lifespan and protocol handling
+            try:
+                import uvicorn
+            except Exception:
+                _stderr('Uvicorn is required to run ASGI apps. Please ensure it is installed.')
+                exit(1)
+
+            # Prefer a callable app.asgi when available; some frameworks expose a boolean here
+            user_app_candidate = getattr(__vc_module.app, 'asgi', None)
+            user_app = user_app_candidate if callable(user_app_candidate) else __vc_module.app
+            asgi_app = ASGIMiddleware(user_app)
+
+            # Pre-bind a socket to obtain an ephemeral port for IPC announcement
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.bind(('127.0.0.1', 0))
+            sock.listen(2048)
+            http_port = sock.getsockname()[1]
+
+            config = uvicorn.Config(
+                app=asgi_app,
+                fd=sock.fileno(),
+                lifespan='auto',
+                access_log=False,
+                log_config=None,
+                log_level='warning',
+            )
+            server = uvicorn.Server(config)
 
-                    if 'content-length' in self.headers:
-                        content_length = int(self.headers['content-length'])
-                        body = self.rfile.read(content_length)
-                    else:
-                        body = b''
+            send_message({
+                "type": "server-started",
+                "payload": {
+                    "initDuration": int((time.time() - start_time) * 1000),
+                    "httpPort": http_port,
+                }
+            })
 
-                    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()
+            # 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()
 
-                    # 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)
+            # Run the server (blocking)
+            server.run()
+            # If the server ever returns, exit
+            sys.exit(0)
 
     if 'Handler' in locals():
         server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
@@ -406,10 +600,15 @@ 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".')
-    print('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
+    _stderr('Missing variable `handler` or `app` in file "__VC_HANDLER_ENTRYPOINT".')
+    _stderr('See the docs: https://vercel.com/docs/functions/serverless-functions/runtimes/python')
     exit(1)
 
 if 'handler' in __vc_variables or 'Handler' in __vc_variables:
@@ -626,7 +825,18 @@ elif 'app' in __vc_variables:
                         )
 
                     status_code = message['status']
-                    headers = Headers(message.get('headers', []))
+                    raw_headers = message.get('headers', [])
+
+                    # Headers from werkzeug transform bytes header value
+                    # from b'value' to "b'value'" so we need to process
+                    # ASGI headers manually
+                    decoded_headers = []
+                    for key, value in raw_headers:
+                        decoded_key = key.decode() if isinstance(key, bytes) else key
+                        decoded_value = value.decode() if isinstance(value, bytes) else value
+                        decoded_headers.append((decoded_key, decoded_value))
+
+                    headers = Headers(decoded_headers)
 
                     self.on_request(headers, status_code)
                     self.state = ASGICycleState.RESPONSE

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

@@ -39,8 +39,9 @@ if _app is None:
         f"Missing 'app' in module '{USER_MODULE}'. Define `app = ...` (ASGI app)."
     )
 
-# Sanic compatibility: prefer `app.asgi` when available
-USER_ASGI_APP = getattr(_app, 'asgi', _app)
+# Prefer a callable app.asgi when available; some frameworks expose a boolean here
+_CAND = getattr(_app, 'asgi', None)
+USER_ASGI_APP = _CAND if callable(_CAND) else _app
 
 PUBLIC_DIR = 'public'
 

vercel_cli/vendor/package.json

@@ -4,9 +4,9 @@
     "vercel": "./dist/vc.js"
   },
   "dependencies": {
-    "@vercel/build-utils": "12.2.1",
+    "@vercel/build-utils": "13.2.12",
     "@vercel/detect-agent": "1.0.0",
-    "@vercel/python": "5.0.10"
+    "@vercel/python": "6.1.6"
   },
   "description": "The command-line interface for Vercel",
   "engines": {
@@ -30,12 +30,13 @@
     "dev": "echo \"'pnpm dev [command]' has been removed. Use 'pnpm vercel [command]' instead.\" && exit 1",
     "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --bail",
     "test-dev": "pnpm test test/dev/",
-    "test-e2e": "rimraf test/fixtures/integration && pnpm test test/integration-1.test.ts test/integration-2.test.ts test/integration-3.test.ts",
+    "test-e2e-node-all-versions": "rimraf test/fixtures/integration && pnpm test test/integration-1.test.ts test/integration-2.test.ts test/integration-3.test.ts test/integration-link-env-pull.test.ts",
     "type-check": "tsc --noEmit",
     "vc": "pnpm vercel",
     "vercel": "pnpm build && node ./dist/vc.js",
     "vitest-run": "vitest --config ./vitest.config.mts",
     "vitest-unit": "jest test/unit/ --listTests"
   },
-  "version": "48.6.6"
+  "type": "module",
+  "version": "50.4.6"
 }

{vercel_cli-48.6.6.dist-info → vercel_cli-50.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vercel-cli
-Version: 48.6.6
+Version: 50.4.6
 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