@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-XYV3VCIX.mjs

@@ -0,0 +1,336 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_token_error
+} from "./chunk-KWFOS5WC.mjs";
+import {
+  __commonJS,
+  __require
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/@vercel/oidc/dist/token-io.js
+var require_token_io = __commonJS({
+  "node_modules/@vercel/oidc/dist/token-io.js"(exports, module) {
+    "use strict";
+    var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames(from))
+          !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      return to;
+    }, __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: !0 }) : target,
+      mod
+    )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), token_io_exports = {};
+    __export(token_io_exports, {
+      findRootDir: () => findRootDir,
+      getUserDataDir: () => getUserDataDir
+    });
+    module.exports = __toCommonJS(token_io_exports);
+    var import_path = __toESM(__require("path")), import_fs = __toESM(__require("fs")), import_os = __toESM(__require("os")), import_token_error = require_token_error();
+    function findRootDir() {
+      try {
+        let dir = process.cwd();
+        for (; dir !== import_path.default.dirname(dir); ) {
+          let pkgPath = import_path.default.join(dir, ".vercel");
+          if (import_fs.default.existsSync(pkgPath))
+            return dir;
+          dir = import_path.default.dirname(dir);
+        }
+      } catch {
+        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.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":
+          return process.env.LOCALAPPDATA ? process.env.LOCALAPPDATA : null;
+        default:
+          return null;
+      }
+    }
+  }
+});
+
+// node_modules/@vercel/oidc/dist/auth-config.js
+var require_auth_config = __commonJS({
+  "node_modules/@vercel/oidc/dist/auth-config.js"(exports, module) {
+    "use strict";
+    var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames(from))
+          !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      return to;
+    }, __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: !0 }) : target,
+      mod
+    )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), auth_config_exports = {};
+    __export(auth_config_exports, {
+      isValidAccessToken: () => isValidAccessToken,
+      readAuthConfig: () => readAuthConfig,
+      writeAuthConfig: () => writeAuthConfig
+    });
+    module.exports = __toCommonJS(auth_config_exports);
+    var fs = __toESM(__require("fs")), path = __toESM(__require("path")), import_token_util = require_token_util();
+    function getAuthConfigPath() {
+      let 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.join(dataDir, "auth.json");
+    }
+    function readAuthConfig() {
+      try {
+        let authPath = getAuthConfigPath();
+        if (!fs.existsSync(authPath))
+          return null;
+        let content = fs.readFileSync(authPath, "utf8");
+        return content ? JSON.parse(content) : null;
+      } catch {
+        return null;
+      }
+    }
+    function writeAuthConfig(config) {
+      let authPath = getAuthConfigPath(), authDir = path.dirname(authPath);
+      fs.existsSync(authDir) || fs.mkdirSync(authDir, { mode: 504, recursive: !0 }), fs.writeFileSync(authPath, JSON.stringify(config, null, 2), { mode: 384 });
+    }
+    function isValidAccessToken(authConfig) {
+      if (!authConfig.token)
+        return !1;
+      if (typeof authConfig.expiresAt != "number")
+        return !0;
+      let nowInSeconds = Math.floor(Date.now() / 1e3);
+      return authConfig.expiresAt >= nowInSeconds;
+    }
+  }
+});
+
+// node_modules/@vercel/oidc/dist/oauth.js
+var require_oauth = __commonJS({
+  "node_modules/@vercel/oidc/dist/oauth.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames(from))
+          !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      return to;
+    }, __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), oauth_exports = {};
+    __export(oauth_exports, {
+      processTokenResponse: () => processTokenResponse,
+      refreshTokenRequest: () => refreshTokenRequest
+    });
+    module.exports = __toCommonJS(oauth_exports);
+    var import_os = __require("os"), VERCEL_ISSUER = "https://vercel.com", VERCEL_CLI_CLIENT_ID = "cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp", userAgent = `@vercel/oidc node-${process.version} ${(0, import_os.platform)()} (${(0, import_os.arch)()}) ${(0, import_os.hostname)()}`, _tokenEndpoint = null;
+    async function getTokenEndpoint() {
+      if (_tokenEndpoint)
+        return _tokenEndpoint;
+      let discoveryUrl = `${VERCEL_ISSUER}/.well-known/openid-configuration`, response = await fetch(discoveryUrl, {
+        headers: { "user-agent": userAgent }
+      });
+      if (!response.ok)
+        throw new Error("Failed to discover OAuth endpoints");
+      let metadata = await response.json();
+      if (!metadata || typeof metadata.token_endpoint != "string")
+        throw new Error("Invalid OAuth discovery response");
+      let endpoint = metadata.token_endpoint;
+      return _tokenEndpoint = endpoint, endpoint;
+    }
+    async function refreshTokenRequest(options) {
+      let 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) {
+      let json = await response.json();
+      if (!response.ok) {
+        let errorMsg = typeof json == "object" && json && "error" in json ? String(json.error) : "Token refresh failed";
+        return [new Error(errorMsg)];
+      }
+      return typeof json != "object" || json === null ? [new Error("Invalid token response")] : typeof json.access_token != "string" ? [new Error("Missing access_token in response")] : json.token_type !== "Bearer" ? [new Error("Invalid token_type in response")] : typeof json.expires_in != "number" ? [new Error("Missing expires_in in response")] : [null, json];
+    }
+  }
+});
+
+// node_modules/@vercel/oidc/dist/token-util.js
+var require_token_util = __commonJS({
+  "node_modules/@vercel/oidc/dist/token-util.js"(exports, module) {
+    var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames(from))
+          !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      return to;
+    }, __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: !0 }) : target,
+      mod
+    )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), 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")), fs = __toESM(__require("fs")), import_token_error = require_token_error(), import_token_io = require_token_io(), import_auth_config = require_auth_config(), import_oauth = require_oauth();
+    function getVercelDataDir() {
+      let vercelFolder = "com.vercel.cli", dataDir = (0, import_token_io.getUserDataDir)();
+      return dataDir ? path.join(dataDir, vercelFolder) : null;
+    }
+    async function getVercelCliToken() {
+      let authConfig = (0, import_auth_config.readAuthConfig)();
+      if (!authConfig)
+        return null;
+      if ((0, import_auth_config.isValidAccessToken)(authConfig))
+        return authConfig.token || null;
+      if (!authConfig.refreshToken)
+        return (0, import_auth_config.writeAuthConfig)({}), null;
+      try {
+        let tokenResponse = await (0, import_oauth.refreshTokenRequest)({
+          refresh_token: authConfig.refreshToken
+        }), [tokensError, tokens] = await (0, import_oauth.processTokenResponse)(tokenResponse);
+        if (tokensError || !tokens)
+          return (0, import_auth_config.writeAuthConfig)({}), null;
+        let updatedConfig = {
+          token: tokens.access_token,
+          expiresAt: Math.floor(Date.now() / 1e3) + tokens.expires_in
+        };
+        return tokens.refresh_token && (updatedConfig.refreshToken = tokens.refresh_token), (0, import_auth_config.writeAuthConfig)(updatedConfig), updatedConfig.token ?? null;
+      } catch {
+        return (0, import_auth_config.writeAuthConfig)({}), null;
+      }
+    }
+    async function getVercelOidcToken(authToken, projectId, teamId) {
+      let url = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`, 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}`
+        );
+      let tokenRes = await res.json();
+      return assertVercelOidcTokenResponse(tokenRes), 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() {
+      let 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?`"
+        );
+      let 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?`"
+        );
+      let 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) {
+      let 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."
+        );
+      let tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`), tokenJson = JSON.stringify(token);
+      fs.mkdirSync(path.dirname(tokenPath), { mode: 504, recursive: !0 }), fs.writeFileSync(tokenPath, tokenJson), fs.chmodSync(tokenPath, 432);
+    }
+    function loadToken(projectId) {
+      let 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."
+        );
+      let tokenPath = path.join(dir, "com.vercel.token", `${projectId}.json`);
+      if (!fs.existsSync(tokenPath))
+        return null;
+      let token = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+      return assertVercelOidcTokenResponse(token), token;
+    }
+    function getTokenPayload(token) {
+      let tokenParts = token.split(".");
+      if (tokenParts.length !== 3)
+        throw new import_token_error.VercelOidcTokenError(
+          "Invalid token. Please run `vc env pull` and try again"
+        );
+      let base64 = tokenParts[1].replace(/-/g, "+").replace(/_/g, "/"), padded = base64.padEnd(
+        base64.length + (4 - base64.length % 4) % 4,
+        "="
+      );
+      return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    }
+    function isExpired(token) {
+      return token.exp * 1e3 < Date.now();
+    }
+  }
+});
+
+export {
+  require_token_util
+};