@flowdular/sdk 0.1.0

package/packages/sandbox/dist/server/assets/token-util-CktFFT4z.js

@@ -0,0 +1,494 @@
+import { createRequire } from "node:module";
+//#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), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/token-error.js
+var require_token_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var token_error_exports = {};
+	__export(token_error_exports, { VercelOidcTokenError: () => VercelOidcTokenError });
+	module.exports = __toCommonJS(token_error_exports);
+	var VercelOidcTokenError = class extends Error {
+		constructor(message, cause) {
+			super(message);
+			this.name = "VercelOidcTokenError";
+			this.cause = cause;
+		}
+		toString() {
+			if (this.cause) return `${this.name}: ${this.message}: ${this.cause}`;
+			return `${this.name}: ${this.message}`;
+		}
+	};
+	0 && (module.exports = { VercelOidcTokenError });
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/auth-errors.js
+var require_auth_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var auth_errors_exports = {};
+	__export(auth_errors_exports, {
+		AccessTokenMissingError: () => AccessTokenMissingError,
+		RefreshAccessTokenFailedError: () => RefreshAccessTokenFailedError
+	});
+	module.exports = __toCommonJS(auth_errors_exports);
+	var AccessTokenMissingError = class extends Error {
+		constructor() {
+			super("No authentication found. Please log in with the Vercel CLI (vercel login).");
+			this.name = "AccessTokenMissingError";
+		}
+	};
+	var RefreshAccessTokenFailedError = class extends Error {
+		constructor(cause) {
+			super("Failed to refresh authentication token.", { cause });
+			this.name = "RefreshAccessTokenFailedError";
+		}
+	};
+	0 && (module.exports = {
+		AccessTokenMissingError,
+		RefreshAccessTokenFailedError
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/token-io.js
+var require_token_io = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var token_io_exports = {};
+	__export(token_io_exports, {
+		findRootDir: () => findRootDir,
+		getUserDataDir: () => getUserDataDir
+	});
+	module.exports = __toCommonJS(token_io_exports);
+	var import_path = __toESM(__require("path"));
+	var import_fs = __toESM(__require("fs"));
+	var import_os$1 = __toESM(__require("os"));
+	var import_token_error = require_token_error();
+	function findRootDir() {
+		try {
+			let dir = process.cwd();
+			while (dir !== import_path.default.dirname(dir)) {
+				const pkgPath = import_path.default.join(dir, ".vercel");
+				if (import_fs.default.existsSync(pkgPath)) return dir;
+				dir = import_path.default.dirname(dir);
+			}
+		} catch (e) {
+			throw new import_token_error.VercelOidcTokenError("Token refresh only supported in node server environments");
+		}
+		return null;
+	}
+	function getUserDataDir() {
+		if (process.env.XDG_DATA_HOME) return process.env.XDG_DATA_HOME;
+		switch (import_os$1.default.platform()) {
+			case "darwin": return import_path.default.join(import_os$1.default.homedir(), "Library/Application Support");
+			case "linux": return import_path.default.join(import_os$1.default.homedir(), ".local/share");
+			case "win32":
+				if (process.env.LOCALAPPDATA) return process.env.LOCALAPPDATA;
+				return null;
+			default: return null;
+		}
+	}
+	0 && (module.exports = {
+		findRootDir,
+		getUserDataDir
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/auth-config.js
+var require_auth_config = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var auth_config_exports = {};
+	__export(auth_config_exports, {
+		isValidAccessToken: () => isValidAccessToken,
+		readAuthConfig: () => readAuthConfig,
+		writeAuthConfig: () => writeAuthConfig
+	});
+	module.exports = __toCommonJS(auth_config_exports);
+	var fs$1 = __toESM(__require("fs"));
+	var path$1 = __toESM(__require("path"));
+	var import_token_util = require_token_util();
+	function getAuthConfigPath() {
+		const dataDir = (0, import_token_util.getVercelDataDir)();
+		if (!dataDir) throw new Error(`Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`);
+		return path$1.join(dataDir, "auth.json");
+	}
+	function readAuthConfig() {
+		try {
+			const authPath = getAuthConfigPath();
+			if (!fs$1.existsSync(authPath)) return null;
+			const content = fs$1.readFileSync(authPath, "utf8");
+			if (!content) return null;
+			return JSON.parse(content);
+		} catch (error) {
+			return null;
+		}
+	}
+	function writeAuthConfig(config) {
+		const authPath = getAuthConfigPath();
+		const authDir = path$1.dirname(authPath);
+		if (!fs$1.existsSync(authDir)) fs$1.mkdirSync(authDir, {
+			mode: 504,
+			recursive: true
+		});
+		fs$1.writeFileSync(authPath, JSON.stringify(config, null, 2), { mode: 384 });
+	}
+	function isValidAccessToken(authConfig, expirationBufferMs = 0) {
+		if (!authConfig.token) return false;
+		if (typeof authConfig.expiresAt !== "number") return true;
+		const nowInSeconds = Math.floor(Date.now() / 1e3);
+		const bufferInSeconds = expirationBufferMs / 1e3;
+		return authConfig.expiresAt >= nowInSeconds + bufferInSeconds;
+	}
+	0 && (module.exports = {
+		isValidAccessToken,
+		readAuthConfig,
+		writeAuthConfig
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/oauth.js
+var require_oauth = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var oauth_exports = {};
+	__export(oauth_exports, {
+		processTokenResponse: () => processTokenResponse,
+		refreshTokenRequest: () => refreshTokenRequest
+	});
+	module.exports = __toCommonJS(oauth_exports);
+	var import_os = __require("os");
+	var VERCEL_ISSUER = "https://vercel.com";
+	var VERCEL_CLI_CLIENT_ID = "cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp";
+	var userAgent = `@vercel/oidc node-${process.version} ${(0, import_os.platform)()} (${(0, import_os.arch)()}) ${(0, import_os.hostname)()}`;
+	var _tokenEndpoint = null;
+	async function getTokenEndpoint() {
+		if (_tokenEndpoint) return _tokenEndpoint;
+		const response = await fetch(`${VERCEL_ISSUER}/.well-known/openid-configuration`, { headers: { "user-agent": userAgent } });
+		if (!response.ok) throw new Error("Failed to discover OAuth endpoints");
+		const metadata = await response.json();
+		if (!metadata || typeof metadata.token_endpoint !== "string") throw new Error("Invalid OAuth discovery response");
+		const endpoint = metadata.token_endpoint;
+		_tokenEndpoint = endpoint;
+		return endpoint;
+	}
+	async function refreshTokenRequest(options) {
+		const tokenEndpoint = await getTokenEndpoint();
+		return await fetch(tokenEndpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				"user-agent": userAgent
+			},
+			body: new URLSearchParams({
+				client_id: VERCEL_CLI_CLIENT_ID,
+				grant_type: "refresh_token",
+				...options
+			})
+		});
+	}
+	async function processTokenResponse(response) {
+		const json = await response.json();
+		if (!response.ok) {
+			const errorMsg = typeof json === "object" && json && "error" in json ? String(json.error) : "Token refresh failed";
+			return [new Error(errorMsg)];
+		}
+		if (typeof json !== "object" || json === null) return [/* @__PURE__ */ new Error("Invalid token response")];
+		if (typeof json.access_token !== "string") return [/* @__PURE__ */ new Error("Missing access_token in response")];
+		if (json.token_type !== "Bearer") return [/* @__PURE__ */ new Error("Invalid token_type in response")];
+		if (typeof json.expires_in !== "number") return [/* @__PURE__ */ new Error("Missing expires_in in response")];
+		return [null, json];
+	}
+	0 && (module.exports = {
+		processTokenResponse,
+		refreshTokenRequest
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/token-util.js
+var require_token_util = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var token_util_exports = {};
+	__export(token_util_exports, {
+		assertVercelOidcTokenResponse: () => assertVercelOidcTokenResponse,
+		findProjectInfo: () => findProjectInfo,
+		getTokenPayload: () => getTokenPayload,
+		getVercelDataDir: () => getVercelDataDir,
+		getVercelOidcToken: () => getVercelOidcToken,
+		getVercelToken: () => getVercelToken,
+		isExpired: () => isExpired,
+		loadToken: () => loadToken,
+		saveToken: () => saveToken
+	});
+	module.exports = __toCommonJS(token_util_exports);
+	var path = __toESM(__require("path"));
+	var fs = __toESM(__require("fs"));
+	var import_token_error = require_token_error();
+	var import_token_io = require_token_io();
+	var import_auth_config = require_auth_config();
+	var import_oauth = require_oauth();
+	var import_auth_errors = require_auth_errors();
+	function getVercelDataDir() {
+		const vercelFolder = "com.vercel.cli";
+		const dataDir = (0, import_token_io.getUserDataDir)();
+		if (!dataDir) return null;
+		return path.join(dataDir, vercelFolder);
+	}
+	async function getVercelToken(options) {
+		const authConfig = (0, import_auth_config.readAuthConfig)();
+		if (!authConfig?.token) throw new import_auth_errors.AccessTokenMissingError();
+		if ((0, import_auth_config.isValidAccessToken)(authConfig, options?.expirationBufferMs)) return authConfig.token;
+		if (!authConfig.refreshToken) {
+			(0, import_auth_config.writeAuthConfig)({});
+			throw new import_auth_errors.RefreshAccessTokenFailedError("No refresh token available");
+		}
+		try {
+			const tokenResponse = await (0, import_oauth.refreshTokenRequest)({ refresh_token: authConfig.refreshToken });
+			const [tokensError, tokens] = await (0, import_oauth.processTokenResponse)(tokenResponse);
+			if (tokensError || !tokens) {
+				(0, import_auth_config.writeAuthConfig)({});
+				throw new import_auth_errors.RefreshAccessTokenFailedError(tokensError);
+			}
+			const updatedConfig = {
+				token: tokens.access_token,
+				expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in
+			};
+			if (tokens.refresh_token) updatedConfig.refreshToken = tokens.refresh_token;
+			(0, import_auth_config.writeAuthConfig)(updatedConfig);
+			return updatedConfig.token;
+		} catch (error) {
+			(0, import_auth_config.writeAuthConfig)({});
+			if (error instanceof import_auth_errors.AccessTokenMissingError || error instanceof import_auth_errors.RefreshAccessTokenFailedError) throw error;
+			throw new import_auth_errors.RefreshAccessTokenFailedError(error);
+		}
+	}
+	async function getVercelOidcToken(authToken, projectId, teamId) {
+		const url = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${authToken}` }
+		});
+		if (!res.ok) throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token: ${res.statusText}`);
+		const tokenRes = await res.json();
+		assertVercelOidcTokenResponse(tokenRes);
+		return tokenRes;
+	}
+	function assertVercelOidcTokenResponse(res) {
+		if (!res || typeof res !== "object") throw new TypeError("Vercel OIDC token is malformed. Expected an object. Please run `vc env pull` and try again");
+		if (!("token" in res) || typeof res.token !== "string") throw new TypeError("Vercel OIDC token is malformed. Expected a string-valued token property. Please run `vc env pull` and try again");
+	}
+	function findProjectInfo() {
+		const dir = (0, import_token_io.findRootDir)();
+		if (!dir) throw new import_token_error.VercelOidcTokenError("Unable to find project root directory. Have you linked your project with `vc link?`");
+		const prjPath = path.join(dir, ".vercel", "project.json");
+		if (!fs.existsSync(prjPath)) throw new import_token_error.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");
+		const prj = JSON.parse(fs.readFileSync(prjPath, "utf8"));
+		if (typeof prj.projectId !== "string" && typeof prj.orgId !== "string") throw new TypeError("Expected a string-valued projectId property. Try running `vc link` to re-link your project.");
+		return {
+			projectId: prj.projectId,
+			teamId: prj.orgId
+		};
+	}
+	function saveToken(token, projectId) {
+		const dir = (0, import_token_io.getUserDataDir)();
+		if (!dir) throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
+		const tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+		const tokenJson = JSON.stringify(token);
+		fs.mkdirSync(path.dirname(tokenPath), {
+			mode: 504,
+			recursive: true
+		});
+		fs.writeFileSync(tokenPath, tokenJson);
+		fs.chmodSync(tokenPath, 432);
+	}
+	function loadToken(projectId) {
+		const dir = (0, import_token_io.getUserDataDir)();
+		if (!dir) throw new import_token_error.VercelOidcTokenError("Unable to find user data directory. Please reach out to Vercel support.");
+		const tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+		if (!fs.existsSync(tokenPath)) return null;
+		const token = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+		assertVercelOidcTokenResponse(token);
+		return token;
+	}
+	function getTokenPayload(token) {
+		const tokenParts = token.split(".");
+		if (tokenParts.length !== 3) throw new import_token_error.VercelOidcTokenError("Invalid token. Please run `vc env pull` and try again");
+		const base64 = tokenParts[1].replace(/-/g, "+").replace(/_/g, "/");
+		const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
+		return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+	}
+	function isExpired(token, bufferMs = 0) {
+		return token.exp * 1e3 < Date.now() + bufferMs;
+	}
+	0 && (module.exports = {
+		assertVercelOidcTokenResponse,
+		findProjectInfo,
+		getTokenPayload,
+		getVercelDataDir,
+		getVercelOidcToken,
+		getVercelToken,
+		isExpired,
+		loadToken,
+		saveToken
+	});
+}));
+//#endregion
+export { __exportAll as a, __commonJSMin as i, require_auth_errors as n, __require as o, require_token_error as r, __toESM as s, require_token_util as t };