@zyycn/claudex 1.0.3-fork.3767904

package/dist/chunk-mw9ve19d.js

@@ -0,0 +1,277 @@
+// @bun
+import {
+  normalizeControlMessageKeys
+} from "./chunk-nt837qt9.js";
+import {
+  EMPTY_USAGE,
+  init_emptyUsage
+} from "./chunk-a8fvd2bk.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_displayTags,
+  stripDisplayTagsAllowEmpty
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+
+// src/bridge/bridgeMessaging.ts
+init_analytics();
+init_emptyUsage();
+import { randomUUID } from "crypto";
+init_debug();
+init_displayTags();
+init_errors();
+init_slowOperations();
+function isSDKMessage(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isSDKControlResponse(value) {
+  return value !== null && typeof value === "object" && "type" in value && value.type === "control_response" && "response" in value;
+}
+function isSDKControlRequest(value) {
+  return value !== null && typeof value === "object" && "type" in value && value.type === "control_request" && "request_id" in value && "request" in value;
+}
+function isEligibleBridgeMessage(m) {
+  if ((m.type === "user" || m.type === "assistant") && m.isVirtual) {
+    return false;
+  }
+  return m.type === "user" || m.type === "assistant" || m.type === "system" && m.subtype === "local_command";
+}
+function extractTitleText(m) {
+  if (m.type !== "user" || m.isMeta || m.toolUseResult || m.isCompactSummary)
+    return;
+  if (m.origin && m.origin.kind !== "human")
+    return;
+  const content = m.message.content;
+  let raw;
+  if (typeof content === "string") {
+    raw = content;
+  } else {
+    for (const block of content) {
+      if (block.type === "text") {
+        raw = block.text;
+        break;
+      }
+    }
+  }
+  if (!raw)
+    return;
+  const clean = stripDisplayTagsAllowEmpty(raw);
+  return clean || undefined;
+}
+function handleIngressMessage(data, recentPostedUUIDs, recentInboundUUIDs, onInboundMessage, onPermissionResponse, onControlRequest) {
+  try {
+    const parsed = normalizeControlMessageKeys(jsonParse(data));
+    if (isSDKControlResponse(parsed)) {
+      logForDebugging("[bridge:repl] Ingress message type=control_response");
+      onPermissionResponse?.(parsed);
+      return;
+    }
+    if (isSDKControlRequest(parsed)) {
+      logForDebugging(`[bridge:repl] Inbound control_request subtype=${parsed.request.subtype}`);
+      onControlRequest?.(parsed);
+      return;
+    }
+    if (!isSDKMessage(parsed))
+      return;
+    const uuid = "uuid" in parsed && typeof parsed.uuid === "string" ? parsed.uuid : undefined;
+    if (uuid && recentPostedUUIDs.has(uuid)) {
+      logForDebugging(`[bridge:repl] Ignoring echo: type=${parsed.type} uuid=${uuid}`);
+      return;
+    }
+    if (uuid && recentInboundUUIDs.has(uuid)) {
+      logForDebugging(`[bridge:repl] Ignoring re-delivered inbound: type=${parsed.type} uuid=${uuid}`);
+      return;
+    }
+    logForDebugging(`[bridge:repl] Ingress message type=${parsed.type}${uuid ? ` uuid=${uuid}` : ""}`);
+    if (parsed.type === "user") {
+      if (uuid)
+        recentInboundUUIDs.add(uuid);
+      logEvent("tengu_bridge_message_received", {
+        is_repl: true
+      });
+      onInboundMessage?.(parsed);
+    } else {
+      logForDebugging(`[bridge:repl] Ignoring non-user inbound message: type=${parsed.type}`);
+    }
+  } catch (err) {
+    logForDebugging(`[bridge:repl] Failed to parse ingress message: ${errorMessage(err)}`);
+  }
+}
+var OUTBOUND_ONLY_ERROR = "This session is outbound-only. Enable Remote Control locally to allow inbound control.";
+function handleServerControlRequest(request, handlers) {
+  const {
+    transport,
+    sessionId,
+    outboundOnly,
+    onInterrupt,
+    onSetModel,
+    onSetMaxThinkingTokens,
+    onSetPermissionMode
+  } = handlers;
+  if (!transport) {
+    logForDebugging("[bridge:repl] Cannot respond to control_request: transport not configured");
+    return;
+  }
+  let response;
+  const req = request.request;
+  if (outboundOnly && req.subtype !== "initialize") {
+    response = {
+      type: "control_response",
+      response: {
+        subtype: "error",
+        request_id: request.request_id,
+        error: OUTBOUND_ONLY_ERROR
+      }
+    };
+    const event2 = { ...response, session_id: sessionId };
+    transport.write(event2);
+    logForDebugging(`[bridge:repl] Rejected ${req.subtype} (outbound-only) request_id=${request.request_id}`);
+    return;
+  }
+  switch (req.subtype) {
+    case "initialize":
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response: {
+            commands: [],
+            output_style: "normal",
+            available_output_styles: ["normal"],
+            models: [],
+            account: {},
+            pid: process.pid
+          }
+        }
+      };
+      break;
+    case "set_model":
+      onSetModel?.(req.model);
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    case "set_max_thinking_tokens":
+      onSetMaxThinkingTokens?.(req.max_thinking_tokens ?? null);
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    case "set_permission_mode": {
+      const verdict = onSetPermissionMode?.(req.mode) ?? {
+        ok: false,
+        error: "set_permission_mode is not supported in this context (onSetPermissionMode callback not registered)"
+      };
+      if (verdict.ok) {
+        response = {
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: request.request_id
+          }
+        };
+      } else {
+        response = {
+          type: "control_response",
+          response: {
+            subtype: "error",
+            request_id: request.request_id,
+            error: verdict.error
+          }
+        };
+      }
+      break;
+    }
+    case "interrupt":
+      onInterrupt?.();
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id
+        }
+      };
+      break;
+    default:
+      response = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: `REPL bridge does not handle control_request subtype: ${req.subtype}`
+        }
+      };
+  }
+  const event = { ...response, session_id: sessionId };
+  transport.write(event);
+  logForDebugging(`[bridge:repl] Sent control_response for ${req.subtype} request_id=${request.request_id} result=${response.response.subtype}`);
+}
+function makeResultMessage(sessionId) {
+  return {
+    type: "result_success",
+    subtype: "success",
+    duration_ms: 0,
+    duration_api_ms: 0,
+    is_error: false,
+    num_turns: 0,
+    result: "",
+    stop_reason: null,
+    total_cost_usd: 0,
+    usage: { ...EMPTY_USAGE },
+    modelUsage: {},
+    permission_denials: [],
+    session_id: sessionId,
+    uuid: randomUUID()
+  };
+}
+
+class BoundedUUIDSet {
+  capacity;
+  ring;
+  set = new Set;
+  writeIdx = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.ring = new Array(capacity);
+  }
+  add(uuid) {
+    if (this.set.has(uuid))
+      return;
+    const evicted = this.ring[this.writeIdx];
+    if (evicted !== undefined) {
+      this.set.delete(evicted);
+    }
+    this.ring[this.writeIdx] = uuid;
+    this.set.add(uuid);
+    this.writeIdx = (this.writeIdx + 1) % this.capacity;
+  }
+  has(uuid) {
+    return this.set.has(uuid);
+  }
+  clear() {
+    this.set.clear();
+    this.ring.fill(undefined);
+    this.writeIdx = 0;
+  }
+}
+
+export { isEligibleBridgeMessage, extractTitleText, handleIngressMessage, handleServerControlRequest, makeResultMessage, BoundedUUIDSet };

