@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-BZIQOWE6.js

@@ -0,0 +1,267 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  analyzeConnectionError
+} from "./chunk-UKYNQGNE.js";
+import {
+  auth
+} from "./chunk-P3PSC54P.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/runtime-oauth-support.js
+function maybeEnableOAuth(definition, logger) {
+  if (definition.auth === "oauth" || definition.auth === "refreshable_bearer") {
+    return void 0;
+  }
+  if (definition.command.kind !== "http") {
+    return void 0;
+  }
+  logger.info(`Detected OAuth requirement for '${definition.name}'. Launching browser flow...`);
+  return {
+    ...definition,
+    auth: "oauth"
+  };
+}
+function isUnauthorizedError(error) {
+  const issue = analyzeConnectionError(error);
+  return issue.kind === "auth";
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/runtime/oauth.js
+var DEFAULT_OAUTH_CODE_TIMEOUT_MS = 3e5;
+var OAUTH_FLOW_ERROR = /* @__PURE__ */ Symbol("oauth-flow-error");
+var POST_AUTH_CONNECT_ERROR = /* @__PURE__ */ Symbol("post-auth-connect-error");
+var MAX_OAUTH_ERROR_DETAIL_LENGTH = 1200;
+var PROACTIVE_TOKEN_SKEW_SECONDS = 60;
+var OAuthTimeoutError = class extends Error {
+  timeoutMs;
+  serverName;
+  constructor(serverName, timeoutMs) {
+    const seconds = Math.round(timeoutMs / 1e3);
+    super(`OAuth authorization for '${serverName}' timed out after ${seconds}s; aborting.`);
+    this.name = "OAuthTimeoutError";
+    this.timeoutMs = timeoutMs;
+    this.serverName = serverName;
+  }
+};
+var OAuthAuthorizationNotStartedError = class extends Error {
+  serverName;
+  constructor(serverName, cause) {
+    const causeMessage = formatOAuthErrorDetail(cause);
+    const detail = causeMessage ? ` Last error: ${causeMessage}` : "";
+    super(`OAuth authorization for '${serverName}' did not produce an authorization URL; aborting instead of waiting for a browser callback.${detail}`);
+    this.name = "OAuthAuthorizationNotStartedError";
+    this.serverName = serverName;
+  }
+};
+function formatOAuthErrorDetail(cause) {
+  if (!(cause instanceof Error) || !cause.message) {
+    return "";
+  }
+  return truncateOAuthErrorDetail(cause.message);
+}
+function truncateOAuthErrorDetail(message) {
+  if (message.length <= MAX_OAUTH_ERROR_DETAIL_LENGTH) {
+    return message;
+  }
+  const truncated = message.length - MAX_OAUTH_ERROR_DETAIL_LENGTH;
+  return `${message.slice(0, MAX_OAUTH_ERROR_DETAIL_LENGTH)}... [truncated ${truncated} chars]`;
+}
+function markOAuthFlowError(error) {
+  return markError(error, OAUTH_FLOW_ERROR);
+}
+function isOAuthFlowError(error) {
+  return hasErrorMarker(error, OAUTH_FLOW_ERROR);
+}
+function markPostAuthConnectError(error) {
+  return markError(error, POST_AUTH_CONNECT_ERROR);
+}
+function isPostAuthConnectError(error) {
+  return hasErrorMarker(error, POST_AUTH_CONNECT_ERROR);
+}
+function markError(error, marker) {
+  if (!error || typeof error !== "object" && typeof error !== "function") {
+    return error;
+  }
+  Object.defineProperty(error, marker, {
+    value: true,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+function hasErrorMarker(error, marker) {
+  return !!error && (typeof error === "object" || typeof error === "function") && marker in error && Boolean(error[marker]);
+}
+function hasUsableCachedAccessToken(tokens) {
+  if (!tokens || typeof tokens.access_token !== "string" || tokens.access_token.trim().length === 0) {
+    return false;
+  }
+  const stored = tokens;
+  const expiresAt = typeof stored.expires_at === "number" ? stored.expires_at : stored.expiresAt;
+  return typeof expiresAt === "number" && expiresAt > Math.floor(Date.now() / 1e3) + PROACTIVE_TOKEN_SKEW_SECONDS;
+}
+async function connectWithAuth(client, transport, session, logger, options = {}) {
+  const { serverName, maxAttempts = 3, oauthTimeoutMs = DEFAULT_OAUTH_CODE_TIMEOUT_MS, recreateTransport } = options;
+  const state = {
+    activeTransport: transport,
+    attempt: 0,
+    hasCompletedAuthFlow: false
+  };
+  while (true) {
+    try {
+      await attemptTransportConnect(client, state);
+      if (session && !state.hasCompletedAuthFlow && options.serverUrl) {
+        await completeProactiveAuthorization(state.activeTransport, session, logger, {
+          serverName,
+          oauthTimeoutMs,
+          serverUrl: options.serverUrl,
+          fetchFn: options.fetchFn
+        });
+        state.hasCompletedAuthFlow = true;
+      }
+      if (session && state.hasCompletedAuthFlow) {
+        await session.close().catch(() => {
+        });
+      }
+      return state.activeTransport;
+    } catch (error) {
+      const unauthorized = isUnauthorizedError(error);
+      if (!shouldRetryAuthorization(state, unauthorized, session)) {
+        await closeReplacementTransport(transport, state.activeTransport);
+        throw state.hasCompletedAuthFlow && !unauthorized ? markPostAuthConnectError(error) : error;
+      }
+      state.attempt += 1;
+      if (state.attempt > maxAttempts) {
+        await closeReplacementTransport(transport, state.activeTransport);
+        throw state.hasCompletedAuthFlow ? markPostAuthConnectError(error) : error;
+      }
+      if (session.hasAuthorizationRedirectStarted?.() !== false) {
+        logger.warn(`OAuth authorization required for '${serverName ?? "unknown"}'. Waiting for browser approval...`);
+      }
+      try {
+        state.activeTransport = await completeAuthorizationChallenge(state.activeTransport, session, logger, error, {
+          serverName,
+          oauthTimeoutMs,
+          recreateTransport
+        });
+        state.hasCompletedAuthFlow = true;
+        logger.info("Authorization code accepted. Retrying connection...");
+      } catch (authError) {
+        const message = authError instanceof OAuthAuthorizationNotStartedError ? "OAuth authorization could not start." : "OAuth authorization failed while waiting for callback.";
+        logger.error(message, authError);
+        await closeReplacementTransport(transport, state.activeTransport);
+        throw markOAuthFlowError(authError);
+      }
+    }
+  }
+}
+async function attemptTransportConnect(client, state) {
+  await client.connect(state.activeTransport);
+  return state.activeTransport;
+}
+function shouldRetryAuthorization(_state, unauthorized, session) {
+  if (!session || !unauthorized) {
+    return false;
+  }
+  return true;
+}
+async function closeReplacementTransport(originalTransport, activeTransport) {
+  if (activeTransport === originalTransport) {
+    return;
+  }
+  await activeTransport.close().catch(() => {
+  });
+}
+async function completeAuthorizationChallenge(transport, session, logger, connectError, options) {
+  if (session.hasAuthorizationRedirectStarted?.() === false) {
+    throw new OAuthAuthorizationNotStartedError(options.serverName ?? "unknown", connectError);
+  }
+  const code = await waitForAuthorizationCodeWithTimeout(session, logger, options.serverName, options.oauthTimeoutMs ?? DEFAULT_OAUTH_CODE_TIMEOUT_MS);
+  if (typeof transport.finishAuth !== "function") {
+    logger.warn("Transport does not support finishAuth; cannot complete OAuth flow automatically.");
+    throw connectError;
+  }
+  await transport.finishAuth(code);
+  if (!options.recreateTransport) {
+    return transport;
+  }
+  const nextTransport = await options.recreateTransport(transport);
+  await transport.close().catch(() => {
+  });
+  return nextTransport;
+}
+async function completeProactiveAuthorization(transport, session, logger, options) {
+  if (!options.serverUrl) {
+    return;
+  }
+  try {
+    const cachedTokens = await session.provider.tokens?.();
+    if (hasUsableCachedAccessToken(cachedTokens)) {
+      return;
+    }
+    const result = await auth(session.provider, {
+      serverUrl: options.serverUrl,
+      fetchFn: options.fetchFn
+    });
+    if (result !== "REDIRECT") {
+      await session.close().catch(() => {
+      });
+      return;
+    }
+    if (session.hasAuthorizationRedirectStarted?.() === false) {
+      throw new OAuthAuthorizationNotStartedError(options.serverName ?? "unknown");
+    }
+    logger.warn(`OAuth authorization required for '${options.serverName ?? "unknown"}'. Waiting for browser approval...`);
+    if (typeof transport.finishAuth !== "function") {
+      throw new Error("Transport does not support finishAuth; cannot complete OAuth flow automatically.");
+    }
+    const code = await waitForAuthorizationCodeWithTimeout(session, logger, options.serverName, options.oauthTimeoutMs ?? DEFAULT_OAUTH_CODE_TIMEOUT_MS);
+    await transport.finishAuth(code);
+    await session.close().catch(() => {
+    });
+  } catch (error) {
+    throw markOAuthFlowError(error);
+  }
+}
+function waitForAuthorizationCodeWithTimeout(session, logger, serverName, timeoutMs = DEFAULT_OAUTH_CODE_TIMEOUT_MS) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return session.waitForAuthorizationCode();
+  }
+  const displayName = serverName ?? "unknown";
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const error = new OAuthTimeoutError(displayName, timeoutMs);
+      logger.warn(error.message);
+      reject(error);
+    }, timeoutMs);
+    session.waitForAuthorizationCode().then((code) => {
+      clearTimeout(timer);
+      resolve(code);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function parseOAuthTimeout(raw) {
+  if (!raw) {
+    return DEFAULT_OAUTH_CODE_TIMEOUT_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_OAUTH_CODE_TIMEOUT_MS;
+  }
+  return parsed;
+}
+function resolveOAuthTimeoutFromEnv() {
+  return parseOAuthTimeout(process.env.MCPORTER_OAUTH_TIMEOUT_MS ?? process.env.MCPORTER_OAUTH_TIMEOUT);
+}
+
+export {
+  maybeEnableOAuth,
+  isUnauthorizedError,
+  OAuthTimeoutError,
+  isOAuthFlowError,
+  isPostAuthConnectError,
+  connectWithAuth,
+  resolveOAuthTimeoutFromEnv
+};