n8n-nodes-vercel-ai-sdk-universal-temp 0.2.35 → 0.2.37

package/node_modules/@vercel/oidc/dist/token-io.js

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var 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 = __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"
+    );
+  }
+  throw new import_token_error.VercelOidcTokenError("Unable to find root directory");
+}
+function getUserDataDir() {
+  if (process.env.XDG_DATA_HOME) {
+    return process.env.XDG_DATA_HOME;
+  }
+  switch (import_os.default.platform()) {
+    case "darwin":
+      return import_path.default.join(import_os.default.homedir(), "Library/Application Support");
+    case "linux":
+      return import_path.default.join(import_os.default.homedir(), ".local/share");
+    case "win32":
+      if (process.env.LOCALAPPDATA) {
+        return process.env.LOCALAPPDATA;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findRootDir,
+  getUserDataDir
+});

package/node_modules/@vercel/oidc/dist/token-util.d.ts

@@ -0,0 +1,21 @@
+export declare function getVercelDataDir(): string | null;
+export declare function getVercelCliToken(): string | null;
+interface VercelTokenResponse {
+    token: string;
+}
+export declare function getVercelOidcToken(authToken: string, projectId: string, teamId?: string): Promise<VercelTokenResponse | null>;
+export declare function assertVercelOidcTokenResponse(res: unknown): asserts res is VercelTokenResponse;
+export declare function findProjectInfo(): {
+    projectId: string;
+    teamId: string;
+};
+export declare function saveToken(token: VercelTokenResponse, projectId: string): void;
+export declare function loadToken(projectId: string): VercelTokenResponse | null;
+interface TokenPayload {
+    sub: string;
+    name: string;
+    exp: number;
+}
+export declare function getTokenPayload(token: string): TokenPayload;
+export declare function isExpired(token: TokenPayload): boolean;
+export {};

package/node_modules/@vercel/oidc/dist/token-util.js

@@ -0,0 +1,177 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var token_util_exports = {};
+__export(token_util_exports, {
+  assertVercelOidcTokenResponse: () => assertVercelOidcTokenResponse,
+  findProjectInfo: () => findProjectInfo,
+  getTokenPayload: () => getTokenPayload,
+  getVercelCliToken: () => getVercelCliToken,
+  getVercelDataDir: () => getVercelDataDir,
+  getVercelOidcToken: () => getVercelOidcToken,
+  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");
+function getVercelDataDir() {
+  const vercelFolder = "com.vercel.cli";
+  const dataDir = (0, import_token_io.getUserDataDir)();
+  if (!dataDir) {
+    return null;
+  }
+  return path.join(dataDir, vercelFolder);
+}
+function getVercelCliToken() {
+  const dataDir = getVercelDataDir();
+  if (!dataDir) {
+    return null;
+  }
+  const tokenPath = path.join(dataDir, "auth.json");
+  if (!fs.existsSync(tokenPath)) {
+    return null;
+  }
+  const token = fs.readFileSync(tokenPath, "utf8");
+  if (!token) {
+    return null;
+  }
+  return JSON.parse(token).token;
+}
+async function getVercelOidcToken(authToken, projectId, teamId) {
+  try {
+    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;
+  } catch (e) {
+    throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token`, e);
+  }
+}
+function assertVercelOidcTokenResponse(res) {
+  if (!res || typeof res !== "object") {
+    throw new TypeError("Expected an object");
+  }
+  if (!("token" in res) || typeof res.token !== "string") {
+    throw new TypeError("Expected a string-valued token property");
+  }
+}
+function findProjectInfo() {
+  const dir = (0, import_token_io.findRootDir)();
+  if (!dir) {
+    throw new import_token_error.VercelOidcTokenError("Unable to find root directory");
+  }
+  try {
+    const prjPath = path.join(dir, ".vercel", "project.json");
+    if (!fs.existsSync(prjPath)) {
+      throw new import_token_error.VercelOidcTokenError("project.json not found");
+    }
+    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");
+    }
+    return { projectId: prj.projectId, teamId: prj.orgId };
+  } catch (e) {
+    throw new import_token_error.VercelOidcTokenError(`Unable to find project ID`, e);
+  }
+}
+function saveToken(token, projectId) {
+  try {
+    const dir = (0, import_token_io.getUserDataDir)();
+    if (!dir) {
+      throw new import_token_error.VercelOidcTokenError("Unable to find user data directory");
+    }
+    const tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+    const tokenJson = JSON.stringify(token);
+    fs.mkdirSync(path.dirname(tokenPath), { mode: 432, recursive: true });
+    fs.writeFileSync(tokenPath, tokenJson);
+    fs.chmodSync(tokenPath, 432);
+    return;
+  } catch (e) {
+    throw new import_token_error.VercelOidcTokenError(`Failed to save token`, e);
+  }
+}
+function loadToken(projectId) {
+  try {
+    const dir = (0, import_token_io.getUserDataDir)();
+    if (!dir) {
+      return null;
+    }
+    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;
+  } catch (e) {
+    throw new import_token_error.VercelOidcTokenError(`Failed to load token`, e);
+  }
+}
+function getTokenPayload(token) {
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    throw new import_token_error.VercelOidcTokenError("Invalid token");
+  }
+  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"));
+}
+const TIME_15_MINUTES_IN_MS = 15 * 60 * 1e3;
+function isExpired(token) {
+  return token.exp * 1e3 < Date.now() + TIME_15_MINUTES_IN_MS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertVercelOidcTokenResponse,
+  findProjectInfo,
+  getTokenPayload,
+  getVercelCliToken,
+  getVercelDataDir,
+  getVercelOidcToken,
+  isExpired,
+  loadToken,
+  saveToken
+});

package/node_modules/@vercel/oidc/dist/token.d.ts

@@ -0,0 +1 @@
+export declare function refreshToken(): Promise<void>;

package/node_modules/@vercel/oidc/dist/token.js

@@ -0,0 +1,53 @@
+"use strict";
+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_exports = {};
+__export(token_exports, {
+  refreshToken: () => refreshToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_token_error = require("./token-error");
+var import_token_util = require("./token-util");
+async function refreshToken() {
+  const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
+  let maybeToken = (0, import_token_util.loadToken)(projectId);
+  if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
+    const authToken = (0, import_token_util.getVercelCliToken)();
+    if (!authToken) {
+      throw new import_token_error.VercelOidcTokenError(
+        "Failed to refresh OIDC token: login to vercel cli"
+      );
+    }
+    if (!projectId) {
+      throw new import_token_error.VercelOidcTokenError(
+        "Failed to refresh OIDC token: project id not found"
+      );
+    }
+    maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
+    if (!maybeToken) {
+      throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");
+    }
+    (0, import_token_util.saveToken)(maybeToken, projectId);
+  }
+  process.env.VERCEL_OIDC_TOKEN = maybeToken.token;
+  return;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  refreshToken
+});

package/node_modules/@vercel/oidc/dist/token.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@vercel/oidc/dist/token.test.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_crypto = require("crypto");
+var import_vitest = require("vitest");
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_token_io = require("./token-io");
+var tokenUtil = __toESM(require("./token-util"));
+var import_token = require("./token");
+import_vitest.vi.mock("./token-io");
+(0, import_vitest.describe)("refreshToken", () => {
+  let rootDir;
+  let userDataDir;
+  let cliDataDir;
+  let tokenDataDir;
+  const projectId = "test-project-id";
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    process.env.VERCEL_OIDC_TOKEN = void 0;
+    const random = `test-${(0, import_crypto.randomUUID)()}`;
+    rootDir = path.join(os.tmpdir(), random);
+    userDataDir = path.join(rootDir, "data");
+    cliDataDir = path.join(userDataDir, "com.vercel.cli");
+    tokenDataDir = path.join(userDataDir, "com.vercel.token");
+    fs.mkdirSync(cliDataDir, { recursive: true });
+    fs.mkdirSync(tokenDataDir, { recursive: true });
+    fs.mkdirSync(path.join(rootDir, ".vercel"), {
+      recursive: true
+    });
+    fs.writeFileSync(path.join(cliDataDir, "auth.json"), '{token: "test"}');
+    fs.writeFileSync(
+      path.join(rootDir, ".vercel", "project.json"),
+      JSON.stringify({ projectId })
+    );
+    import_vitest.vi.spyOn(process, "cwd").mockReturnValue(rootDir);
+    import_vitest.vi.mocked(import_token_io.findRootDir).mockReturnValue(rootDir);
+    import_vitest.vi.mocked(import_token_io.getUserDataDir).mockReturnValue(userDataDir);
+    import_vitest.vi.spyOn(tokenUtil, "getVercelCliToken").mockReturnValue("test");
+    import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
+      token: "test-token"
+    });
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: Date.now() + 1e5
+    });
+  });
+  (0, import_vitest.test)("should correctly load saved token from file", async () => {
+    const token = { token: "test-saved" };
+    const tokenPath = path.join(tokenDataDir, `${projectId}.json`);
+    fs.writeFileSync(tokenPath, JSON.stringify(token));
+    await (0, import_token.refreshToken)();
+    (0, import_vitest.expect)(process.env.VERCEL_OIDC_TOKEN).toBe("test-saved");
+  });
+  (0, import_vitest.test)("should correctly save token to file", async () => {
+    await (0, import_token.refreshToken)();
+    (0, import_vitest.expect)(process.env.VERCEL_OIDC_TOKEN).toBe("test-token");
+    const tokenPath = path.join(tokenDataDir, `${projectId}.json`);
+    const token = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+    (0, import_vitest.expect)(token).toEqual({ token: "test-token" });
+  });
+});

package/node_modules/@vercel/oidc/docs/README.md

@@ -0,0 +1,104 @@
+# @vercel/oidc
+
+## Table of contents
+
+### Functions
+
+- [getContext](README.md#getcontext)
+- [getVercelOidcToken](README.md#getverceloidctoken)
+- [getVercelOidcTokenSync](README.md#getverceloidctokensync)
+
+## Functions
+
+### getContext
+
+▸ **getContext**(): `Context`
+
+#### Returns
+
+`Context`
+
+#### Defined in
+
+[get-context.ts:7](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-context.ts#L7)
+
+---
+
+### getVercelOidcToken
+
+▸ **getVercelOidcToken**(): [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
+
+Gets the current OIDC token from the request context or the environment variable.
+
+Do not cache this value, as it is subject to change in production!
+
+This function is used to retrieve the OIDC token from the request context or the environment variable.
+It checks for the `x-vercel-oidc-token` header in the request context and falls back to the `VERCEL_OIDC_TOKEN` environment variable if the header is not present.
+
+Unlike the `getVercelOidcTokenSync` function, this function will refresh the token if it is expired in a development environment.
+
+**`Throws`**
+
+If the `x-vercel-oidc-token` header is missing from the request context and the environment variable `VERCEL_OIDC_TOKEN` is not set. If the token
+is expired in a development environment, will also throw an error if the token cannot be refreshed: no CLI credentials are available, CLI credentials are expired, no project configuration is available
+or the token refresh request fails.
+
+**`Example`**
+
+```js
+// Using the OIDC token
+getVercelOidcToken()
+  .then(token => {
+    console.log('OIDC Token:', token);
+  })
+  .catch(error => {
+    console.error('Error:', error.message);
+  });
+```
+
+#### Returns
+
+[`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
+
+A promise that resolves to the OIDC token.
+
+#### Defined in
+
+[get-vercel-oidc-token.ts:30](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L30)
+
+---
+
+### getVercelOidcTokenSync
+
+▸ **getVercelOidcTokenSync**(): `string`
+
+Gets the current OIDC token from the request context or the environment variable.
+
+Do not cache this value, as it is subject to change in production!
+
+This function is used to retrieve the OIDC token from the request context or the environment variable.
+It checks for the `x-vercel-oidc-token` header in the request context and falls back to the `VERCEL_OIDC_TOKEN` environment variable if the header is not present.
+
+This function will not refresh the token if it is expired. For refreshing the token, use the @{link getVercelOidcToken} function.
+
+**`Throws`**
+
+If the `x-vercel-oidc-token` header is missing from the request context and the environment variable `VERCEL_OIDC_TOKEN` is not set.
+
+**`Example`**
+
+```js
+// Using the OIDC token
+const token = getVercelOidcTokenSync();
+console.log('OIDC Token:', token);
+```
+
+#### Returns
+
+`string`
+
+The OIDC token.
+
+#### Defined in
+
+[get-vercel-oidc-token.ts:81](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L81)

package/node_modules/@vercel/oidc/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vercel/oidc",
+  "description": "Runtime OIDC helpers intended for use with Vercel Functions",
+  "homepage": "https://vercel.com",
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.md"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./dist/index-browser.js",
+      "react-native": "./dist/index-browser.js",
+      "workflow": "./dist/index-browser.js",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "version": "3.0.3",
+  "repository": {
+    "directory": "packages/oidc",
+    "type": "git",
+    "url": "git+https://github.com/vercel/vercel.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/vercel/issues"
+  },
+  "devDependencies": {
+    "tinyspawn": "1.3.1",
+    "typedoc": "0.24.6",
+    "typedoc-plugin-markdown": "4.1.2",
+    "typedoc-plugin-mdn-links": "3.2.3",
+    "typescript": "4.9.5",
+    "vitest": "2.0.1"
+  },
+  "peerDependenciesMeta": {},
+  "engines": {
+    "node": ">= 20"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "pretest": "pnpm run build:code",
+    "test": "vitest",
+    "build": "pnpm run build:code && pnpm run build:docs",
+    "build:code": "node ../../utils/build.mjs",
+    "build:docs": "typedoc && prettier --write docs/**/*.md docs/*.md"
+  }
+}