@introspection-ai/recipes 0.24.0 → 0.25.0

package/dist/mcp-chunks/{chunk-SQTXZR56.js → chunk-ASG4OY3M.js}

@@ -1,615 +1,32 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
-  clearVaultEntry,
-  clearVaultTokensIfMatching,
-  getOAuthVaultPath,
-  isStoredOAuthClientInformation,
-  isStoredOAuthTokens,
-  loadVaultEntryForRecovery,
-  reconcileVaultServerUrl,
-  sameOAuthClientGeneration,
-  sameOAuthClientValue,
+  clearLegacyOAuthArtifacts,
+  createOAuthPersistenceStores,
   sameOAuthTokenGeneration,
-  sameOAuthTokenValue,
-  saveVaultEntry,
-  vaultCredentialKeys,
-  withHiddenOAuthClientGeneration,
-  withHiddenOAuthTokenGeneration,
-  withOAuthClientGeneration,
-  withOAuthTokenGeneration
-} from "./chunk-7CS27CWE.js";
+  vaultCredentialKeys
+} from "./chunk-53NRFMB3.js";
 import {
   checkResourceAllowed,
   discoverOAuthServerInfo,
   refreshAuthorization,
   resourceUrlFromServerUrl
-} from "./chunk-K56RW4HB.js";
+} from "./chunk-PZ323CXI.js";
 import {
   canonicalizeFilePath,
   isFileLockTimeoutError,
-  readJsonFile,
-  withFileLock,
-  writeJsonFile,
-  writeTextFileAtomic
-} from "./chunk-ADINDBOF.js";
+  withFileLock
+} from "./chunk-ITR7FQM3.js";
 import {
-  legacyMcporterDir,
   mcporterDir
-} from "./chunk-TGJOZDKG.js";
+} from "./chunk-FS5JIKT6.js";
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-persistence.js
-import fs2 from "node:fs/promises";
-
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-persistence-stores.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-persistence.js
 import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-function withStoredExpiry(tokens) {
-  const stored = tokens;
-  if (typeof stored.expires_at === "number" || typeof stored.expiresAt === "number") {
-    return tokens;
-  }
-  if (typeof tokens.expires_in === "number" && Number.isFinite(tokens.expires_in)) {
-    return {
-      ...tokens,
-      expires_at: Math.floor(Date.now() / 1e3) + tokens.expires_in
-    };
-  }
-  return tokens;
-}
-function prepareStoredTokens(tokens) {
-  return withStoredExpiry(withOAuthTokenGeneration(tokens));
-}
-var DirectoryPersistence = class {
-  root;
-  logger;
-  serverUrl;
-  skipUrlMarkerWhenMissing;
-  tokenPath;
-  clientInfoPath;
-  codeVerifierPath;
-  statePath;
-  serverUrlPath;
-  discoveryStatePath;
-  authorizationServerUrlPath;
-  resourceUrlPath;
-  constructor(root, logger, serverUrl, skipUrlMarkerWhenMissing = false) {
-    this.root = root;
-    this.logger = logger;
-    this.serverUrl = serverUrl;
-    this.skipUrlMarkerWhenMissing = skipUrlMarkerWhenMissing;
-    this.tokenPath = path.join(root, "tokens.json");
-    this.clientInfoPath = path.join(root, "client.json");
-    this.codeVerifierPath = path.join(root, "code_verifier.txt");
-    this.statePath = path.join(root, "state.txt");
-    this.serverUrlPath = path.join(root, "server_url.txt");
-    this.discoveryStatePath = path.join(root, "discovery.json");
-    this.authorizationServerUrlPath = path.join(root, "authorization_server_url.txt");
-    this.resourceUrlPath = path.join(root, "resource_url.txt");
-  }
-  describe() {
-    return this.root;
-  }
-  async ensureDir() {
-    await fs.mkdir(this.root, { recursive: true });
-  }
-  async reconcileServerUrl() {
-    if (!this.serverUrl) {
-      return;
-    }
-    const serverUrl = this.serverUrl;
-    if (this.skipUrlMarkerWhenMissing) {
-      try {
-        await fs.access(this.root);
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          return;
-        }
-        throw error;
-      }
-    }
-    await this.ensureDir();
-    await withFileLock(this.tokenPath, async () => {
-      let previousUrl;
-      try {
-        previousUrl = (await fs.readFile(this.serverUrlPath, "utf8")).trim();
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
-      if (previousUrl === serverUrl) {
-        return;
-      }
-      if (previousUrl !== void 0) {
-        await this.clearFiles("all");
-      }
-      await writeTextFileAtomic(this.serverUrlPath, serverUrl);
-    });
-  }
-  async readSnapshot() {
-    await this.reconcileServerUrl();
-    const [tokens, clientInfo, codeVerifier, state, discoveryState, authorizationServerUrl, resourceUrl] = await Promise.all([
-      this.readTokensAfterReconcile(),
-      this.readClientInfoAfterReconcile(),
-      this.readCodeVerifierAfterReconcile(),
-      this.readStateAfterReconcile(),
-      this.readDiscoveryStateAfterReconcile(),
-      this.readTextAfterReconcile(this.authorizationServerUrlPath),
-      this.readTextAfterReconcile(this.resourceUrlPath)
-    ]);
-    return { tokens, clientInfo, codeVerifier, state, discoveryState, authorizationServerUrl, resourceUrl };
-  }
-  async readTokens() {
-    await this.reconcileServerUrl();
-    return await this.readTokensAfterReconcile();
-  }
-  async readTokensAfterReconcile() {
-    const tokens = await this.readJsonOrUndefined(this.tokenPath);
-    return isStoredOAuthTokens(tokens) ? withHiddenOAuthTokenGeneration(tokens) : void 0;
-  }
-  async saveTokens(tokens) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await withFileLock(this.tokenPath, async () => {
-      await writeJsonFile(this.tokenPath, prepareStoredTokens(tokens));
-    });
-    this.logger?.debug?.(`Saved tokens to ${this.tokenPath}`);
-  }
-  async clearRejectedCredentials(expectedTokens, expectedClientInfo) {
-    await this.reconcileServerUrl();
-    await withFileLock(this.tokenPath, async () => {
-      if (expectedTokens) {
-        const current = await this.readJsonOrUndefined(this.tokenPath);
-        if (sameOAuthTokenGeneration(current, expectedTokens)) {
-          await this.unlinkIfPresent(this.tokenPath);
-        }
-      }
-      if (expectedClientInfo) {
-        const currentClientInfo = await this.readJsonOrUndefined(this.clientInfoPath);
-        if (sameOAuthClientGeneration(currentClientInfo, expectedClientInfo)) {
-          await this.unlinkIfPresent(this.clientInfoPath);
-        }
-      }
-    });
-  }
-  async unlinkIfPresent(file) {
-    try {
-      await fs.unlink(file);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-  async readClientInfo() {
-    await this.reconcileServerUrl();
-    return await this.readClientInfoAfterReconcile();
-  }
-  async readClientInfoAfterReconcile() {
-    const info = await this.readJsonOrUndefined(this.clientInfoPath);
-    return isStoredOAuthClientInformation(info) ? withHiddenOAuthClientGeneration(info) : void 0;
-  }
-  async saveClientInfo(info) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await withFileLock(this.tokenPath, async () => {
-      await writeJsonFile(this.clientInfoPath, withOAuthClientGeneration(info));
-    });
-  }
-  async readCodeVerifier() {
-    await this.reconcileServerUrl();
-    return await this.readCodeVerifierAfterReconcile();
-  }
-  async readCodeVerifierAfterReconcile() {
-    try {
-      return (await fs.readFile(this.codeVerifierPath, "utf8")).trim();
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return void 0;
-      }
-      throw error;
-    }
-  }
-  async saveCodeVerifier(value) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await writeTextFileAtomic(this.codeVerifierPath, value);
-  }
-  async readState() {
-    await this.reconcileServerUrl();
-    return await this.readStateAfterReconcile();
-  }
-  async readStateAfterReconcile() {
-    return readJsonFile(this.statePath);
-  }
-  // A present-but-corrupt credential cache (tokens/client) means "no usable
-  // credentials": degrade to re-auth instead of crashing the connection,
-  // mirroring VaultPersistence and the daemon/server-proxy readers. Genuine I/O
-  // faults still propagate (readJsonFile re-throws everything except ENOENT).
-  // OAuth state is intentionally excluded so its CSRF check still fails closed.
-  async readJsonOrUndefined(filePath) {
-    try {
-      return await readJsonFile(filePath);
-    } catch (error) {
-      if (!(error instanceof SyntaxError)) {
-        throw error;
-      }
-      this.logger?.debug?.(`Ignoring corrupt OAuth cache file ${filePath}: ${error.message}`);
-      return void 0;
-    }
-  }
-  async saveState(value) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await writeJsonFile(this.statePath, value);
-  }
-  async readDiscoveryState() {
-    await this.reconcileServerUrl();
-    return this.readDiscoveryStateAfterReconcile();
-  }
-  async readDiscoveryStateAfterReconcile() {
-    return readJsonFile(this.discoveryStatePath);
-  }
-  async saveDiscoveryState(value) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await writeJsonFile(this.discoveryStatePath, value);
-  }
-  async readAuthorizationServerUrl() {
-    await this.reconcileServerUrl();
-    return this.readTextAfterReconcile(this.authorizationServerUrlPath);
-  }
-  async saveAuthorizationServerUrl(value) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await writeTextFileAtomic(this.authorizationServerUrlPath, value);
-  }
-  async readResourceUrl() {
-    await this.reconcileServerUrl();
-    return this.readTextAfterReconcile(this.resourceUrlPath);
-  }
-  async saveResourceUrl(value) {
-    await this.reconcileServerUrl();
-    await this.ensureDir();
-    await writeTextFileAtomic(this.resourceUrlPath, value);
-  }
-  async readTextAfterReconcile(filePath) {
-    try {
-      return (await fs.readFile(filePath, "utf8")).trim() || void 0;
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return void 0;
-      throw error;
-    }
-  }
-  async clear(scope) {
-    await this.reconcileServerUrl();
-    await this.clearFiles(scope);
-  }
-  async clearFiles(scope) {
-    const files = [];
-    if (scope === "all" || scope === "tokens") {
-      files.push(this.tokenPath);
-    }
-    if (scope === "all" || scope === "client") {
-      files.push(this.clientInfoPath);
-    }
-    if (scope === "all" || scope === "verifier") {
-      files.push(this.codeVerifierPath);
-    }
-    if (scope === "all" || scope === "state") {
-      files.push(this.statePath);
-    }
-    if (scope === "all" || scope === "discovery") {
-      files.push(this.discoveryStatePath, this.authorizationServerUrlPath, this.resourceUrlPath);
-    }
-    await Promise.all(files.map((file) => this.unlinkIfPresent(file)));
-  }
-};
-var VaultPersistence = class {
-  definition;
-  tokenSnapshots;
-  clientSnapshots;
-  constructor(definition) {
-    this.definition = definition;
-  }
-  describe() {
-    return `${getOAuthVaultPath()} (vault)`;
-  }
-  async reconcileServerUrl() {
-    await reconcileVaultServerUrl(this.definition);
-  }
-  async readSnapshot() {
-    await this.reconcileServerUrl();
-    const recovery = await loadVaultEntryForRecovery(this.definition);
-    this.tokenSnapshots = recovery.tokenSnapshots;
-    this.clientSnapshots = recovery.clientSnapshots;
-    return {
-      tokens: recovery.entry?.tokens,
-      clientInfo: recovery.entry?.clientInfo,
-      codeVerifier: recovery.entry?.codeVerifier,
-      state: recovery.entry?.state,
-      discoveryState: recovery.entry?.discoveryState,
-      authorizationServerUrl: recovery.entry?.authorizationServerUrl,
-      resourceUrl: recovery.entry?.resourceUrl
-    };
-  }
-  async readTokens() {
-    const snapshot = await this.readSnapshot();
-    return snapshot.tokens;
-  }
-  async saveTokens(tokens) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { tokens: prepareStoredTokens(tokens) });
-  }
-  async readClientInfo() {
-    const snapshot = await this.readSnapshot();
-    return snapshot.clientInfo;
-  }
-  async saveClientInfo(info) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { clientInfo: info });
-  }
-  async readCodeVerifier() {
-    const snapshot = await this.readSnapshot();
-    return snapshot.codeVerifier;
-  }
-  async saveCodeVerifier(value) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { codeVerifier: value });
-  }
-  async readState() {
-    const snapshot = await this.readSnapshot();
-    return snapshot.state;
-  }
-  async saveState(value) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { state: value });
-  }
-  async readDiscoveryState() {
-    return (await this.readSnapshot()).discoveryState;
-  }
-  async saveDiscoveryState(value) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { discoveryState: value });
-  }
-  async readAuthorizationServerUrl() {
-    return (await this.readSnapshot()).authorizationServerUrl;
-  }
-  async saveAuthorizationServerUrl(value) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { authorizationServerUrl: value });
-  }
-  async readResourceUrl() {
-    return (await this.readSnapshot()).resourceUrl;
-  }
-  async saveResourceUrl(value) {
-    await this.reconcileServerUrl();
-    await saveVaultEntry(this.definition, { resourceUrl: value });
-  }
-  async clear(scope) {
-    await this.reconcileServerUrl();
-    await clearVaultEntry(this.definition, scope);
-  }
-  async clearRejectedCredentials(expectedTokens, expectedClientInfo) {
-    await this.reconcileServerUrl();
-    await clearVaultTokensIfMatching(this.definition, expectedTokens, expectedClientInfo, expectedTokens ? this.tokenSnapshots : void 0, expectedClientInfo ? this.clientSnapshots : void 0);
-  }
-};
-var CompositePersistence = class {
-  stores;
-  recoveryTokenSnapshots = /* @__PURE__ */ new Map();
-  recoveryClientSnapshots = /* @__PURE__ */ new Map();
-  recoveryTokenSource;
-  recoveryClientSource;
-  constructor(stores) {
-    this.stores = stores;
-  }
-  describe() {
-    return this.stores.map((store) => store.describe()).join(" + ");
-  }
-  async readSnapshot() {
-    const snapshots = await Promise.all(this.stores.map((store) => store.readSnapshot()));
-    const tokens = this.firstSnapshotValue(snapshots, "tokens");
-    const clientInfo = this.firstSnapshotValue(snapshots, "clientInfo");
-    this.recoveryTokenSnapshots.clear();
-    this.recoveryClientSnapshots.clear();
-    for (const [index, snapshot] of snapshots.entries()) {
-      const store = this.stores[index];
-      this.recoveryTokenSnapshots.set(store, snapshot.tokens);
-      this.recoveryClientSnapshots.set(store, snapshot.clientInfo);
-    }
-    this.recoveryTokenSource = tokens.source;
-    this.recoveryClientSource = clientInfo.source;
-    return {
-      tokens: tokens.value,
-      clientInfo: clientInfo.value,
-      codeVerifier: this.firstSnapshotValue(snapshots, "codeVerifier").value,
-      state: this.firstSnapshotValue(snapshots, "state").value,
-      discoveryState: this.firstSnapshotValue(snapshots, "discoveryState").value,
-      authorizationServerUrl: this.firstSnapshotValue(snapshots, "authorizationServerUrl").value,
-      resourceUrl: this.firstSnapshotValue(snapshots, "resourceUrl").value
-    };
-  }
-  firstSnapshotValue(snapshots, field) {
-    for (const [index, snapshot] of snapshots.entries()) {
-      if (snapshot[field] !== void 0) {
-        return { value: snapshot[field], source: this.stores[index] };
-      }
-    }
-    return { value: void 0, source: void 0 };
-  }
-  async readTokens() {
-    const result = await this.readRecoveryValues((store) => store.readTokens(), this.recoveryTokenSnapshots);
-    this.recoveryTokenSource = result.source;
-    return result.value;
-  }
-  async readTokensPerStore() {
-    const perStore = await Promise.all(this.stores.map((store) => store.readTokens()));
-    return perStore.filter((tokens) => tokens !== void 0);
-  }
-  async saveTokens(tokens) {
-    const stored = prepareStoredTokens(tokens);
-    await Promise.all(this.stores.map((store) => store.saveTokens(stored)));
-  }
-  async clearRejectedCredentials(expectedTokens, expectedClientInfo) {
-    await Promise.all(this.stores.map((store) => {
-      const storedTokenSnapshot = expectedTokens ? this.recoveryTokenSnapshots.get(store) : void 0;
-      const tokenSnapshot = expectedTokens && storedTokenSnapshot && (store === this.recoveryTokenSource || sameOAuthTokenValue(storedTokenSnapshot, expectedTokens)) ? storedTokenSnapshot : void 0;
-      const storedClientSnapshot = expectedClientInfo ? this.recoveryClientSnapshots.get(store) : void 0;
-      const clientSnapshot = expectedClientInfo && storedClientSnapshot && (store === this.recoveryClientSource || sameOAuthClientValue(storedClientSnapshot, expectedClientInfo)) ? storedClientSnapshot : void 0;
-      return tokenSnapshot || clientSnapshot ? store.clearRejectedCredentials(tokenSnapshot, clientSnapshot) : Promise.resolve();
-    }));
-  }
-  async readClientInfo() {
-    const result = await this.readRecoveryValues((store) => store.readClientInfo(), this.recoveryClientSnapshots);
-    this.recoveryClientSource = result.source;
-    return result.value;
-  }
-  async readRecoveryValues(read, snapshots) {
-    const results = await Promise.allSettled(this.stores.map((store) => read(store)));
-    snapshots.clear();
-    let value;
-    let source;
-    for (const [index, result] of results.entries()) {
-      const store = this.stores[index];
-      if (result.status === "rejected") {
-        if (!source) {
-          throw result.reason;
-        }
-        continue;
-      }
-      snapshots.set(store, result.value);
-      if (!source && result.value !== void 0) {
-        source = store;
-        value = result.value;
-      }
-    }
-    return { value, source };
-  }
-  async saveClientInfo(info) {
-    const stored = withOAuthClientGeneration(info);
-    await Promise.all(this.stores.map((store) => store.saveClientInfo(stored)));
-  }
-  async readCodeVerifier() {
-    for (const store of this.stores) {
-      const result = await store.readCodeVerifier();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveCodeVerifier(value) {
-    await Promise.all(this.stores.map((store) => store.saveCodeVerifier(value)));
-  }
-  async readState() {
-    for (const store of this.stores) {
-      const result = await store.readState();
-      if (result) {
-        return result;
-      }
-    }
-    return void 0;
-  }
-  async saveState(value) {
-    await Promise.all(this.stores.map((store) => store.saveState(value)));
-  }
-  async readDiscoveryState() {
-    return this.readFirst((store) => store.readDiscoveryState());
-  }
-  async saveDiscoveryState(value) {
-    await Promise.all(this.stores.map((store) => store.saveDiscoveryState(value)));
-  }
-  async readAuthorizationServerUrl() {
-    return this.readFirst((store) => store.readAuthorizationServerUrl());
-  }
-  async saveAuthorizationServerUrl(value) {
-    await Promise.all(this.stores.map((store) => store.saveAuthorizationServerUrl(value)));
-  }
-  async readResourceUrl() {
-    return this.readFirst((store) => store.readResourceUrl());
-  }
-  async saveResourceUrl(value) {
-    await Promise.all(this.stores.map((store) => store.saveResourceUrl(value)));
-  }
-  async readFirst(read) {
-    for (const store of this.stores) {
-      const value = await read(store);
-      if (value !== void 0)
-        return value;
-    }
-    return void 0;
-  }
-  async clear(scope) {
-    await Promise.all(this.stores.map((store) => store.clear(scope)));
-  }
-};
-async function createOAuthPersistenceStores(definition, logger) {
-  const vault = new VaultPersistence(definition);
-  const stores = [vault];
-  const serverUrl = definition.command.kind === "http" ? definition.command.url.toString() : void 0;
-  if (definition.tokenCacheDir) {
-    stores.unshift(new DirectoryPersistence(definition.tokenCacheDir, logger, serverUrl));
-  }
-  const legacyDir = path.join(legacyMcporterDir(), definition.name);
-  if (!definition.tokenCacheDir) {
-    const legacy = new DirectoryPersistence(legacyDir, logger, serverUrl, true);
-    const snapshot = await legacy.readSnapshot();
-    if (snapshot.tokens || snapshot.clientInfo || snapshot.codeVerifier || snapshot.state || snapshot.discoveryState || snapshot.authorizationServerUrl || snapshot.resourceUrl) {
-      if (snapshot.tokens) {
-        await vault.saveTokens(snapshot.tokens);
-      }
-      if (snapshot.clientInfo) {
-        await vault.saveClientInfo(snapshot.clientInfo);
-      }
-      if (snapshot.codeVerifier) {
-        await vault.saveCodeVerifier(snapshot.codeVerifier);
-      }
-      if (snapshot.state) {
-        await vault.saveState(snapshot.state);
-      }
-      if (snapshot.discoveryState) {
-        await vault.saveDiscoveryState(snapshot.discoveryState);
-      }
-      if (snapshot.authorizationServerUrl) {
-        await vault.saveAuthorizationServerUrl(snapshot.authorizationServerUrl);
-      }
-      if (snapshot.resourceUrl) {
-        await vault.saveResourceUrl(snapshot.resourceUrl);
-      }
-      logger?.info?.(`Migrated legacy OAuth cache for '${definition.name}' into vault.`);
-    }
-  }
-  return stores.length === 1 ? vault : new CompositePersistence(stores);
-}
-async function clearLegacyOAuthArtifacts(definition, logger, scope) {
-  const legacyDir = path.join(legacyMcporterDir(), definition.name);
-  if (!definition.tokenCacheDir || legacyDir !== definition.tokenCacheDir) {
-    const legacy = new DirectoryPersistence(legacyDir, logger);
-    await legacy.clear(scope);
-  }
-  const legacyFiles = [];
-  if (definition.name.toLowerCase() === "gmail") {
-    legacyFiles.push(path.join(os.homedir(), ".gmail-mcp", "credentials.json"));
-  }
-  await Promise.all(legacyFiles.map(async (file) => {
-    try {
-      await fs.unlink(file);
-      logger?.info?.(`Cleared legacy OAuth cache file ${file}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }));
-}
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-token-refresh.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-token-refresh.js
 import { Buffer } from "node:buffer";
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-client-info.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-client-info.js
 function buildStaticClientInformation(definition, options = {}) {
   if (!definition.oauthClientId) {
     return void 0;
@@ -635,23 +52,23 @@ function resolveOAuthClientSecret(definition, options = {}) {
   return definition.oauthClientSecret;
 }
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-refresh-lock.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-refresh-lock.js
 import { AsyncLocalStorage } from "node:async_hooks";
 import crypto from "node:crypto";
-import path2 from "node:path";
+import path from "node:path";
 var REFRESH_LOCK_DIR = "refresh-locks";
 var LOCK_LABEL_MAX = 40;
 var IDENTITY_HASH_LENGTH = 16;
 var TIMEOUT_OVERRIDE_ENV = "MCPORTER_TEST_REFRESH_LOCK_TIMEOUT_MS";
 var heldLockPaths = new AsyncLocalStorage();
 function refreshLockDir() {
-  return path2.join(mcporterDir("data"), REFRESH_LOCK_DIR);
+  return path.join(mcporterDir("data"), REFRESH_LOCK_DIR);
 }
 async function refreshLockPaths(definition) {
   const paths = [];
   if (definition.tokenCacheDir) {
-    const tokenPath = await canonicalizeFilePath(path2.join(definition.tokenCacheDir, "tokens.json"));
-    paths.push(lockPathFor(path2.basename(path2.dirname(tokenPath)), `dir:${tokenPath}`));
+    const tokenPath = await canonicalizeFilePath(path.join(definition.tokenCacheDir, "tokens.json"));
+    paths.push(lockPathFor(path.basename(path.dirname(tokenPath)), `dir:${tokenPath}`));
   }
   for (const vaultKey of await vaultCredentialKeys(definition)) {
     paths.push(lockPathFor(vaultKey.split("|")[0] ?? "", `vault:${vaultKey}`));
@@ -690,15 +107,15 @@ function resolveTimeoutMs(explicit) {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
 }
 function lockPathFor(label, identity) {
-  const digest = crypto.createHash("sha256").update(identity).digest("hex").slice(0, IDENTITY_HASH_LENGTH);
+  const digest = crypto.hash("sha256", identity, "hex").slice(0, IDENTITY_HASH_LENGTH);
   const safeLabel = filenameSafeLabel(label);
-  return path2.join(refreshLockDir(), safeLabel.length > 0 ? `${safeLabel}-${digest}` : digest);
+  return path.join(refreshLockDir(), safeLabel.length > 0 ? `${safeLabel}-${digest}` : digest);
 }
 function filenameSafeLabel(value) {
   return value.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^[._-]+/, "").slice(0, LOCK_LABEL_MAX);
 }
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-token-refresh.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-token-refresh.js
 var TOKEN_EXPIRY_SKEW_SECONDS = 60;
 var TOKEN_REQUEST_TIMEOUT_MS = 1e4;
 var OAuthIssuerMismatchError = class extends Error {
@@ -1093,7 +510,7 @@ function readClientSecret(definition, refreshClientSecretEnv) {
   return resolveOAuthClientSecret(definition, { rejectBlank: true });
 }
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/oauth-persistence.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth-persistence.js
 async function buildOAuthPersistence(definition, logger) {
   return await createOAuthPersistenceStores(definition, logger);
 }
@@ -1101,7 +518,7 @@ async function clearOAuthCaches(definition, logger, scope = "all") {
   const persistence = await buildOAuthPersistence(definition, logger);
   await persistence.clear(scope);
   if (definition.tokenCacheDir && scope === "all") {
-    await fs2.rm(definition.tokenCacheDir, { recursive: true, force: true });
+    await fs.rm(definition.tokenCacheDir, { recursive: true, force: true });
   }
   await clearLegacyOAuthArtifacts(definition, logger, scope);
 }

package/dist/mcp-chunks/{chunk-V4RYLZM5.js → chunk-B2LNXGAP.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.13.7/node_modules/mcporter/dist/stable-json.js
+// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/stable-json.js
 function stableJsonStringify(value, space) {
   const json = JSON.stringify(sortJsonValue(value), void 0, space);
   if (json === void 0) {