@powerhousedao/shared 6.0.0-dev.228 → 6.0.0-dev.230

package/dist/clis/services/telemetry.d.mts

@@ -0,0 +1,40 @@
+//#region clis/services/telemetry.d.ts
+/**
+ * Prompts the user once, caches the answer. Must be called before init.
+ * Returns `true` if telemetry should be enabled, `false` otherwise.
+ */
+declare function resolveTelemetryConsent(): Promise<boolean>;
+/**
+ * Initializes Sentry for CLI error reporting if telemetry is enabled.
+ * Safe to call multiple times; only the first call takes effect.
+ */
+declare function initCliTelemetry(opts: {
+  cliName: "ph-cli" | "ph-cmd";
+  release?: string;
+}): Promise<void>;
+/**
+ * Captures an error (if telemetry is initialized) and flushes before the
+ * caller calls process.exit(). Safe no-op when telemetry is disabled.
+ */
+declare function captureCliError(err: unknown): Promise<void>;
+/**
+ * Explicitly set telemetry consent (used by `ph telemetry on|off`).
+ */
+declare function setTelemetryConsent(enabled: boolean): void;
+/**
+ * Returns the current telemetry state — useful for `ph telemetry status`.
+ */
+declare function getTelemetryStatus(): {
+  source: "env";
+  enabled: boolean;
+} | {
+  source: "config";
+  enabled: boolean;
+  askedAt: string;
+} | {
+  source: "default";
+  enabled: false;
+};
+//#endregion
+export { captureCliError, getTelemetryStatus, initCliTelemetry, resolveTelemetryConsent, setTelemetryConsent };
+//# sourceMappingURL=telemetry.d.mts.map

package/dist/clis/services/telemetry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.mts","names":[],"sources":["../../../clis/services/telemetry.ts"],"mappings":";;AA8EA;;;iBAAsB,uBAAA,CAAA,GAA2B,OAAA;;AAkHjD;;;iBAAsB,gBAAA,CAAiB,IAAA;EACrC,OAAA;EACA,OAAA;AAAA,IACE,OAAA;;;;AAkCJ;iBAAsB,eAAA,CAAgB,GAAA,YAAe,OAAA;;;;iBAcrC,mBAAA,CAAoB,OAAA;;;;iBAOpB,kBAAA,CAAA;EACV,MAAA;EAAe,OAAA;AAAA;EACf,MAAA;EAAkB,OAAA;EAAkB,OAAA;AAAA;EACpC,MAAA;EAAmB,OAAA;AAAA"}

package/dist/clis/services/telemetry.mjs

