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

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/lambda.d.ts

@@ -2,10 +2,12 @@
 import type { Config, Env, Files, FunctionFramework, TriggerEvent } from './types';
 export type { TriggerEvent };
 export type LambdaOptions = LambdaOptionsWithFiles | LambdaOptionsWithZipBuffer;
+export type LambdaExecutableRuntimeLanguages = 'rust' | 'go';
 export type LambdaArchitecture = 'x86_64' | 'arm64';
 export interface LambdaOptionsBase {
     handler: string;
     runtime: string;
+    runtimeLanguage?: LambdaExecutableRuntimeLanguages;
     architecture?: LambdaArchitecture;
     memory?: number;
     maxDuration?: number;
@@ -41,6 +43,11 @@ export interface LambdaOptionsBase {
      * When true, the Lambda runtime can be terminated mid-execution if the request is cancelled.
      */
     supportsCancellation?: boolean;
+    /**
+     * Whether to disable automatic fetch instrumentation.
+     * When true, the Function runtime will not automatically instrument fetch calls.
+     */
+    shouldDisableAutomaticFetchInstrumentation?: boolean;
 }
 export interface LambdaOptionsWithFiles extends LambdaOptionsBase {
     files: Files;
@@ -70,6 +77,11 @@ export declare class Lambda {
     files?: Files;
     handler: string;
     runtime: string;
+    /**
+     * When using a generic runtime such as "executable" or "provided" (custom runtimes),
+     * this field can be used to specify the language the executable was compiled with.
+     */
+    runtimeLanguage?: LambdaExecutableRuntimeLanguages;
     architecture: LambdaArchitecture;
     memory?: number;
     maxDuration?: number;
@@ -105,6 +117,11 @@ export declare class Lambda {
      * When true, the Lambda runtime can be terminated mid-execution if the request is cancelled.
      */
     supportsCancellation?: boolean;
+    /**
+     * Whether to disable automatic fetch instrumentation.
+     * When true, the Function runtime will not automatically instrument fetch calls.
+     */
+    shouldDisableAutomaticFetchInstrumentation?: boolean;
     constructor(opts: LambdaOptions);
     createZip(): Promise<Buffer>;
     /**

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/lambda.js

@@ -60,6 +60,7 @@ class Lambda {
     const {
       handler,
       runtime,
+      runtimeLanguage,
       maxDuration,
       architecture,
       memory,
@@ -73,7 +74,8 @@ class Lambda {
       operationType,
       framework,
       experimentalTriggers,
-      supportsCancellation
+      supportsCancellation,
+      shouldDisableAutomaticFetchInstrumentation
     } = opts;
     if ("files" in opts) {
       (0, import_assert.default)(typeof opts.files === "object", '"files" must be an object');
@@ -90,6 +92,12 @@ class Lambda {
         '"architecture" must be either "x86_64" or "arm64"'
       );
     }
+    if (runtimeLanguage !== void 0) {
+      (0, import_assert.default)(
+        runtimeLanguage === "rust" || runtimeLanguage === "go",
+        '"runtimeLanguage" is invalid. Valid options: "rust", "go"'
+      );
+    }
     if ("experimentalAllowBundling" in opts && opts.experimentalAllowBundling !== void 0) {
       (0, import_assert.default)(
         typeof opts.experimentalAllowBundling === "boolean",
@@ -213,6 +221,7 @@ class Lambda {
     this.files = "files" in opts ? opts.files : void 0;
     this.handler = handler;
     this.runtime = runtime;
+    this.runtimeLanguage = runtimeLanguage;
     this.architecture = getDefaultLambdaArchitecture(architecture);
     this.memory = memory;
     this.maxDuration = maxDuration;
@@ -227,6 +236,7 @@ class Lambda {
     this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
     this.experimentalTriggers = experimentalTriggers;
     this.supportsCancellation = supportsCancellation;
+    this.shouldDisableAutomaticFetchInstrumentation = shouldDisableAutomaticFetchInstrumentation;
   }
   async createZip() {
     let { zipBuffer } = this;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/python.d.ts

@@ -0,0 +1,22 @@
+import FileFsRef from './file-fs-ref';
+/**
+ * Run a Python script that only uses the standard library.
+ */
+export declare function runStdlibPyScript(options: {
+    scriptName: string;
+    pythonPath?: string;
+    args?: string[];
+    cwd?: string;
+}): Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Check if a Python file is a valid entrypoint by detecting:
+ * - A top-level 'app' callable (Flask, FastAPI, Sanic, WSGI/ASGI, etc.)
+ * - A top-level 'handler' class (BaseHTTPRequestHandler subclass)
+ */
+export declare function isPythonEntrypoint(file: FileFsRef | {
+    fsPath?: string;
+}): Promise<boolean>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/python.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var python_exports = {};
+__export(python_exports, {
+  isPythonEntrypoint: () => isPythonEntrypoint,
+  runStdlibPyScript: () => runStdlibPyScript
+});
+module.exports = __toCommonJS(python_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = require("path");
+var import_execa = __toESM(require("execa"));
+var import_debug = __toESM(require("./debug"));
+const isWin = process.platform === "win32";
+async function runStdlibPyScript(options) {
+  const { scriptName, pythonPath, args = [], cwd } = options;
+  const scriptPath = (0, import_path.join)(__dirname, "..", "lib", "python", `${scriptName}.py`);
+  if (!import_fs.default.existsSync(scriptPath)) {
+    throw new Error(`Python script not found: ${scriptPath}`);
+  }
+  const pythonCmd = pythonPath ?? (isWin ? "python" : "python3");
+  (0, import_debug.default)(
+    `Running stdlib Python script: ${pythonCmd} ${scriptPath} ${args.join(" ")}`
+  );
+  try {
+    const result = await (0, import_execa.default)(pythonCmd, [scriptPath, ...args], { cwd });
+    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (err) {
+    const execaErr = err;
+    return {
+      exitCode: execaErr.exitCode ?? 1,
+      stdout: execaErr.stdout ?? "",
+      stderr: execaErr.stderr ?? ""
+    };
+  }
+}
+async function isPythonEntrypoint(file) {
+  try {
+    const fsPath = file.fsPath;
+    if (!fsPath)
+      return false;
+    const content = await import_fs.default.promises.readFile(fsPath, "utf-8");
+    if (!content.includes("app") && !content.includes("handler") && !content.includes("Handler")) {
+      return false;
+    }
+    const result = await runStdlibPyScript({
+      scriptName: "ast_parser",
+      args: [fsPath]
+    });
+    return result.exitCode === 0;
+  } catch (err) {
+    (0, import_debug.default)(`Failed to check Python entrypoint: ${err}`);
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPythonEntrypoint,
+  runStdlibPyScript
+});

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/types.d.ts

@@ -346,6 +346,7 @@ export interface ProjectSettings {
     outputDirectory?: string | null;
     rootDirectory?: string | null;
     nodeVersion?: string;
+    monorepoManager?: string | null;
     createdAt?: number;
     autoExposeSystemEnvs?: boolean;
     sourceFilesOutsideRootDirectory?: boolean;
@@ -469,6 +470,14 @@ export interface BuildResultV2Typical {
     flags?: {
         definitions: FlagDefinitions;
     };
+    /**
+     * User-configured deployment ID for skew protection.
+     * This allows users to specify a custom deployment identifier
+     * in their next.config.js that will be used for version skew protection
+     * with pre-built deployments.
+     * @example "abc123"
+     */
+    deploymentId?: string;
 }
 export type BuildResultV2 = BuildResultV2Typical | BuildResultBuildOutput;
 export interface BuildResultV3 {

vercel_cli/vendor/node_modules/@vercel/build-utils/lib/python/ast_parser.py

@@ -0,0 +1,72 @@
+import sys
+import ast
+
+
+def contains_app_or_handler(file_path: str) -> bool:
+    """
+    Check if a Python file contains or exports:
+    - A top-level 'app' callable (e.g., Flask, FastAPI, Sanic apps)
+    - A top-level 'handler' class (e.g., BaseHTTPRequestHandler subclass)
+    """
+    with open(file_path, "r") as file:
+        code = file.read()
+
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return False
+
+    for node in ast.iter_child_nodes(tree):
+        # Check for top-level assignment to 'app'
+        # e.g., app = Sanic() or app = Flask(__name__) or app = create_app()
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == "app":
+                    return True
+
+        # Check for annotated assignment to 'app'
+        # e.g., app: Sanic = Sanic()
+        if isinstance(node, ast.AnnAssign):
+            if isinstance(node.target, ast.Name) and node.target.id == "app":
+                return True
+
+        # Check for function named 'app'
+        # e.g., def app(environ, start_response): ...
+        if isinstance(node, ast.FunctionDef) and node.name == "app":
+            return True
+
+        # Check for async function named 'app'
+        # e.g., async def app(scope, receive, send): ...
+        if isinstance(node, ast.AsyncFunctionDef) and node.name == "app":
+            return True
+
+        # Check for import of 'app'
+        # e.g., from server import app
+        # e.g., from server import application as app
+        if isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                # alias.asname is the 'as' name, alias.name is the original name
+                # If aliased, check asname; otherwise check the original name
+                imported_as = alias.asname if alias.asname else alias.name
+                if imported_as == "app":
+                    return True
+
+        # Check for top-level class named 'handler'
+        # e.g., class handler(BaseHTTPRequestHandler):
+        if isinstance(node, ast.ClassDef) and node.name.lower() == "handler":
+            return True
+
+    return False
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python ast_parser.py <file_path>")
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+    result = contains_app_or_handler(file_path)
+
+    # Exit with 0 if found, 1 if not found
+    sys.exit(0 if result else 1)
+

vercel_cli/vendor/node_modules/@vercel/build-utils/lib/python/tests/test_ast_parser.py

@@ -0,0 +1,72 @@
+import unittest
+import tempfile
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from ast_parser import contains_app_or_handler
+
+
+class TestContainsAppOrHandler(unittest.TestCase):
+    def _check(self, code: str) -> bool:
+        """Helper to test code snippets without needing fixture files."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            f.flush()
+            try:
+                return contains_app_or_handler(f.name)
+            finally:
+                os.unlink(f.name)
+
+    def test_flask_app(self):
+        self.assertTrue(self._check("from flask import Flask\napp = Flask(__name__)"))
+
+    def test_fastapi_app(self):
+        self.assertTrue(self._check("from fastapi import FastAPI\napp = FastAPI()"))
+
+    def test_sanic_app(self):
+        self.assertTrue(self._check("from sanic import Sanic\napp = Sanic('app')"))
+
+    def test_annotated_app(self):
+        self.assertTrue(self._check("from fastapi import FastAPI\napp: FastAPI = FastAPI()"))
+
+    def test_wsgi_function(self):
+        self.assertTrue(self._check("def app(environ, start_response):\n    pass"))
+
+    def test_asgi_function(self):
+        self.assertTrue(self._check("async def app(scope, receive, send):\n    pass"))
+
+    def test_imported_app(self):
+        self.assertTrue(self._check("from server import app"))
+
+    def test_imported_app_aliased(self):
+        self.assertTrue(self._check("from server import application as app"))
+
+    def test_handler_class(self):
+        self.assertTrue(self._check("class Handler:\n    pass"))
+
+    def test_handler_class_lowercase(self):
+        self.assertTrue(self._check("class handler:\n    pass"))
+
+    def test_no_app_or_handler(self):
+        self.assertFalse(self._check("def hello():\n    return 'world'"))
+
+    def test_app_in_function_not_toplevel(self):
+        # app defined inside a function should NOT match
+        self.assertFalse(self._check("def create():\n    app = Flask(__name__)\n    return app"))
+
+    def test_syntax_error(self):
+        self.assertFalse(self._check("def broken("))
+
+    def test_empty_file(self):
+        self.assertFalse(self._check(""))
+
+    def test_only_comments(self):
+        self.assertFalse(self._check("# just a comment\n# another comment"))
+
+
+if __name__ == "__main__":
+    unittest.main()
+

vercel_cli/vendor/node_modules/@vercel/build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "12.2.1",
+  "version": "13.2.12",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -26,8 +26,6 @@
     "@types/node-fetch": "^2.1.6",
     "@types/semver": "6.0.0",
     "@types/yazl": "2.4.2",
-    "@vercel/error-utils": "2.0.3",
-    "@vercel/routing-utils": "5.2.1",
     "aggregate-error": "3.0.1",
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",
@@ -48,7 +46,9 @@
     "typescript": "4.9.5",
     "yazl": "2.5.1",
     "vitest": "2.0.1",
-    "json5": "2.2.3"
+    "json5": "2.2.3",
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/routing-utils": "5.3.2"
   },
   "scripts": {
     "build": "node build.mjs",