package/dist/chunk-mxt2wn9a.js

@@ -0,0 +1,131 @@
+// @bun
+import {
+  init_settingsSync
+} from "./chunk-rx4c84ah.js";
+import {
+  init_refresh,
+  refreshActivePlugins
+} from "./chunk-as7vh4kb.js";
+import {
+  init_changeDetector
+} from "./chunk-njmw3yt4.js";
+import"./chunk-j0xd989k.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-a8fvd2bk.js";
+import"./chunk-pkcx8qa3.js";
+import"./chunk-er596fa7.js";
+import"./chunk-ddk0ak7r.js";
+import"./chunk-k2qkkhf9.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-1ed0q5rg.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-khs0jvy0.js";
+import"./chunk-p4qrpz5a.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-pxy618ae.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-tnd5xbeh.js";
+import"./chunk-8aww16wk.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2xj33w0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tssr3fyd.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-pkb4qnmq.js";
+import {
+  init_stringUtils,
+  plural
+} from "./chunk-z06751ss.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-9nta4x35.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-w8yw30sd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils
+} from "./chunk-raqgs410.js";
+import {
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/reload-plugins/reload-plugins.ts
+function n(count, noun) {
+  return `${count} ${plural(count, noun)}`;
+}
+var call = async (_args, context) => {
+  if (false) {}
+  const r = await refreshActivePlugins(context.setAppState);
+  const parts = [
+    n(r.enabled_count, "plugin"),
+    n(r.command_count, "skill"),
+    n(r.agent_count, "agent"),
+    n(r.hook_count, "hook"),
+    n(r.mcp_count, "plugin MCP server"),
+    n(r.lsp_count, "plugin LSP server")
+  ];
+  let msg = `Reloaded: ${parts.join(" \xB7 ")}`;
+  if (r.error_count > 0) {
+    msg += `
+${n(r.error_count, "error")} during load. Run /doctor for details.`;
+  }
+  return { type: "text", value: msg };
+};
+var init_reload_plugins = __esm(() => {
+  init_state();
+  init_settingsSync();
+  init_envUtils();
+  init_refresh();
+  init_changeDetector();
+  init_stringUtils();
+});
+init_reload_plugins();
+
+export {
+  call
+};

package/dist/chunk-n0qaeaa5.js

@@ -0,0 +1,256 @@
+// @bun
+import {
+  require_dist_cjs
+} from "./chunk-xsq9ae7x.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getHomeDir.js
+var require_getHomeDir = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getHomeDir = undefined;
+  var os_1 = __require("os");
+  var path_1 = __require("path");
+  var homeDirCache = {};
+  var getHomeDirCacheKey = () => {
+    if (process && process.geteuid) {
+      return `${process.geteuid()}`;
+    }
+    return "DEFAULT";
+  };
+  var getHomeDir = () => {
+    const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${path_1.sep}` } = process.env;
+    if (HOME)
+      return HOME;
+    if (USERPROFILE)
+      return USERPROFILE;
+    if (HOMEPATH)
+      return `${HOMEDRIVE}${HOMEPATH}`;
+    const homeDirCacheKey = getHomeDirCacheKey();
+    if (!homeDirCache[homeDirCacheKey])
+      homeDirCache[homeDirCacheKey] = (0, os_1.homedir)();
+    return homeDirCache[homeDirCacheKey];
+  };
+  exports.getHomeDir = getHomeDir;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getSSOTokenFilepath.js
+var require_getSSOTokenFilepath = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getSSOTokenFilepath = undefined;
+  var crypto_1 = __require("crypto");
+  var path_1 = __require("path");
+  var getHomeDir_1 = require_getHomeDir();
+  var getSSOTokenFilepath = (id) => {
+    const hasher = (0, crypto_1.createHash)("sha1");
+    const cacheName = hasher.update(id).digest("hex");
+    return (0, path_1.join)((0, getHomeDir_1.getHomeDir)(), ".aws", "sso", "cache", `${cacheName}.json`);
+  };
+  exports.getSSOTokenFilepath = getSSOTokenFilepath;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getSSOTokenFromFile.js
+var require_getSSOTokenFromFile = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getSSOTokenFromFile = exports.tokenIntercept = undefined;
+  var promises_1 = __require("fs/promises");
+  var getSSOTokenFilepath_1 = require_getSSOTokenFilepath();
+  exports.tokenIntercept = {};
+  var getSSOTokenFromFile = async (id) => {
+    if (exports.tokenIntercept[id]) {
+      return exports.tokenIntercept[id];
+    }
+    const ssoTokenFilepath = (0, getSSOTokenFilepath_1.getSSOTokenFilepath)(id);
+    const ssoTokenText = await (0, promises_1.readFile)(ssoTokenFilepath, "utf8");
+    return JSON.parse(ssoTokenText);
+  };
+  exports.getSSOTokenFromFile = getSSOTokenFromFile;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/readFile.js
+var require_readFile = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.readFile = exports.fileIntercept = exports.filePromises = undefined;
+  var promises_1 = __require("fs/promises");
+  exports.filePromises = {};
+  exports.fileIntercept = {};
+  var readFile = (path, options) => {
+    if (exports.fileIntercept[path] !== undefined) {
+      return exports.fileIntercept[path];
+    }
+    if (!exports.filePromises[path] || options?.ignoreCache) {
+      exports.filePromises[path] = (0, promises_1.readFile)(path, "utf8");
+    }
+    return exports.filePromises[path];
+  };
+  exports.readFile = readFile;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var getHomeDir = require_getHomeDir();
+  var getSSOTokenFilepath = require_getSSOTokenFilepath();
+  var getSSOTokenFromFile = require_getSSOTokenFromFile();
+  var path = __require("path");
+  var types = require_dist_cjs();
+  var readFile = require_readFile();
+  var ENV_PROFILE = "AWS_PROFILE";
+  var DEFAULT_PROFILE = "default";
+  var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
+  var CONFIG_PREFIX_SEPARATOR = ".";
+  var getConfigData = (data) => Object.entries(data).filter(([key]) => {
+    const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+    if (indexOfSeparator === -1) {
+      return false;
+    }
+    return Object.values(types.IniSectionType).includes(key.substring(0, indexOfSeparator));
+  }).reduce((acc, [key, value]) => {
+    const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+    const updatedKey = key.substring(0, indexOfSeparator) === types.IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
+    acc[updatedKey] = value;
+    return acc;
+  }, {
+    ...data.default && { default: data.default }
+  });
+  var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
+  var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "config");
+  var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
+  var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "credentials");
+  var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
+  var profileNameBlockList = ["__proto__", "profile __proto__"];
+  var parseIni = (iniData) => {
+    const map = {};
+    let currentSection;
+    let currentSubSection;
+    for (const iniLine of iniData.split(/\r?\n/)) {
+      const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
+      const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
+      if (isSection) {
+        currentSection = undefined;
+        currentSubSection = undefined;
+        const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
+        const matches = prefixKeyRegex.exec(sectionName);
+        if (matches) {
+          const [, prefix, , name] = matches;
+          if (Object.values(types.IniSectionType).includes(prefix)) {
+            currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
+          }
+        } else {
+          currentSection = sectionName;
+        }
+        if (profileNameBlockList.includes(sectionName)) {
+          throw new Error(`Found invalid profile name "${sectionName}"`);
+        }
+      } else if (currentSection) {
+        const indexOfEqualsSign = trimmedLine.indexOf("=");
+        if (![0, -1].includes(indexOfEqualsSign)) {
+          const [name, value] = [
+            trimmedLine.substring(0, indexOfEqualsSign).trim(),
+            trimmedLine.substring(indexOfEqualsSign + 1).trim()
+          ];
+          if (value === "") {
+            currentSubSection = name;
+          } else {
+            if (currentSubSection && iniLine.trimStart() === iniLine) {
+              currentSubSection = undefined;
+            }
+            map[currentSection] = map[currentSection] || {};
+            const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name;
+            map[currentSection][key] = value;
+          }
+        }
+      }
+    }
+    return map;
+  };
+  var swallowError$1 = () => ({});
+  var loadSharedConfigFiles = async (init = {}) => {
+    const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init;
+    const homeDir = getHomeDir.getHomeDir();
+    const relativeHomeDirPrefix = "~/";
+    let resolvedFilepath = filepath;
+    if (filepath.startsWith(relativeHomeDirPrefix)) {
+      resolvedFilepath = path.join(homeDir, filepath.slice(2));
+    }
+    let resolvedConfigFilepath = configFilepath;
+    if (configFilepath.startsWith(relativeHomeDirPrefix)) {
+      resolvedConfigFilepath = path.join(homeDir, configFilepath.slice(2));
+    }
+    const parsedFiles = await Promise.all([
+      readFile.readFile(resolvedConfigFilepath, {
+        ignoreCache: init.ignoreCache
+      }).then(parseIni).then(getConfigData).catch(swallowError$1),
+      readFile.readFile(resolvedFilepath, {
+        ignoreCache: init.ignoreCache
+      }).then(parseIni).catch(swallowError$1)
+    ]);
+    return {
+      configFile: parsedFiles[0],
+      credentialsFile: parsedFiles[1]
+    };
+  };
+  var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(types.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
+  var swallowError = () => ({});
+  var loadSsoSessionData = async (init = {}) => readFile.readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
+  var mergeConfigFiles = (...files) => {
+    const merged = {};
+    for (const file of files) {
+      for (const [key, values] of Object.entries(file)) {
+        if (merged[key] !== undefined) {
+          Object.assign(merged[key], values);
+        } else {
+          merged[key] = values;
+        }
+      }
+    }
+    return merged;
+  };
+  var parseKnownFiles = async (init) => {
+    const parsedFiles = await loadSharedConfigFiles(init);
+    return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile);
+  };
+  var externalDataInterceptor = {
+    getFileRecord() {
+      return readFile.fileIntercept;
+    },
+    interceptFile(path2, contents) {
+      readFile.fileIntercept[path2] = Promise.resolve(contents);
+    },
+    getTokenRecord() {
+      return getSSOTokenFromFile.tokenIntercept;
+    },
+    interceptToken(id, contents) {
+      getSSOTokenFromFile.tokenIntercept[id] = contents;
+    }
+  };
+  exports.getSSOTokenFromFile = getSSOTokenFromFile.getSSOTokenFromFile;
+  exports.readFile = readFile.readFile;
+  exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
+  exports.DEFAULT_PROFILE = DEFAULT_PROFILE;
+  exports.ENV_PROFILE = ENV_PROFILE;
+  exports.externalDataInterceptor = externalDataInterceptor;
+  exports.getProfileName = getProfileName;
+  exports.loadSharedConfigFiles = loadSharedConfigFiles;
+  exports.loadSsoSessionData = loadSsoSessionData;
+  exports.parseKnownFiles = parseKnownFiles;
+  Object.prototype.hasOwnProperty.call(getHomeDir, "__proto__") && !Object.prototype.hasOwnProperty.call(exports, "__proto__") && Object.defineProperty(exports, "__proto__", {
+    enumerable: true,
+    value: getHomeDir["__proto__"]
+  });
+  Object.keys(getHomeDir).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      exports[k] = getHomeDir[k];
+  });
+  Object.prototype.hasOwnProperty.call(getSSOTokenFilepath, "__proto__") && !Object.prototype.hasOwnProperty.call(exports, "__proto__") && Object.defineProperty(exports, "__proto__", {
+    enumerable: true,
+    value: getSSOTokenFilepath["__proto__"]
+  });
+  Object.keys(getSSOTokenFilepath).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      exports[k] = getSSOTokenFilepath[k];
+  });
+});
+
+export { require_dist_cjs2 as require_dist_cjs };