@@ -0,0 +1,185 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region clis/services/telemetry.ts
+/**
+* CLI telemetry (error reporting via Sentry).
+*
+* Design:
+* - Opt-out by default, asked once on first interactive run.
+* - Stores consent in ~/.ph/telemetry.json so we never ask twice.
+* - Respects PH_NO_TELEMETRY=1 and DO_NOT_TRACK=1 as immediate kill switches.
+* - Non-interactive (TTY missing, CI, piped) defaults to DISABLED — we don't
+*   want to hang a CI pipeline on an unanswered prompt, and we don't want to
+*   capture errors without informed consent.
+* - DSN is published in the CLI binary; Sentry DSNs accept events but grant
+*   no read access, so this is safe. Hardcoded so users can't accidentally
+*   misroute events.
+*
+* PII scrubbing in beforeSend hook:
+* - Home-directory paths collapsed to ~
+* - Flag/arg values that look like secrets (tokens, keys) stripped
+* - No source-context from user files
+*/
+const SENTRY_DSN = "https://0e7793802288589b4923896118374462@sentry.monitoring.vetra.io/3";
+const TELEMETRY_FILE = join(homedir(), ".ph", "telemetry.json");
+function isExplicitlyDisabled() {
+	return process.env.PH_NO_TELEMETRY === "1" || process.env.PH_NO_TELEMETRY === "true" || process.env.DO_NOT_TRACK === "1" || process.env.DO_NOT_TRACK === "true";
+}
+function isExplicitlyEnabled() {
+	return process.env.PH_TELEMETRY === "1" || process.env.PH_TELEMETRY === "true";
+}
+function isInteractive() {
+	return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function readConfig() {
+	try {
+		if (!existsSync(TELEMETRY_FILE)) return null;
+		return JSON.parse(readFileSync(TELEMETRY_FILE, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function writeConfig(cfg) {
+	try {
+		mkdirSync(join(homedir(), ".ph"), { recursive: true });
+		writeFileSync(TELEMETRY_FILE, JSON.stringify(cfg, null, 2));
+	} catch {}
+}
+/**
+* Prompts the user once, caches the answer. Must be called before init.
+* Returns `true` if telemetry should be enabled, `false` otherwise.
+*/
+async function resolveTelemetryConsent() {
+	if (isExplicitlyDisabled()) return false;
+	if (isExplicitlyEnabled()) return true;
+	const cached = readConfig();
+	if (cached) return cached.enabled;
+	if (!isInteractive()) return false;
+	const enquirer = await import("enquirer");
+	try {
+		const { enabled } = await enquirer.default.prompt({
+			type: "confirm",
+			name: "enabled",
+			message: "Help improve Powerhouse by sending anonymous error reports? (stack traces only, paths and secrets are scrubbed)",
+			initial: true
+		});
+		writeConfig({
+			enabled,
+			askedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return enabled;
+	} catch {
+		return false;
+	}
+}
+function scrubString(input) {
+	if (!input) return input;
+	const home = homedir();
+	let out = input;
+	if (home && out.includes(home)) out = out.split(home).join("~");
+	out = out.replace(/(--?(?:token|api[-_]?key|password|secret|auth)[=\s])([^\s]+)/gi, "$1<redacted>");
+	return out;
+}
+function scrubEvent(event) {
+	const e = event;
+	try {
+		if (e.message) e.message = scrubString(e.message);
+		if (e.logentry?.message) e.logentry.message = scrubString(e.logentry.message);
+		const values = e.exception?.values;
+		if (Array.isArray(values)) for (const ex of values) {
+			if (ex.value) ex.value = scrubString(ex.value);
+			const frames = ex.stacktrace?.frames;
+			if (Array.isArray(frames)) for (const f of frames) {
+				if (f.filename) f.filename = scrubString(f.filename);
+				if (f.abs_path) f.abs_path = scrubString(f.abs_path);
+				delete f.pre_context;
+				delete f.context_line;
+				delete f.post_context;
+				delete f.vars;
+			}
+		}
+		delete e.server_name;
+		if (e.extra) {
+			delete e.extra.argv;
+			delete e.extra.env;
+		}
+	} catch {}
+	return event;
+}
+let initialized = false;
+/**
+* Initializes Sentry for CLI error reporting if telemetry is enabled.
+* Safe to call multiple times; only the first call takes effect.
+*/
+async function initCliTelemetry(opts) {
+	if (initialized) return;
+	if (!await resolveTelemetryConsent()) return;
+	const Sentry = await import("@sentry/node");
+	Sentry.init({
+		dsn: SENTRY_DSN,
+		release: opts.release,
+		environment: process.env.NODE_ENV || "production",
+		sendDefaultPii: false,
+		defaultIntegrations: false,
+		integrations: [],
+		beforeSend(event) {
+			return scrubEvent(event);
+		},
+		beforeBreadcrumb(breadcrumb) {
+			if (breadcrumb.message) breadcrumb.message = scrubString(breadcrumb.message);
+			return breadcrumb;
+		}
+	});
+	Sentry.setTag("cli_name", opts.cliName);
+	if (opts.release) Sentry.setTag("cli_version", opts.release);
+	initialized = true;
+}
+/**
+* Captures an error (if telemetry is initialized) and flushes before the
+* caller calls process.exit(). Safe no-op when telemetry is disabled.
+*/
+async function captureCliError(err) {
+	if (!initialized) return;
+	try {
+		const Sentry = await import("@sentry/node");
+		Sentry.captureException(err);
+		await Sentry.flush(2e3);
+	} catch {}
+}
+/**
+* Explicitly set telemetry consent (used by `ph telemetry on|off`).
+*/
+function setTelemetryConsent(enabled) {
+	writeConfig({
+		enabled,
+		askedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/**
+* Returns the current telemetry state — useful for `ph telemetry status`.
+*/
+function getTelemetryStatus() {
+	if (isExplicitlyDisabled()) return {
+		source: "env",
+		enabled: false
+	};
+	if (isExplicitlyEnabled()) return {
+		source: "env",
+		enabled: true
+	};
+	const cached = readConfig();
+	if (cached) return {
+		source: "config",
+		enabled: cached.enabled,
+		askedAt: cached.askedAt
+	};
+	return {
+		source: "default",
+		enabled: false
+	};
+}
+//#endregion
+export { captureCliError, getTelemetryStatus, initCliTelemetry, resolveTelemetryConsent, setTelemetryConsent };
+
+//# sourceMappingURL=telemetry.mjs.map

package/dist/clis/services/telemetry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.mjs","names":[],"sources":["../../../clis/services/telemetry.ts"],"sourcesContent":["/**\n * CLI telemetry (error reporting via Sentry).\n *\n * Design:\n * - Opt-out by default, asked once on first interactive run.\n * - Stores consent in ~/.ph/telemetry.json so we never ask twice.\n * - Respects PH_NO_TELEMETRY=1 and DO_NOT_TRACK=1 as immediate kill switches.\n * - Non-interactive (TTY missing, CI, piped) defaults to DISABLED — we don't\n *   want to hang a CI pipeline on an unanswered prompt, and we don't want to\n *   capture errors without informed consent.\n * - DSN is published in the CLI binary; Sentry DSNs accept events but grant\n *   no read access, so this is safe. Hardcoded so users can't accidentally\n *   misroute events.\n *\n * PII scrubbing in beforeSend hook:\n * - Home-directory paths collapsed to ~\n * - Flag/arg values that look like secrets (tokens, keys) stripped\n * - No source-context from user files\n */\nimport { readFileSync, writeFileSync, mkdirSync, existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { homedir } from \"node:os\";\n\n// Sentry project \"ph-cli\" on the powerhouse-hosted Sentry instance.\n// Public DSNs are safe to ship — they grant write-only ingest access.\nconst SENTRY_DSN =\n  \"https://0e7793802288589b4923896118374462@sentry.monitoring.vetra.io/3\";\n\nconst TELEMETRY_FILE = join(homedir(), \".ph\", \"telemetry.json\");\n\ntype TelemetryConfig = {\n  enabled: boolean;\n  askedAt: string;\n};\n\nfunction isExplicitlyDisabled(): boolean {\n  // Standard opt-out signals respected by most OSS CLIs.\n  return (\n    process.env.PH_NO_TELEMETRY === \"1\" ||\n    process.env.PH_NO_TELEMETRY === \"true\" ||\n    process.env.DO_NOT_TRACK === \"1\" ||\n    process.env.DO_NOT_TRACK === \"true\"\n  );\n}\n\nfunction isExplicitlyEnabled(): boolean {\n  return (\n    process.env.PH_TELEMETRY === \"1\" || process.env.PH_TELEMETRY === \"true\"\n  );\n}\n\nfunction isInteractive(): boolean {\n  // Only ask if stdin is a TTY and CI env isn't set.\n  return Boolean(process.stdin.isTTY) && !process.env.CI;\n}\n\nfunction readConfig(): TelemetryConfig | null {\n  try {\n    if (!existsSync(TELEMETRY_FILE)) return null;\n    return JSON.parse(readFileSync(TELEMETRY_FILE, \"utf8\")) as TelemetryConfig;\n  } catch {\n    return null;\n  }\n}\n\nfunction writeConfig(cfg: TelemetryConfig): void {\n  try {\n    mkdirSync(join(homedir(), \".ph\"), { recursive: true });\n    writeFileSync(TELEMETRY_FILE, JSON.stringify(cfg, null, 2));\n  } catch {\n    // non-fatal; we'll just ask again next time\n  }\n}\n\n/**\n * Prompts the user once, caches the answer. Must be called before init.\n * Returns `true` if telemetry should be enabled, `false` otherwise.\n */\nexport async function resolveTelemetryConsent(): Promise<boolean> {\n  if (isExplicitlyDisabled()) return false;\n  if (isExplicitlyEnabled()) return true;\n\n  const cached = readConfig();\n  if (cached) return cached.enabled;\n\n  if (!isInteractive()) {\n    // Non-interactive first run: stay silent, don't ask, don't send. User can\n    // opt in later with `ph telemetry on` or PH_TELEMETRY=1.\n    return false;\n  }\n\n  const enquirer = await import(\"enquirer\");\n  try {\n    const { enabled } = await enquirer.default.prompt<{ enabled: boolean }>({\n      type: \"confirm\",\n      name: \"enabled\",\n      message:\n        \"Help improve Powerhouse by sending anonymous error reports? \" +\n        \"(stack traces only, paths and secrets are scrubbed)\",\n      initial: true,\n    });\n    writeConfig({ enabled, askedAt: new Date().toISOString() });\n    return enabled;\n  } catch {\n    // user hit Ctrl-C during prompt — treat as no, but don't persist so we\n    // ask again next time\n    return false;\n  }\n}\n\nfunction scrubString(input: string): string {\n  if (!input) return input;\n  const home = homedir();\n  let out = input;\n  // Collapse home dir to ~\n  if (home && out.includes(home)) {\n    out = out.split(home).join(\"~\");\n  }\n  // Strip common secret-shaped flag values: --token=XYZ, --api-key XYZ, etc.\n  out = out.replace(\n    /(--?(?:token|api[-_]?key|password|secret|auth)[=\\s])([^\\s]+)/gi,\n    \"$1<redacted>\",\n  );\n  return out;\n}\n\ntype ScrubbableFrame = {\n  filename?: string;\n  abs_path?: string;\n  pre_context?: unknown;\n  context_line?: unknown;\n  post_context?: unknown;\n  vars?: unknown;\n};\n\ntype ScrubbableException = {\n  value?: string;\n  stacktrace?: { frames?: ScrubbableFrame[] };\n};\n\ntype ScrubbableEvent = {\n  message?: string;\n  logentry?: { message?: string };\n  exception?: { values?: ScrubbableException[] };\n  server_name?: string;\n  extra?: Record<string, unknown>;\n};\n\nfunction scrubEvent<T>(event: T): T {\n  const e = event as ScrubbableEvent;\n  try {\n    if (e.message) e.message = scrubString(e.message);\n    if (e.logentry?.message) {\n      e.logentry.message = scrubString(e.logentry.message);\n    }\n    const values = e.exception?.values;\n    if (Array.isArray(values)) {\n      for (const ex of values) {\n        if (ex.value) ex.value = scrubString(ex.value);\n        const frames = ex.stacktrace?.frames;\n        if (Array.isArray(frames)) {\n          for (const f of frames) {\n            if (f.filename) f.filename = scrubString(f.filename);\n            if (f.abs_path) f.abs_path = scrubString(f.abs_path);\n            // Drop captured source context from user machines — privacy.\n            delete f.pre_context;\n            delete f.context_line;\n            delete f.post_context;\n            delete f.vars;\n          }\n        }\n      }\n    }\n    // Server name can leak the user's machine hostname; drop it.\n    delete e.server_name;\n    // Strip raw argv from extra context.\n    if (e.extra) {\n      delete e.extra.argv;\n      delete e.extra.env;\n    }\n  } catch {\n    // Never let scrubbing throw — worst case we drop the event below.\n  }\n  return event;\n}\n\nlet initialized = false;\n\n/**\n * Initializes Sentry for CLI error reporting if telemetry is enabled.\n * Safe to call multiple times; only the first call takes effect.\n */\nexport async function initCliTelemetry(opts: {\n  cliName: \"ph-cli\" | \"ph-cmd\";\n  release?: string;\n}): Promise<void> {\n  if (initialized) return;\n  const enabled = await resolveTelemetryConsent();\n  if (!enabled) return;\n\n  const Sentry = await import(\"@sentry/node\");\n  Sentry.init({\n    dsn: SENTRY_DSN,\n    release: opts.release,\n    environment: process.env.NODE_ENV || \"production\",\n    sendDefaultPii: false,\n    defaultIntegrations: false,\n    integrations: [\n      // Only the bare minimum — no automatic HTTP/FS instrumentation.\n    ],\n    beforeSend(event) {\n      return scrubEvent(event);\n    },\n    beforeBreadcrumb(breadcrumb) {\n      if (breadcrumb.message) {\n        breadcrumb.message = scrubString(breadcrumb.message);\n      }\n      return breadcrumb;\n    },\n  });\n  Sentry.setTag(\"cli_name\", opts.cliName);\n  if (opts.release) Sentry.setTag(\"cli_version\", opts.release);\n  initialized = true;\n}\n\n/**\n * Captures an error (if telemetry is initialized) and flushes before the\n * caller calls process.exit(). Safe no-op when telemetry is disabled.\n */\nexport async function captureCliError(err: unknown): Promise<void> {\n  if (!initialized) return;\n  try {\n    const Sentry = await import(\"@sentry/node\");\n    Sentry.captureException(err);\n    await Sentry.flush(2000);\n  } catch {\n    // Reporting must never mask the real error.\n  }\n}\n\n/**\n * Explicitly set telemetry consent (used by `ph telemetry on|off`).\n */\nexport function setTelemetryConsent(enabled: boolean): void {\n  writeConfig({ enabled, askedAt: new Date().toISOString() });\n}\n\n/**\n * Returns the current telemetry state — useful for `ph telemetry status`.\n */\nexport function getTelemetryStatus():\n  | { source: \"env\"; enabled: boolean }\n  | { source: \"config\"; enabled: boolean; askedAt: string }\n  | { source: \"default\"; enabled: false } {\n  if (isExplicitlyDisabled()) return { source: \"env\", enabled: false };\n  if (isExplicitlyEnabled()) return { source: \"env\", enabled: true };\n  const cached = readConfig();\n  if (cached)\n    return {\n      source: \"config\",\n      enabled: cached.enabled,\n      askedAt: cached.askedAt,\n    };\n  return { source: \"default\", enabled: false };\n}\n"],"mappings":"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"}

package/dist/clis/utils.d.mts

@@ -0,0 +1,9 @@
+//#region clis/utils.d.ts
+declare class NodeVersionError extends Error {
+  constructor(currentVersion: string, minimumVersion: string);
+  static isError(error: unknown): error is NodeVersionError;
+}
+declare function assertNodeVersion(nodeVersion?: string): void;
+//#endregion
+export { NodeVersionError, assertNodeVersion };
+//# sourceMappingURL=utils.d.mts.map

package/dist/clis/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../clis/utils.ts"],"mappings":";cAIa,gBAAA,SAAyB,KAAA;cACxB,cAAA,UAAwB,cAAA;EAAA,OAO7B,OAAA,CAAQ,KAAA,YAAiB,KAAA,IAAS,gBAAA;AAAA;AAAA,iBAK3B,iBAAA,CAAkB,WAAA"}

package/dist/clis/utils.mjs

@@ -0,0 +1,373 @@
+import { MINIMUM_NODE_VERSION } from "./constants.mjs";
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js
+var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SEMVER_SPEC_VERSION = "2.0.0";
+	const MAX_LENGTH = 256;
+	const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+	module.exports = {
+		MAX_LENGTH,
+		MAX_SAFE_COMPONENT_LENGTH: 16,
+		MAX_SAFE_BUILD_LENGTH: MAX_LENGTH - 6,
+		MAX_SAFE_INTEGER,
+		RELEASE_TYPES: [
+			"major",
+			"premajor",
+			"minor",
+			"preminor",
+			"patch",
+			"prepatch",
+			"prerelease"
+		],
+		SEMVER_SPEC_VERSION,
+		FLAG_INCLUDE_PRERELEASE: 1,
+		FLAG_LOOSE: 2
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js
+var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
+	const debug = require_debug();
+	exports = module.exports = {};
+	const re = exports.re = [];
+	const safeRe = exports.safeRe = [];
+	const src = exports.src = [];
+	const safeSrc = exports.safeSrc = [];
+	const t = exports.t = {};
+	let R = 0;
+	const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+	const safeRegexReplacements = [
+		["\\s", 1],
+		["\\d", MAX_LENGTH],
+		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+	];
+	const makeSafeRegex = (value) => {
+		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+		return value;
+	};
+	const createToken = (name, value, isGlobal) => {
+		const safe = makeSafeRegex(value);
+		const index = R++;
+		debug(name, index, value);
+		t[name] = index;
+		src[index] = value;
+		safeSrc[index] = safe;
+		re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+	};
+	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+	createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+	createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+	createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+	createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+	createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+	createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+	createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+	createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+	createToken("GTLT", "((?:<|>)?=?)");
+	createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+	createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+	createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+	createToken("COERCERTL", src[t.COERCE], true);
+	createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+	createToken("LONETILDE", "(?:~>?)");
+	createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+	exports.tildeTrimReplace = "$1~";
+	createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+	createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("LONECARET", "(?:\\^)");
+	createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+	exports.caretTrimReplace = "$1^";
+	createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+	createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+	createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+	createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+	exports.comparatorTrimReplace = "$1$2$3";
+	createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+	createToken("STAR", "(<|>)?=?\\s*\\*");
+	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js
+var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const looseOption = Object.freeze({ loose: true });
+	const emptyOpts = Object.freeze({});
+	const parseOptions = (options) => {
+		if (!options) return emptyOpts;
+		if (typeof options !== "object") return looseOption;
+		return options;
+	};
+	module.exports = parseOptions;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js
+var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const numeric = /^[0-9]+$/;
+	const compareIdentifiers = (a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+		const anum = numeric.test(a);
+		const bnum = numeric.test(b);
+		if (anum && bnum) {
+			a = +a;
+			b = +b;
+		}
+		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+	};
+	const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+	module.exports = {
+		compareIdentifiers,
+		rcompareIdentifiers
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js
+var require_semver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const debug = require_debug();
+	const { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+	const { safeRe: re, t } = require_re();
+	const parseOptions = require_parse_options();
+	const { compareIdentifiers } = require_identifiers();
+	module.exports = class SemVer {
+		constructor(version, options) {
+			options = parseOptions(options);
+			if (version instanceof SemVer) if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
+			else version = version.version;
+			else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+			debug("SemVer", version, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+			if (!m) throw new TypeError(`Invalid Version: ${version}`);
+			this.raw = version;
+			this.major = +m[1];
+			this.minor = +m[2];
+			this.patch = +m[3];
+			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
+			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
+			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
+			if (!m[4]) this.prerelease = [];
+			else this.prerelease = m[4].split(".").map((id) => {
+				if (/^[0-9]+$/.test(id)) {
+					const num = +id;
+					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+				}
+				return id;
+			});
+			this.build = m[5] ? m[5].split(".") : [];
+			this.format();
+		}
+		format() {
+			this.version = `${this.major}.${this.minor}.${this.patch}`;
+			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+			return this.version;
+		}
+		toString() {
+			return this.version;
+		}
+		compare(other) {
+			debug("SemVer.compare", this.version, this.options, other);
+			if (!(other instanceof SemVer)) {
+				if (typeof other === "string" && other === this.version) return 0;
+				other = new SemVer(other, this.options);
+			}
+			if (other.version === this.version) return 0;
+			return this.compareMain(other) || this.comparePre(other);
+		}
+		compareMain(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.major < other.major) return -1;
+			if (this.major > other.major) return 1;
+			if (this.minor < other.minor) return -1;
+			if (this.minor > other.minor) return 1;
+			if (this.patch < other.patch) return -1;
+			if (this.patch > other.patch) return 1;
+			return 0;
+		}
+		comparePre(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.prerelease.length && !other.prerelease.length) return -1;
+			else if (!this.prerelease.length && other.prerelease.length) return 1;
+			else if (!this.prerelease.length && !other.prerelease.length) return 0;
+			let i = 0;
+			do {
+				const a = this.prerelease[i];
+				const b = other.prerelease[i];
+				debug("prerelease compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		compareBuild(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			let i = 0;
+			do {
+				const a = this.build[i];
+				const b = other.build[i];
+				debug("build compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		inc(release, identifier, identifierBase) {
+			if (release.startsWith("pre")) {
+				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
+				if (identifier) {
+					const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
+				}
+			}
+			switch (release) {
+				case "premajor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor = 0;
+					this.major++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "preminor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prepatch":
+					this.prerelease.length = 0;
+					this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prerelease":
+					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "release":
+					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
+					this.prerelease.length = 0;
+					break;
+				case "major":
+					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+					this.minor = 0;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "minor":
+					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "patch":
+					if (this.prerelease.length === 0) this.patch++;
+					this.prerelease = [];
+					break;
+				case "pre": {
+					const base = Number(identifierBase) ? 1 : 0;
+					if (this.prerelease.length === 0) this.prerelease = [base];
+					else {
+						let i = this.prerelease.length;
+						while (--i >= 0) if (typeof this.prerelease[i] === "number") {
+							this.prerelease[i]++;
+							i = -2;
+						}
+						if (i === -1) {
+							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
+							this.prerelease.push(base);
+						}
+					}
+					if (identifier) {
+						let prerelease = [identifier, base];
+						if (identifierBase === false) prerelease = [identifier];
+						if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+							if (isNaN(this.prerelease[1])) this.prerelease = prerelease;
+						} else this.prerelease = prerelease;
+					}
+					break;
+				}
+				default: throw new Error(`invalid increment argument: ${release}`);
+			}
+			this.raw = this.format();
+			if (this.build.length) this.raw += `+${this.build.join(".")}`;
+			return this;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js
+var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const SemVer = require_semver();
+	const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+	module.exports = compare;
+}));
+//#endregion
+//#region clis/utils.ts
+var import_lt = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const compare = require_compare();
+	const lt = (a, b, loose) => compare(a, b, loose) < 0;
+	module.exports = lt;
+})))(), 1);
+var NodeVersionError = class extends Error {
+	constructor(currentVersion, minimumVersion) {
+		super(`Node version ${minimumVersion} or higher is required. Current version: ${currentVersion}`);
+		this.name = "NodeVersionError";
+	}
+	static isError(error) {
+		return error instanceof Error && error.name === "NodeVersionError";
+	}
+};
+function assertNodeVersion(nodeVersion = process.versions.node) {
+	if (!nodeVersion) return;
+	if ((0, import_lt.default)(nodeVersion, "24.0.0")) throw new NodeVersionError(nodeVersion, MINIMUM_NODE_VERSION);
+}
+//#endregion
+export { NodeVersionError, assertNodeVersion };
+
+//# sourceMappingURL=utils.mjs.map