vercel 59.11.2 → 59.11.7

package/dist/chunks/chunk-HB4UKFDO.js

@@ -0,0 +1,1295 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_load_json_file,
+  require_pify
+} from "./chunk-B5XLQKHI.js";
+import {
+  isNativeBinaryInstall
+} from "./chunk-4IALDGB7.js";
+import {
+  require_graceful_fs
+} from "./chunk-G5FBSUL4.js";
+import {
+  output_manager_default,
+  require_signal_exit
+} from "./chunk-2JIX6UMI.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../internals/constants/dist/index.js
+var require_dist = __commonJS({
+  "../../internals/constants/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TITLE = exports.NAME = exports.LOGO = exports.PROJECT_ENV_TARGET = void 0;
+    exports.PROJECT_ENV_TARGET = [
+      "production",
+      "preview",
+      "development"
+    ];
+    exports.LOGO = "\u25B2";
+    exports.NAME = "vercel";
+    exports.TITLE = "Vercel";
+  }
+});
+
+// ../../node_modules/.pnpm/imurmurhash@0.1.4/node_modules/imurmurhash/imurmurhash.js
+var require_imurmurhash = __commonJS({
+  "../../node_modules/.pnpm/imurmurhash@0.1.4/node_modules/imurmurhash/imurmurhash.js"(exports, module) {
+    (function() {
+      var cache;
+      function MurmurHash3(key, seed) {
+        var m = this instanceof MurmurHash3 ? this : cache;
+        m.reset(seed);
+        if (typeof key === "string" && key.length > 0) {
+          m.hash(key);
+        }
+        if (m !== this) {
+          return m;
+        }
+      }
+      ;
+      MurmurHash3.prototype.hash = function(key) {
+        var h1, k1, i, top, len;
+        len = key.length;
+        this.len += len;
+        k1 = this.k1;
+        i = 0;
+        switch (this.rem) {
+          case 0:
+            k1 ^= len > i ? key.charCodeAt(i++) & 65535 : 0;
+          case 1:
+            k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 8 : 0;
+          case 2:
+            k1 ^= len > i ? (key.charCodeAt(i++) & 65535) << 16 : 0;
+          case 3:
+            k1 ^= len > i ? (key.charCodeAt(i) & 255) << 24 : 0;
+            k1 ^= len > i ? (key.charCodeAt(i++) & 65280) >> 8 : 0;
+        }
+        this.rem = len + this.rem & 3;
+        len -= this.rem;
+        if (len > 0) {
+          h1 = this.h1;
+          while (1) {
+            k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+            k1 = k1 << 15 | k1 >>> 17;
+            k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+            h1 ^= k1;
+            h1 = h1 << 13 | h1 >>> 19;
+            h1 = h1 * 5 + 3864292196 & 4294967295;
+            if (i >= len) {
+              break;
+            }
+            k1 = key.charCodeAt(i++) & 65535 ^ (key.charCodeAt(i++) & 65535) << 8 ^ (key.charCodeAt(i++) & 65535) << 16;
+            top = key.charCodeAt(i++);
+            k1 ^= (top & 255) << 24 ^ (top & 65280) >> 8;
+          }
+          k1 = 0;
+          switch (this.rem) {
+            case 3:
+              k1 ^= (key.charCodeAt(i + 2) & 65535) << 16;
+            case 2:
+              k1 ^= (key.charCodeAt(i + 1) & 65535) << 8;
+            case 1:
+              k1 ^= key.charCodeAt(i) & 65535;
+          }
+          this.h1 = h1;
+        }
+        this.k1 = k1;
+        return this;
+      };
+      MurmurHash3.prototype.result = function() {
+        var k1, h1;
+        k1 = this.k1;
+        h1 = this.h1;
+        if (k1 > 0) {
+          k1 = k1 * 11601 + (k1 & 65535) * 3432906752 & 4294967295;
+          k1 = k1 << 15 | k1 >>> 17;
+          k1 = k1 * 13715 + (k1 & 65535) * 461832192 & 4294967295;
+          h1 ^= k1;
+        }
+        h1 ^= this.len;
+        h1 ^= h1 >>> 16;
+        h1 = h1 * 51819 + (h1 & 65535) * 2246770688 & 4294967295;
+        h1 ^= h1 >>> 13;
+        h1 = h1 * 44597 + (h1 & 65535) * 3266445312 & 4294967295;
+        h1 ^= h1 >>> 16;
+        return h1 >>> 0;
+      };
+      MurmurHash3.prototype.reset = function(seed) {
+        this.h1 = typeof seed === "number" ? seed : 0;
+        this.rem = this.k1 = this.len = 0;
+        return this;
+      };
+      cache = new MurmurHash3();
+      if (typeof module != "undefined") {
+        module.exports = MurmurHash3;
+      } else {
+        this.MurmurHash3 = MurmurHash3;
+      }
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/write-file-atomic@2.4.3/node_modules/write-file-atomic/index.js
+var require_write_file_atomic = __commonJS({
+  "../../node_modules/.pnpm/write-file-atomic@2.4.3/node_modules/write-file-atomic/index.js"(exports, module) {
+    "use strict";
+    module.exports = writeFile;
+    module.exports.sync = writeFileSync;
+    module.exports._getTmpname = getTmpname;
+    module.exports._cleanupOnExit = cleanupOnExit;
+    var fs = require_graceful_fs();
+    var MurmurHash3 = require_imurmurhash();
+    var onExit = require_signal_exit();
+    var path = __require("path");
+    var activeFiles = {};
+    var threadId = function getId() {
+      try {
+        var workerThreads = __require("worker_threads");
+        return workerThreads.threadId;
+      } catch (e) {
+        return 0;
+      }
+    }();
+    var invocations = 0;
+    function getTmpname(filename) {
+      return filename + "." + MurmurHash3(__filename).hash(String(process.pid)).hash(String(threadId)).hash(String(++invocations)).result();
+    }
+    function cleanupOnExit(tmpfile) {
+      return function() {
+        try {
+          fs.unlinkSync(typeof tmpfile === "function" ? tmpfile() : tmpfile);
+        } catch (_) {
+        }
+      };
+    }
+    function writeFile(filename, data, options, callback) {
+      if (options) {
+        if (options instanceof Function) {
+          callback = options;
+          options = {};
+        } else if (typeof options === "string") {
+          options = { encoding: options };
+        }
+      } else {
+        options = {};
+      }
+      var Promise2 = options.Promise || global.Promise;
+      var truename;
+      var fd;
+      var tmpfile;
+      var removeOnExitHandler = onExit(cleanupOnExit(() => tmpfile));
+      var absoluteName = path.resolve(filename);
+      new Promise2(function serializeSameFile(resolve) {
+        if (!activeFiles[absoluteName])
+          activeFiles[absoluteName] = [];
+        activeFiles[absoluteName].push(resolve);
+        if (activeFiles[absoluteName].length === 1)
+          resolve();
+      }).then(function getRealPath() {
+        return new Promise2(function(resolve) {
+          fs.realpath(filename, function(_, realname) {
+            truename = realname || filename;
+            tmpfile = getTmpname(truename);
+            resolve();
+          });
+        });
+      }).then(function stat() {
+        return new Promise2(function stat2(resolve) {
+          if (options.mode && options.chown)
+            resolve();
+          else {
+            fs.stat(truename, function(err, stats) {
+              if (err || !stats)
+                resolve();
+              else {
+                options = Object.assign({}, options);
+                if (options.mode == null) {
+                  options.mode = stats.mode;
+                }
+                if (options.chown == null && process.getuid) {
+                  options.chown = { uid: stats.uid, gid: stats.gid };
+                }
+                resolve();
+              }
+            });
+          }
+        });
+      }).then(function thenWriteFile() {
+        return new Promise2(function(resolve, reject) {
+          fs.open(tmpfile, "w", options.mode, function(err, _fd) {
+            fd = _fd;
+            if (err)
+              reject(err);
+            else
+              resolve();
+          });
+        });
+      }).then(function write() {
+        return new Promise2(function(resolve, reject) {
+          if (Buffer.isBuffer(data)) {
+            fs.write(fd, data, 0, data.length, 0, function(err) {
+              if (err)
+                reject(err);
+              else
+                resolve();
+            });
+          } else if (data != null) {
+            fs.write(fd, String(data), 0, String(options.encoding || "utf8"), function(err) {
+              if (err)
+                reject(err);
+              else
+                resolve();
+            });
+          } else
+            resolve();
+        });
+      }).then(function syncAndClose() {
+        return new Promise2(function(resolve, reject) {
+          if (options.fsync !== false) {
+            fs.fsync(fd, function(err) {
+              if (err)
+                fs.close(fd, () => reject(err));
+              else
+                fs.close(fd, resolve);
+            });
+          } else {
+            fs.close(fd, resolve);
+          }
+        });
+      }).then(function chown() {
+        fd = null;
+        if (options.chown) {
+          return new Promise2(function(resolve, reject) {
+            fs.chown(tmpfile, options.chown.uid, options.chown.gid, function(err) {
+              if (err)
+                reject(err);
+              else
+                resolve();
+            });
+          });
+        }
+      }).then(function chmod() {
+        if (options.mode) {
+          return new Promise2(function(resolve, reject) {
+            fs.chmod(tmpfile, options.mode, function(err) {
+              if (err)
+                reject(err);
+              else
+                resolve();
+            });
+          });
+        }
+      }).then(function rename() {
+        return new Promise2(function(resolve, reject) {
+          fs.rename(tmpfile, truename, function(err) {
+            if (err)
+              reject(err);
+            else
+              resolve();
+          });
+        });
+      }).then(function success() {
+        removeOnExitHandler();
+        callback();
+      }, function fail(err) {
+        return new Promise2((resolve) => {
+          return fd ? fs.close(fd, resolve) : resolve();
+        }).then(() => {
+          removeOnExitHandler();
+          fs.unlink(tmpfile, function() {
+            callback(err);
+          });
+        });
+      }).then(function checkQueue() {
+        activeFiles[absoluteName].shift();
+        if (activeFiles[absoluteName].length > 0) {
+          activeFiles[absoluteName][0]();
+        } else
+          delete activeFiles[absoluteName];
+      });
+    }
+    function writeFileSync(filename, data, options) {
+      if (typeof options === "string")
+        options = { encoding: options };
+      else if (!options)
+        options = {};
+      try {
+        filename = fs.realpathSync(filename);
+      } catch (ex) {
+      }
+      var tmpfile = getTmpname(filename);
+      if (!options.mode || !options.chown) {
+        try {
+          var stats = fs.statSync(filename);
+          options = Object.assign({}, options);
+          if (!options.mode) {
+            options.mode = stats.mode;
+          }
+          if (!options.chown && process.getuid) {
+            options.chown = { uid: stats.uid, gid: stats.gid };
+          }
+        } catch (ex) {
+        }
+      }
+      var fd;
+      var cleanup = cleanupOnExit(tmpfile);
+      var removeOnExitHandler = onExit(cleanup);
+      try {
+        fd = fs.openSync(tmpfile, "w", options.mode);
+        if (Buffer.isBuffer(data)) {
+          fs.writeSync(fd, data, 0, data.length, 0);
+        } else if (data != null) {
+          fs.writeSync(fd, String(data), 0, String(options.encoding || "utf8"));
+        }
+        if (options.fsync !== false) {
+          fs.fsyncSync(fd);
+        }
+        fs.closeSync(fd);
+        if (options.chown)
+          fs.chownSync(tmpfile, options.chown.uid, options.chown.gid);
+        if (options.mode)
+          fs.chmodSync(tmpfile, options.mode);
+        fs.renameSync(tmpfile, filename);
+        removeOnExitHandler();
+      } catch (err) {
+        if (fd) {
+          try {
+            fs.closeSync(fd);
+          } catch (ex) {
+          }
+        }
+        removeOnExitHandler();
+        cleanup();
+        throw err;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/is-plain-obj@1.1.0/node_modules/is-plain-obj/index.js
+var require_is_plain_obj = __commonJS({
+  "../../node_modules/.pnpm/is-plain-obj@1.1.0/node_modules/is-plain-obj/index.js"(exports, module) {
+    "use strict";
+    var toString = Object.prototype.toString;
+    module.exports = function(x) {
+      var prototype;
+      return toString.call(x) === "[object Object]" && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/sort-keys@1.1.2/node_modules/sort-keys/index.js
+var require_sort_keys = __commonJS({
+  "../../node_modules/.pnpm/sort-keys@1.1.2/node_modules/sort-keys/index.js"(exports, module) {
+    "use strict";
+    var isPlainObj = require_is_plain_obj();
+    module.exports = function(obj, opts) {
+      if (!isPlainObj(obj)) {
+        throw new TypeError("Expected a plain object");
+      }
+      opts = opts || {};
+      if (typeof opts === "function") {
+        opts = { compare: opts };
+      }
+      var deep = opts.deep;
+      var seenInput = [];
+      var seenOutput = [];
+      var sortKeys = function(x) {
+        var seenIndex = seenInput.indexOf(x);
+        if (seenIndex !== -1) {
+          return seenOutput[seenIndex];
+        }
+        var ret = {};
+        var keys = Object.keys(x).sort(opts.compare);
+        seenInput.push(x);
+        seenOutput.push(ret);
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var val = x[key];
+          ret[key] = deep && isPlainObj(val) ? sortKeys(val) : val;
+        }
+        return ret;
+      };
+      return sortKeys(obj);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/pify@3.0.0/node_modules/pify/index.js
+var require_pify2 = __commonJS({
+  "../../node_modules/.pnpm/pify@3.0.0/node_modules/pify/index.js"(exports, module) {
+    "use strict";
+    var processFn = (fn, opts) => function() {
+      const P = opts.promiseModule;
+      const args = new Array(arguments.length);
+      for (let i = 0; i < arguments.length; i++) {
+        args[i] = arguments[i];
+      }
+      return new P((resolve, reject) => {
+        if (opts.errorFirst) {
+          args.push(function(err, result) {
+            if (opts.multiArgs) {
+              const results = new Array(arguments.length - 1);
+              for (let i = 1; i < arguments.length; i++) {
+                results[i - 1] = arguments[i];
+              }
+              if (err) {
+                results.unshift(err);
+                reject(results);
+              } else {
+                resolve(results);
+              }
+            } else if (err) {
+              reject(err);
+            } else {
+              resolve(result);
+            }
+          });
+        } else {
+          args.push(function(result) {
+            if (opts.multiArgs) {
+              const results = new Array(arguments.length - 1);
+              for (let i = 0; i < arguments.length; i++) {
+                results[i] = arguments[i];
+              }
+              resolve(results);
+            } else {
+              resolve(result);
+            }
+          });
+        }
+        fn.apply(this, args);
+      });
+    };
+    module.exports = (obj, opts) => {
+      opts = Object.assign({
+        exclude: [/.+(Sync|Stream)$/],
+        errorFirst: true,
+        promiseModule: Promise
+      }, opts);
+      const filter = (key) => {
+        const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+        return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+      };
+      let ret;
+      if (typeof obj === "function") {
+        ret = function() {
+          if (opts.excludeMain) {
+            return obj.apply(this, arguments);
+          }
+          return processFn(obj, opts).apply(this, arguments);
+        };
+      } else {
+        ret = Object.create(Object.getPrototypeOf(obj));
+      }
+      for (const key in obj) {
+        const x = obj[key];
+        ret[key] = typeof x === "function" && filter(key) ? processFn(x, opts) : x;
+      }
+      return ret;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/make-dir@1.3.0/node_modules/make-dir/index.js
+var require_make_dir = __commonJS({
+  "../../node_modules/.pnpm/make-dir@1.3.0/node_modules/make-dir/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var pify = require_pify2();
+    var defaults = {
+      mode: 511 & ~process.umask(),
+      fs
+    };
+    var checkPath = (pth) => {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const err = new Error(`Path contains invalid characters: ${pth}`);
+          err.code = "EINVAL";
+          throw err;
+        }
+      }
+    };
+    module.exports = (input, opts) => Promise.resolve().then(() => {
+      checkPath(input);
+      opts = Object.assign({}, defaults, opts);
+      const mkdir = pify(opts.fs.mkdir);
+      const stat = pify(opts.fs.stat);
+      const make = (pth) => {
+        return mkdir(pth, opts.mode).then(() => pth).catch((err) => {
+          if (err.code === "ENOENT") {
+            if (err.message.includes("null bytes") || path.dirname(pth) === pth) {
+              throw err;
+            }
+            return make(path.dirname(pth)).then(() => make(pth));
+          }
+          return stat(pth).then((stats) => stats.isDirectory() ? pth : Promise.reject()).catch(() => {
+            throw err;
+          });
+        });
+      };
+      return make(path.resolve(input));
+    });
+    module.exports.sync = (input, opts) => {
+      checkPath(input);
+      opts = Object.assign({}, defaults, opts);
+      const make = (pth) => {
+        try {
+          opts.fs.mkdirSync(pth, opts.mode);
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            if (err.message.includes("null bytes") || path.dirname(pth) === pth) {
+              throw err;
+            }
+            make(path.dirname(pth));
+            return make(pth);
+          }
+          try {
+            if (!opts.fs.statSync(pth).isDirectory()) {
+              throw new Error("The path is not a directory");
+            }
+          } catch (_) {
+            throw err;
+          }
+        }
+        return pth;
+      };
+      return make(path.resolve(input));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-indent@5.0.0/node_modules/detect-indent/index.js
+var require_detect_indent = __commonJS({
+  "../../node_modules/.pnpm/detect-indent@5.0.0/node_modules/detect-indent/index.js"(exports, module) {
+    "use strict";
+    var INDENT_RE = /^(?:( )+|\t+)/;
+    function getMostUsed(indents) {
+      let result = 0;
+      let maxUsed = 0;
+      let maxWeight = 0;
+      for (const entry of indents) {
+        const key = entry[0];
+        const val = entry[1];
+        const u = val[0];
+        const w = val[1];
+        if (u > maxUsed || u === maxUsed && w > maxWeight) {
+          maxUsed = u;
+          maxWeight = w;
+          result = Number(key);
+        }
+      }
+      return result;
+    }
+    module.exports = (str) => {
+      if (typeof str !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      let tabs = 0;
+      let spaces = 0;
+      let prev = 0;
+      const indents = /* @__PURE__ */ new Map();
+      let current;
+      let isIndent;
+      for (const line of str.split(/\n/g)) {
+        if (!line) {
+          continue;
+        }
+        let indent2;
+        const matches = line.match(INDENT_RE);
+        if (matches) {
+          indent2 = matches[0].length;
+          if (matches[1]) {
+            spaces++;
+          } else {
+            tabs++;
+          }
+        } else {
+          indent2 = 0;
+        }
+        const diff = indent2 - prev;
+        prev = indent2;
+        if (diff) {
+          isIndent = diff > 0;
+          current = indents.get(isIndent ? diff : -diff);
+          if (current) {
+            current[0]++;
+          } else {
+            current = [1, 0];
+            indents.set(diff, current);
+          }
+        } else if (current) {
+          current[1] += Number(isIndent);
+        }
+      }
+      const amount = getMostUsed(indents);
+      let type;
+      let indent;
+      if (!amount) {
+        type = null;
+        indent = "";
+      } else if (spaces >= tabs) {
+        type = "space";
+        indent = " ".repeat(amount);
+      } else {
+        type = "tab";
+        indent = "	".repeat(amount);
+      }
+      return {
+        amount,
+        type,
+        indent
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/write-json-file@2.2.0/node_modules/write-json-file/index.js
+var require_write_json_file = __commonJS({
+  "../../node_modules/.pnpm/write-json-file@2.2.0/node_modules/write-json-file/index.js"(exports, module) {
+    "use strict";
+    var path = __require("path");
+    var fs = require_graceful_fs();
+    var writeFileAtomic = require_write_file_atomic();
+    var sortKeys = require_sort_keys();
+    var makeDir = require_make_dir();
+    var pify = require_pify();
+    var detectIndent = require_detect_indent();
+    var init = (fn, fp, data, opts) => {
+      if (!fp) {
+        throw new TypeError("Expected a filepath");
+      }
+      if (data === void 0) {
+        throw new TypeError("Expected data to stringify");
+      }
+      opts = Object.assign({
+        indent: "	",
+        sortKeys: false
+      }, opts);
+      if (opts.sortKeys) {
+        data = sortKeys(data, {
+          deep: true,
+          compare: typeof opts.sortKeys === "function" && opts.sortKeys
+        });
+      }
+      return fn(fp, data, opts);
+    };
+    var readFile = (fp) => pify(fs.readFile)(fp, "utf8").catch(() => {
+    });
+    var main = (fp, data, opts) => {
+      return (opts.detectIndent ? readFile(fp) : Promise.resolve()).then((str) => {
+        const indent = str ? detectIndent(str).indent : opts.indent;
+        const json = JSON.stringify(data, opts.replacer, indent);
+        return pify(writeFileAtomic)(fp, `${json}
+`, { mode: opts.mode });
+      });
+    };
+    var mainSync = (fp, data, opts) => {
+      let indent = opts.indent;
+      if (opts.detectIndent) {
+        try {
+          const file = fs.readFileSync(fp, "utf8");
+          indent = detectIndent(file).indent;
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            throw err;
+          }
+        }
+      }
+      const json = JSON.stringify(data, opts.replacer, indent);
+      return writeFileAtomic.sync(fp, `${json}
+`, { mode: opts.mode });
+    };
+    module.exports = (fp, data, opts) => {
+      return makeDir(path.dirname(fp), { fs }).then(() => init(main, fp, data, opts));
+    };
+    module.exports.sync = (fp, data, opts) => {
+      makeDir.sync(path.dirname(fp), { fs });
+      init(mainSync, fp, data, opts);
+    };
+  }
+});
+
+// src/util/telemetry/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import os from "os";
+var import_constants = __toESM(require_dist(), 1);
+import { spawn } from "child_process";
+import { cloneEnv } from "@vercel/build-utils";
+
+// src/util/telemetry/session.ts
+var import_load_json_file = __toESM(require_load_json_file(), 1);
+var import_write_json_file = __toESM(require_write_json_file(), 1);
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+var DEFAULT_CLI_SESSION_INACTIVITY_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_CLI_SESSION_MAX_LIFETIME_MS = 24 * 60 * 60 * 1e3;
+function isPersistedCliSession(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const session = value;
+  return typeof session.id === "string" && typeof session.createdAt === "number" && Number.isFinite(session.createdAt) && typeof session.lastSeenAt === "number" && Number.isFinite(session.lastSeenAt);
+}
+function isPersistedCliDevice(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const device = value;
+  return typeof device.id === "string";
+}
+function readPersistedCliSession(filePath) {
+  try {
+    const session = import_load_json_file.default.sync(filePath);
+    return isPersistedCliSession(session) ? session : null;
+  } catch {
+    return null;
+  }
+}
+function writePersistedCliSession(filePath, session) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    import_write_json_file.default.sync(filePath, session, { indent: 2 });
+  } catch {
+  }
+}
+function readPersistedCliDevice(filePath) {
+  try {
+    const device = import_load_json_file.default.sync(filePath);
+    return isPersistedCliDevice(device) ? device : null;
+  } catch {
+    return null;
+  }
+}
+function writePersistedCliDevice(filePath, device) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    import_write_json_file.default.sync(filePath, device, { indent: 2 });
+  } catch {
+  }
+}
+function getOrCreatePersistedCliSession(opts) {
+  const now = opts.now?.() ?? Date.now();
+  const inactivityTimeoutMs = opts.inactivityTimeoutMs ?? DEFAULT_CLI_SESSION_INACTIVITY_TIMEOUT_MS;
+  const maxLifetimeMs = opts.maxLifetimeMs ?? DEFAULT_CLI_SESSION_MAX_LIFETIME_MS;
+  const existing = readPersistedCliSession(opts.filePath);
+  const shouldReuseExisting = existing && now - existing.lastSeenAt <= inactivityTimeoutMs && now - existing.createdAt <= maxLifetimeMs;
+  const session = shouldReuseExisting ? {
+    ...existing,
+    lastSeenAt: now
+  } : {
+    id: randomUUID(),
+    createdAt: now,
+    lastSeenAt: now
+  };
+  writePersistedCliSession(opts.filePath, session);
+  return session;
+}
+function touchPersistedCliSession(opts, session) {
+  const nextSession = {
+    ...session,
+    lastSeenAt: opts.now?.() ?? Date.now()
+  };
+  writePersistedCliSession(opts.filePath, nextSession);
+  return nextSession;
+}
+function getOrCreatePersistedCliDevice(opts) {
+  const existing = readPersistedCliDevice(opts.filePath);
+  if (existing) {
+    return existing;
+  }
+  const device = {
+    id: randomUUID()
+  };
+  writePersistedCliDevice(opts.filePath, device);
+  return device;
+}
+
+// src/util/telemetry/index.ts
+var LogLabel = `['telemetry']:`;
+var MAX_ERROR_SERVER_MESSAGE_LENGTH = 500;
+var TelemetryClient = class {
+  constructor({ opts }) {
+    this.redactedValue = "[REDACTED]";
+    this.noValueToTriggerPrompt = "[TRIGGER_PROMPT]";
+    this.redactedArgumentsLength = (args) => {
+      if (args && args.length === 1) {
+        return "ONE";
+      }
+      if (args.length > 1) {
+        return "MANY";
+      }
+      return "NONE";
+    };
+    this.redactedTargetName = (target) => {
+      if (import_constants.PROJECT_ENV_TARGET.includes(target)) {
+        return target;
+      }
+      return this.redactedValue;
+    };
+    this.isDebug = opts.isDebug || false;
+    this.store = opts.store;
+  }
+  track(eventData) {
+    if (this.isDebug) {
+      output_manager_default.debug(`${LogLabel} ${eventData.key}:${eventData.value}`);
+    }
+    const event = {
+      id: randomUUID2(),
+      eventTime: Date.now(),
+      ...eventData
+    };
+    this.store.add(event);
+  }
+  trackCliCommand(eventData) {
+    this.track({
+      key: `command:${eventData.command}`,
+      value: eventData.value
+    });
+  }
+  trackCliSubcommand(eventData) {
+    this.track({
+      key: `subcommand:${eventData.subcommand}`,
+      value: eventData.value
+    });
+  }
+  trackCliArgument(eventData) {
+    if (eventData.value) {
+      this.track({
+        key: `argument:${eventData.arg}`,
+        value: eventData.value
+      });
+    }
+  }
+  trackCliOption(eventData) {
+    this.track({
+      key: `option:${eventData.option}`,
+      value: eventData.value
+    });
+  }
+  trackTargetEnvironment(targetEnvironment) {
+    this.track({
+      key: "target_environment",
+      value: targetEnvironment
+    });
+  }
+  trackCommandOutput(eventData) {
+    this.track({
+      key: `output:${eventData.key}`,
+      value: eventData.value
+    });
+  }
+  trackCliFlag(flag) {
+    this.track({
+      key: `flag:${flag}`,
+      value: "TRUE"
+    });
+  }
+  trackOidcTokenRefresh(count) {
+    this.track({
+      key: "oidc-token-refresh",
+      value: `${count}`
+    });
+  }
+  trackCPUs() {
+    this.track({
+      key: "cpu_count",
+      value: String(os.cpus().length)
+    });
+  }
+  trackAgenticUse(agent) {
+    if (agent) {
+      this.track({
+        key: "agent",
+        value: agent
+      });
+    }
+  }
+  trackPlatform() {
+    this.track({
+      key: "platform",
+      value: os.platform()
+    });
+  }
+  trackArch() {
+    this.track({
+      key: "arch",
+      value: os.arch()
+    });
+  }
+  trackCI(ciVendorName) {
+    if (ciVendorName) {
+      this.track({
+        key: "ci",
+        value: ciVendorName
+      });
+    }
+  }
+  trackStdinIsTTY(isTTY) {
+    this.track({
+      key: "stdin_is_tty",
+      value: isTTY ? "true" : "false"
+    });
+  }
+  trackVersion(version) {
+    if (version) {
+      this.track({
+        key: "version",
+        value: version
+      });
+    }
+  }
+  trackDefaultDeploy() {
+    this.track({
+      key: "default-deploy",
+      value: "TRUE"
+    });
+  }
+  trackProjectId(projectId) {
+    if (projectId) {
+      this.track({
+        key: "project_id",
+        value: projectId
+      });
+    }
+  }
+  trackInvocationId(invocationId) {
+    if (invocationId) {
+      this.track({
+        key: "invocation_id",
+        value: invocationId
+      });
+    }
+  }
+  trackDeviceId(deviceId) {
+    if (deviceId) {
+      this.track({
+        key: "device_id",
+        value: deviceId
+      });
+    }
+  }
+  trackVercelPluginActiveSession() {
+    this.track({
+      key: "vercel_plugin_active_session",
+      value: "TRUE"
+    });
+  }
+  trackVercelPluginVersion(version) {
+    if (version) {
+      this.track({
+        key: "vercel_plugin_version",
+        value: version
+      });
+    }
+  }
+  trackErrorStatus(status) {
+    if (typeof status !== "undefined") {
+      this.track({
+        key: "error_status",
+        value: String(status)
+      });
+    }
+  }
+  trackErrorCode(code) {
+    if (code) {
+      this.track({
+        key: "error_code",
+        value: code
+      });
+    }
+  }
+  trackErrorSlug(slug) {
+    if (slug) {
+      this.track({
+        key: "error_slug",
+        value: slug
+      });
+    }
+  }
+  trackErrorAction(action) {
+    if (action) {
+      this.track({
+        key: "error_action",
+        value: action
+      });
+    }
+  }
+  trackErrorServerMessage(serverMessage) {
+    if (serverMessage) {
+      const normalizedServerMessage = serverMessage.trim().replace(/\s+/g, " ");
+      this.track({
+        key: "error_server_message",
+        value: normalizedServerMessage.slice(
+          0,
+          MAX_ERROR_SERVER_MESSAGE_LENGTH
+        )
+      });
+    }
+  }
+  trackExtension() {
+    this.track({
+      key: "extension",
+      value: this.redactedValue
+    });
+  }
+  trackLoginState(state) {
+    if (state === "started")
+      this.loginAttempt = randomUUID2();
+    if (this.loginAttempt) {
+      this.track({ key: `login:attempt:${this.loginAttempt}`, value: state });
+    }
+    if (state !== "started")
+      this.loginAttempt = void 0;
+  }
+  trackCliFlagHelp(command, subcommands) {
+    let subcommand;
+    if (subcommands) {
+      subcommand = Array.isArray(subcommands) ? subcommands[0] : subcommands;
+    }
+    this.track({
+      key: "flag:help",
+      value: subcommand ? `${command}:${subcommand}` : command
+    });
+  }
+  /**
+   * Tracks the --format option for JSON output.
+   * This is a common option across many commands, so it's defined in the base class.
+   */
+  trackCliOptionFormat(format) {
+    if (format) {
+      const allowedFormat = ["json"].includes(format) ? format : this.redactedValue;
+      this.trackCliOption({
+        option: "format",
+        value: allowedFormat
+      });
+    }
+  }
+  /**
+   * Tracks the --project option. Value is redacted because project names/IDs
+   * may be sensitive. Accepts `string | string[]` so commands with a repeatable
+   * `--project` can override. Not all commands support repeated `--project` flags
+   */
+  trackCliOptionProject(value) {
+    if (!value)
+      return;
+    if (Array.isArray(value) && value.length === 0)
+      return;
+    this.trackCliOption({
+      option: "project",
+      value: this.redactedValue
+    });
+  }
+};
+var TelemetryEventStore = class {
+  constructor(opts) {
+    this.teamId = "NO_TEAM_ID";
+    this.userId = "NO_USER_ID";
+    this.projectId = "NO_PROJECT_ID";
+    this.isDebug = opts?.isDebug || false;
+    this.events = [];
+    this.config = opts?.config;
+    this.cliDeviceOptions = opts?.cliDevice;
+    this.cliSessionOptions = opts?.cliSession;
+    this.invocationId = randomUUID2();
+    this.deviceId = randomUUID2();
+    if (this.cliDeviceOptions) {
+      this.cliDevice = getOrCreatePersistedCliDevice(this.cliDeviceOptions);
+      this.deviceId = this.cliDevice.id;
+    }
+    if (this.cliSessionOptions) {
+      this.cliSession = getOrCreatePersistedCliSession(this.cliSessionOptions);
+      this.sessionId = this.cliSession.id;
+    } else {
+      this.sessionId = randomUUID2();
+    }
+  }
+  add(event) {
+    event.sessionId = this.sessionId;
+    event.teamId = this.teamId;
+    event.userId = this.userId;
+    event.projectId = this.projectId;
+    this.events.push(event);
+  }
+  updateTeamId(teamId) {
+    if (teamId) {
+      this.teamId = teamId;
+    }
+  }
+  updateUserId(userId) {
+    if (userId) {
+      this.userId = userId;
+    }
+  }
+  updateProjectId(projectId) {
+    if (projectId) {
+      this.projectId = projectId;
+    }
+  }
+  get hasUserId() {
+    return this.userId !== "NO_USER_ID";
+  }
+  get currentProjectId() {
+    return this.projectId;
+  }
+  get currentInvocationId() {
+    return this.invocationId;
+  }
+  get currentDeviceId() {
+    return this.deviceId;
+  }
+  get currentSessionId() {
+    return this.sessionId;
+  }
+  get readonlyEvents() {
+    return Array.from(this.events);
+  }
+  reset() {
+    this.events = [];
+  }
+  get enabled() {
+    if (process.env.VERCEL_TELEMETRY_DISABLED) {
+      return false;
+    }
+    return this.config?.enabled ?? true;
+  }
+  async save() {
+    if (this.cliSession && this.cliSessionOptions) {
+      this.cliSession = touchPersistedCliSession(
+        this.cliSessionOptions,
+        this.cliSession
+      );
+    }
+    if (this.isDebug) {
+      output_manager_default.log(`${LogLabel} Flushing Events`);
+      for (const event of this.events) {
+        event.teamId = this.teamId;
+        event.userId = this.userId;
+        event.projectId = this.projectId;
+        output_manager_default.log(JSON.stringify(event));
+      }
+      return;
+    }
+    if (this.enabled) {
+      const sessionId = this.events[0].sessionId;
+      if (!sessionId) {
+        output_manager_default.debug("Unable to send metrics: no session ID");
+        return;
+      }
+      const events = this.events.map((event) => {
+        delete event.sessionId;
+        delete event.teamId;
+        delete event.userId;
+        delete event.projectId;
+        const { eventTime, ...rest } = event;
+        return {
+          event_time: eventTime,
+          team_id: this.teamId,
+          user_id: this.userId,
+          project_id: this.projectId,
+          ...rest
+        };
+      });
+      const payload = {
+        headers: {
+          "Client-id": "vercel-cli",
+          "x-vercel-cli-topic-id": "generic",
+          "x-vercel-cli-session-id": sessionId
+        },
+        body: events
+      };
+      await this.sendToSubprocess(payload, output_manager_default.debugEnabled);
+    }
+  }
+  /**
+   * Send the telemetry events to a subprocess, this invokes the `telemetry flush` command
+   * and passes a stringified payload to the subprocess, there's a risk that if the event payload
+   * increases in size, it may exceed the maximum buffer size for the subprocess, in which case the
+   * child process will error and not send anything.
+   * FIXME: handle max buffer size
+   */
+  async sendToSubprocess(payload, outputDebugEnabled) {
+    const flushArgs = ["telemetry", "flush", JSON.stringify(payload)];
+    let nodeBinaryPath;
+    let script;
+    if (isNativeBinaryInstall()) {
+      nodeBinaryPath = process.execPath;
+      script = flushArgs;
+    } else {
+      const args = [process.execPath, process.argv[0], process.argv[1]];
+      if (args[0] === args[1]) {
+        args.shift();
+      }
+      nodeBinaryPath = args[0];
+      script = [...args.slice(1), ...flushArgs];
+    }
+    const env = cloneEnv(process.env, {
+      VERCEL_TELEMETRY_DISABLED: "1"
+    });
+    if (outputDebugEnabled) {
+      return new Promise((resolve) => {
+        const childProcess = spawn(nodeBinaryPath, script, {
+          env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        childProcess.stderr.on("data", (data) => output_manager_default.debug(data.toString()));
+        childProcess.stdout.on("data", (data) => output_manager_default.debug(data.toString()));
+        childProcess.on("error", (d) => {
+          output_manager_default.debug(d);
+        });
+        const timeout = setTimeout(() => {
+          output_manager_default.debug("Telemetry subprocess killed due to timeout");
+          childProcess.kill();
+        }, 2e3);
+        childProcess.on("exit", (code) => {
+          output_manager_default.debug(`Telemetry subprocess exited with code ${code}`);
+          childProcess.unref();
+          timeout.unref();
+          resolve();
+        });
+      });
+    } else {
+      const childProcess = spawn(nodeBinaryPath, script, {
+        stdio: "ignore",
+        env,
+        windowsHide: true,
+        detached: true
+      });
+      childProcess.unref();
+    }
+  }
+};
+
+export {
+  require_dist,
+  TelemetryClient,
+  TelemetryEventStore
+};
+/*! Bundled license information:
+
+imurmurhash/imurmurhash.js:
+  (**
+   * @preserve
+   * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
+   *
+   * @author <a href="mailto:jensyt@gmail.com">Jens Taylor</a>
+   * @see http://github.com/homebrewing/brauhaus-diff
+   * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+   * @see http://github.com/garycourt/murmurhash-js
+   * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+   * @see http://sites.google.com/site/murmurhash/
+   *)
+*/