@sentry/junior 0.10.3 → 0.11.1

package/dist/handlers/router.js

@@ -1,827 +0,0 @@
-import {
-  POST,
-  buildConversationContext,
-  buildSlackOutputMessage,
-  coerceThreadArtifactsState,
-  coerceThreadConversationState,
-  createUserTokenStore,
-  deleteMcpAuthSession,
-  escapeXml,
-  finalizeMcpAuthorization,
-  formatProviderLabel,
-  generateAssistantReply,
-  generateConversationId,
-  getPersistedThreadState,
-  getSlackClient,
-  isRetryableTurnError,
-  markConversationMessage,
-  markTurnCompleted,
-  markTurnFailed,
-  maxDuration,
-  mergeArtifactsState,
-  normalizeConversationText,
-  persistThreadStateById,
-  publishAppHomeView,
-  resolveBaseUrl,
-  resolveReplyDelivery,
-  truncateStatusText,
-  updateConversationStats,
-  uploadFilesToThread,
-  upsertConversationMessage
-} from "../chunk-ASAQ64YN.js";
-import {
-  GET
-} from "../chunk-4RBEYCOG.js";
-import "../chunk-573MJIST.js";
-import {
-  botConfig,
-  getStateAdapter
-} from "../chunk-FNYLIUOK.js";
-import {
-  buildOAuthTokenRequest,
-  getPluginOAuthConfig,
-  logException,
-  logInfo,
-  logWarn,
-  parseOAuthTokenResponse
-} from "../chunk-AVIUX5XL.js";
-import "../chunk-KCLEEKYX.js";
-
-// src/handlers/mcp-oauth-callback.ts
-import { Buffer } from "buffer";
-import { after } from "next/server";
-
-// src/handlers/oauth-resume.ts
-function resolveReplyTimeoutMs(explicitTimeoutMs) {
-  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
-    return explicitTimeoutMs;
-  }
-  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
-  if (!raw) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
-}
-async function postSlackMessage(channelId, threadTs, text) {
-  try {
-    await getSlackClient().chat.postMessage({
-      channel: channelId,
-      thread_ts: threadTs,
-      text
-    });
-  } catch {
-  }
-}
-async function setAssistantStatus(channelId, threadTs, status) {
-  try {
-    await getSlackClient().assistant.threads.setStatus({
-      channel_id: channelId,
-      thread_ts: threadTs,
-      status
-    });
-  } catch {
-  }
-}
-var STATUS_DEBOUNCE_MS = 1e3;
-function createDebouncedStatusPoster(channelId, threadTs) {
-  let lastPostAt = 0;
-  let currentStatus = "";
-  let pendingStatus = null;
-  let pendingTimer = null;
-  let stopped = false;
-  const flush = async () => {
-    if (stopped || !pendingStatus) return;
-    const status = pendingStatus;
-    pendingStatus = null;
-    pendingTimer = null;
-    lastPostAt = Date.now();
-    currentStatus = status;
-    await setAssistantStatus(channelId, threadTs, status);
-  };
-  const post = async (status) => {
-    if (stopped) return;
-    const truncated = truncateStatusText(status);
-    if (!truncated || truncated === currentStatus) return;
-    const now = Date.now();
-    const elapsed = now - lastPostAt;
-    if (elapsed >= STATUS_DEBOUNCE_MS) {
-      if (pendingTimer) {
-        clearTimeout(pendingTimer);
-        pendingTimer = null;
-      }
-      pendingStatus = null;
-      lastPostAt = now;
-      currentStatus = truncated;
-      await setAssistantStatus(channelId, threadTs, truncated);
-      return;
-    }
-    pendingStatus = truncated;
-    if (!pendingTimer) {
-      pendingTimer = setTimeout(
-        () => {
-          void flush();
-        },
-        Math.max(1, STATUS_DEBOUNCE_MS - elapsed)
-      );
-    }
-  };
-  post.stop = () => {
-    stopped = true;
-    if (pendingTimer) {
-      clearTimeout(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-  };
-  return post;
-}
-function createReadOnlyConfigService(values) {
-  const entries = Object.entries(values).map(([key, value]) => ({
-    key,
-    value,
-    scope: "conversation",
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }));
-  return {
-    get: async (key) => entries.find((entry) => entry.key === key),
-    set: async () => {
-      throw new Error("Read-only configuration in resumed context");
-    },
-    unset: async () => false,
-    list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
-    resolve: async (key) => values[key],
-    resolveValues: async ({ keys, prefix } = {}) => {
-      const filtered = {};
-      for (const [key, value] of Object.entries(values)) {
-        if (prefix && !key.startsWith(prefix)) continue;
-        if (keys && !keys.includes(key)) continue;
-        filtered[key] = value;
-      }
-      return filtered;
-    }
-  };
-}
-async function resumeAuthorizedRequest(args) {
-  const postStatus = createDebouncedStatusPoster(args.channelId, args.threadTs);
-  await postSlackMessage(args.channelId, args.threadTs, args.connectedText);
-  await setAssistantStatus(args.channelId, args.threadTs, "Thinking...");
-  try {
-    const generateReply = args.generateReply ?? generateAssistantReply;
-    const replyPromise = generateReply(args.messageText, {
-      assistant: { userName: botConfig.userName },
-      requester: { userId: args.requesterUserId },
-      correlation: {
-        conversationId: args.correlation?.conversationId,
-        turnId: args.correlation?.turnId,
-        channelId: args.correlation?.channelId ?? args.channelId,
-        threadTs: args.correlation?.threadTs ?? args.threadTs,
-        requesterId: args.correlation?.requesterId ?? args.requesterUserId
-      },
-      toolChannelId: args.toolChannelId,
-      conversationContext: args.conversationContext,
-      artifactState: args.artifactState,
-      configuration: args.configuration,
-      channelConfiguration: args.configuration ? createReadOnlyConfigService(args.configuration) : void 0,
-      onStatus: postStatus
-    });
-    const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
-    const reply = typeof replyTimeoutMs === "number" ? await Promise.race([
-      replyPromise,
-      new Promise(
-        (_, reject) => setTimeout(
-          () => reject(
-            new Error(
-              `generateAssistantReply timed out after ${replyTimeoutMs}ms`
-            )
-          ),
-          replyTimeoutMs
-        )
-      )
-    ]) : await replyPromise;
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
-    if (args.onReply) {
-      await args.onReply(reply);
-    } else if (reply.text) {
-      await postSlackMessage(args.channelId, args.threadTs, reply.text);
-    }
-    await args.onSuccess?.(reply);
-  } catch (error) {
-    postStatus.stop();
-    await setAssistantStatus(args.channelId, args.threadTs, "");
-    if (isRetryableTurnError(error, "mcp_auth_resume") && args.onAuthPause) {
-      await args.onAuthPause(error);
-      return;
-    }
-    await args.onFailure?.(error);
-    await postSlackMessage(args.channelId, args.threadTs, args.failureText);
-  }
-}
-
-// src/handlers/mcp-oauth-callback.ts
-var CALLBACK_PAGES = {
-  missing_state: {
-    title: "Authorization failed",
-    message: "Missing state parameter.",
-    status: 400
-  },
-  provider_error: {
-    title: "Authorization failed",
-    message: "The provider returned an authorization error.",
-    status: 400
-  },
-  missing_code: {
-    title: "Authorization failed",
-    message: "Missing code parameter.",
-    status: 400
-  },
-  success: {
-    title: "Authorization complete",
-    message: "Your MCP access is connected. Junior will continue the paused request in Slack.",
-    status: 200
-  },
-  failure: {
-    title: "Authorization failed",
-    message: "Junior could not finish the authorization callback. Return to Slack and retry the original request.",
-    status: 500
-  }
-};
-function htmlResponse(kind) {
-  const page = CALLBACK_PAGES[kind];
-  const html = `<!DOCTYPE html>
-<html>
-<head><title>${page.title}</title></head>
-<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
-  <div style="text-align: center; max-width: 480px;">
-    <h1>${page.title}</h1>
-    <p>${page.message}</p>
-    <p style="margin-top: 2rem; color: #666; font-size: 0.9em;">You can close this tab and return to Slack.</p>
-  </div>
-</body>
-</html>`;
-  return new Response(html, {
-    status: page.status,
-    headers: { "Content-Type": "text/html; charset=utf-8" }
-  });
-}
-function extractSlackText(text, files) {
-  const message = buildSlackOutputMessage(text, files);
-  if (typeof message === "object" && message !== null && "markdown" in message && typeof message.markdown === "string") {
-    return message.markdown;
-  }
-  if (typeof message === "object" && message !== null && "raw" in message && typeof message.raw === "string") {
-    return message.raw;
-  }
-  return text;
-}
-async function normalizeFileUploads(files) {
-  const normalized = [];
-  for (const file of files) {
-    let data;
-    if (Buffer.isBuffer(file.data)) {
-      data = file.data;
-    } else if (file.data instanceof ArrayBuffer) {
-      data = Buffer.from(file.data);
-    } else {
-      data = Buffer.from(await file.data.arrayBuffer());
-    }
-    normalized.push({
-      data,
-      filename: file.filename
-    });
-  }
-  return normalized;
-}
-async function deliverReplyToThread(channelId, threadTs, reply) {
-  const replyFiles = reply.files && reply.files.length > 0 ? reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply,
-    hasStreamedThreadReply: false
-  });
-  if (shouldPostThreadReply) {
-    const text = extractSlackText(
-      reply.text,
-      attachFiles === "inline" ? replyFiles : void 0
-    );
-    if (text.trim().length > 0) {
-      await postSlackMessage(channelId, threadTs, text);
-    }
-  }
-  if (!replyFiles || attachFiles === "none") {
-    return;
-  }
-  const files = await normalizeFileUploads(replyFiles);
-  if (files.length === 0) {
-    return;
-  }
-  try {
-    await uploadFilesToThread({
-      channelId,
-      threadTs,
-      files
-    });
-  } catch {
-  }
-}
-function buildDeterministicTurnId(messageId) {
-  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return `turn_${sanitized}`;
-}
-function getUserMessageIdForTurn(conversation, sessionId) {
-  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
-    const message = conversation.messages[index];
-    if (message?.role !== "user") {
-      continue;
-    }
-    if (buildDeterministicTurnId(message.id) === sessionId) {
-      return message.id;
-    }
-  }
-  return void 0;
-}
-async function buildResumeConversationContext(channelId, threadTs, sessionId) {
-  const threadId = `slack:${channelId}:${threadTs}`;
-  const conversation = coerceThreadConversationState(
-    await getPersistedThreadState(threadId)
-  );
-  const userMessageId = getUserMessageIdForTurn(conversation, sessionId);
-  return buildConversationContext(conversation, {
-    excludeMessageId: userMessageId
-  });
-}
-async function persistCompletedReplyState(channelId, threadTs, sessionId, reply) {
-  const threadId = `slack:${channelId}:${threadTs}`;
-  const currentState = await getPersistedThreadState(threadId);
-  const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
-  const nextArtifacts = reply.artifactStatePatch ? mergeArtifactsState(artifacts, reply.artifactStatePatch) : void 0;
-  const userMessageId = getUserMessageIdForTurn(conversation, sessionId);
-  markConversationMessage(conversation, userMessageId, {
-    replied: true,
-    skippedReason: void 0
-  });
-  upsertConversationMessage(conversation, {
-    id: generateConversationId("assistant"),
-    role: "assistant",
-    text: normalizeConversationText(reply.text) || "[empty response]",
-    createdAtMs: Date.now(),
-    author: {
-      userName: botConfig.userName,
-      isBot: true
-    },
-    meta: {
-      replied: true
-    }
-  });
-  markTurnCompleted({
-    conversation,
-    nowMs: Date.now(),
-    updateConversationStats
-  });
-  await persistThreadStateById(threadId, {
-    artifacts: nextArtifacts,
-    conversation,
-    sandboxId: reply.sandboxId,
-    sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash
-  });
-}
-async function persistFailedReplyState(channelId, threadTs, sessionId) {
-  const threadId = `slack:${channelId}:${threadTs}`;
-  const currentState = await getPersistedThreadState(threadId);
-  const conversation = coerceThreadConversationState(currentState);
-  markTurnFailed({
-    conversation,
-    nowMs: Date.now(),
-    userMessageId: getUserMessageIdForTurn(conversation, sessionId),
-    markConversationMessage,
-    updateConversationStats
-  });
-  await persistThreadStateById(threadId, {
-    conversation
-  });
-}
-async function resumeAuthorizedMcpTurn(args) {
-  const { authSession, provider } = args;
-  if (!authSession.channelId || !authSession.threadTs) {
-    return;
-  }
-  const conversationContext = await buildResumeConversationContext(
-    authSession.channelId,
-    authSession.threadTs,
-    authSession.sessionId
-  );
-  await resumeAuthorizedRequest({
-    messageText: authSession.userMessage,
-    requesterUserId: authSession.userId,
-    provider,
-    channelId: authSession.channelId,
-    threadTs: authSession.threadTs,
-    connectedText: `Your ${provider} MCP access is now connected. Continuing the original request...`,
-    failureText: "MCP authorization completed, but resuming the request failed. Please retry the original command.",
-    correlation: {
-      conversationId: authSession.conversationId,
-      turnId: authSession.sessionId,
-      channelId: authSession.channelId,
-      threadTs: authSession.threadTs,
-      requesterId: authSession.userId
-    },
-    toolChannelId: authSession.toolChannelId ?? authSession.artifactState?.assistantContextChannelId ?? authSession.channelId,
-    conversationContext,
-    artifactState: authSession.artifactState,
-    configuration: authSession.configuration,
-    onReply: async (reply) => {
-      await deliverReplyToThread(
-        authSession.channelId,
-        authSession.threadTs,
-        reply
-      );
-    },
-    onSuccess: async (reply) => {
-      try {
-        await persistCompletedReplyState(
-          authSession.channelId,
-          authSession.threadTs,
-          authSession.sessionId,
-          reply
-        );
-      } catch (persistError) {
-        logException(
-          persistError,
-          "mcp_oauth_callback_resume_persist_failed",
-          {},
-          { "app.credential.provider": provider },
-          "Failed to persist resumed MCP turn state"
-        );
-      }
-    },
-    onFailure: async (error) => {
-      logException(
-        error,
-        "mcp_oauth_callback_resume_failed",
-        {},
-        { "app.credential.provider": provider },
-        "Failed to resume MCP-authorized turn"
-      );
-      try {
-        await persistFailedReplyState(
-          authSession.channelId,
-          authSession.threadTs,
-          authSession.sessionId
-        );
-      } catch (persistError) {
-        logException(
-          persistError,
-          "mcp_oauth_callback_resume_failure_persist_failed",
-          {},
-          { "app.credential.provider": provider },
-          "Failed to persist failed MCP resume state"
-        );
-      }
-    },
-    onAuthPause: async () => {
-      logWarn(
-        "mcp_oauth_callback_resume_reparked_for_auth",
-        {},
-        { "app.credential.provider": provider },
-        "Resumed MCP turn requested another authorization flow"
-      );
-    }
-  });
-}
-async function GET2(request, context) {
-  const { provider } = await context.params;
-  const url = new URL(request.url);
-  const state = url.searchParams.get("state")?.trim();
-  const code = url.searchParams.get("code")?.trim();
-  const error = url.searchParams.get("error")?.trim();
-  if (!state) {
-    return htmlResponse("missing_state");
-  }
-  if (error) {
-    return htmlResponse("provider_error");
-  }
-  if (!code) {
-    return htmlResponse("missing_code");
-  }
-  try {
-    const authSession = await finalizeMcpAuthorization(provider, state, code);
-    try {
-      await deleteMcpAuthSession(authSession.authSessionId);
-    } catch (cleanupError) {
-      logException(
-        cleanupError,
-        "mcp_oauth_callback_session_cleanup_failed",
-        {},
-        { "app.credential.provider": provider },
-        "Failed to delete completed MCP auth session"
-      );
-    }
-    after(async () => {
-      await resumeAuthorizedMcpTurn({
-        authSession,
-        provider
-      });
-    });
-    return htmlResponse("success");
-  } catch (callbackError) {
-    logException(
-      callbackError,
-      "mcp_oauth_callback_failed",
-      {},
-      { "app.credential.provider": provider },
-      "Failed to process MCP OAuth callback"
-    );
-    return htmlResponse("failure");
-  }
-}
-
-// src/handlers/oauth-callback.ts
-import { after as after2 } from "next/server";
-function htmlErrorResponse(title, message, status) {
-  const safeTitle = escapeXml(title);
-  const safeMessage = escapeXml(message);
-  const html = `<!DOCTYPE html>
-<html>
-<head><title>${safeTitle}</title></head>
-<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
-  <div style="text-align: center; max-width: 480px;">
-    <h1>${safeTitle}</h1>
-    <p>${safeMessage}</p>
-    <p style="margin-top: 2rem; color: #666; font-size: 0.9em;">You can close this tab and return to Slack to try again.</p>
-  </div>
-</body>
-</html>`;
-  return new Response(html, {
-    status,
-    headers: { "Content-Type": "text/html; charset=utf-8" }
-  });
-}
-async function buildResumeConversationContext2(channelId, threadTs) {
-  const conversation = coerceThreadConversationState(
-    await getPersistedThreadState(`slack:${channelId}:${threadTs}`)
-  );
-  const latestUserMessageId = [...conversation.messages].reverse().find((message) => message.role === "user")?.id;
-  return buildConversationContext(conversation, {
-    excludeMessageId: latestUserMessageId
-  });
-}
-async function resumePendingOAuthMessage(stored) {
-  if (!stored.pendingMessage || !stored.channelId || !stored.threadTs) return;
-  const providerLabel = formatProviderLabel(stored.provider);
-  const conversationContext = await buildResumeConversationContext2(
-    stored.channelId,
-    stored.threadTs
-  );
-  await resumeAuthorizedRequest({
-    messageText: stored.pendingMessage,
-    requesterUserId: stored.userId,
-    provider: stored.provider,
-    channelId: stored.channelId,
-    threadTs: stored.threadTs,
-    connectedText: `Your ${providerLabel} account is now connected. Processing your request...`,
-    failureText: `I connected your account but hit an error processing your request. Please try \`${stored.pendingMessage}\` again.`,
-    conversationContext,
-    configuration: stored.configuration,
-    onSuccess: async (reply) => {
-      logInfo(
-        "oauth_callback_resume_complete",
-        {},
-        {
-          "app.credential.provider": stored.provider,
-          "app.ai.outcome": reply.diagnostics.outcome,
-          "app.ai.tool_calls": reply.diagnostics.toolCalls.length
-        },
-        "Auto-resumed pending message after OAuth callback"
-      );
-    },
-    onFailure: async (error) => {
-      logException(
-        error,
-        "oauth_callback_resume_failed",
-        {},
-        { "app.credential.provider": stored.provider },
-        "Failed to auto-resume pending message after OAuth callback"
-      );
-    }
-  });
-}
-async function GET3(request, context) {
-  const { provider } = await context.params;
-  const providerConfig = getPluginOAuthConfig(provider);
-  if (!providerConfig) {
-    return htmlErrorResponse(
-      "Unknown provider",
-      "The OAuth provider in this link is not recognized.",
-      404
-    );
-  }
-  const providerLabel = formatProviderLabel(provider);
-  const url = new URL(request.url);
-  const errorParam = url.searchParams.get("error");
-  const code = url.searchParams.get("code");
-  const state = url.searchParams.get("state");
-  if (errorParam) {
-    if (state) {
-      const cleanupAdapter = getStateAdapter();
-      await cleanupAdapter.delete(`oauth-state:${state}`);
-    }
-    if (errorParam === "access_denied") {
-      return htmlErrorResponse(
-        "Authorization declined",
-        `You declined the ${providerLabel} authorization request. Return to Slack and ask Junior to connect your ${providerLabel} account again if you change your mind.`,
-        400
-      );
-    }
-    return htmlErrorResponse(
-      "Authorization failed",
-      `${providerLabel} returned an error: ${errorParam}. Return to Slack and try again.`,
-      400
-    );
-  }
-  if (!code || !state) {
-    return htmlErrorResponse(
-      "Invalid request",
-      "This authorization link is missing required parameters.",
-      400
-    );
-  }
-  const stateAdapter = getStateAdapter();
-  const stateKey = `oauth-state:${state}`;
-  const stored = await stateAdapter.get(stateKey);
-  if (!stored) {
-    return htmlErrorResponse(
-      "Link expired",
-      `This authorization link has expired (links are valid for 10 minutes). Return to Slack and ask Junior to connect your ${providerLabel} account again to get a new link.`,
-      400
-    );
-  }
-  if (stored.provider !== provider) {
-    return htmlErrorResponse(
-      "Provider mismatch",
-      "This authorization link does not match the expected provider.",
-      400
-    );
-  }
-  await stateAdapter.delete(stateKey);
-  const clientId = process.env[providerConfig.clientIdEnv]?.trim();
-  const clientSecret = process.env[providerConfig.clientSecretEnv]?.trim();
-  if (!clientId || !clientSecret) {
-    return htmlErrorResponse(
-      "Configuration error",
-      "OAuth client credentials are not configured on the server.",
-      500
-    );
-  }
-  const baseUrl = resolveBaseUrl();
-  if (!baseUrl) {
-    return htmlErrorResponse(
-      "Configuration error",
-      "The server cannot determine its base URL.",
-      500
-    );
-  }
-  const redirectUri = `${baseUrl}${providerConfig.callbackPath}`;
-  let tokenResponse;
-  try {
-    const tokenRequest = buildOAuthTokenRequest({
-      clientId,
-      clientSecret,
-      payload: {
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: redirectUri
-      },
-      tokenAuthMethod: providerConfig.tokenAuthMethod,
-      tokenExtraHeaders: providerConfig.tokenExtraHeaders
-    });
-    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
-      method: "POST",
-      headers: tokenRequest.headers,
-      body: tokenRequest.body
-    });
-  } catch {
-    return htmlErrorResponse(
-      "Connection failed",
-      "Failed to exchange the authorization code. Please try again.",
-      500
-    );
-  }
-  if (!tokenResponse.ok) {
-    return htmlErrorResponse(
-      "Connection failed",
-      "The token exchange with the provider failed. Please try again.",
-      500
-    );
-  }
-  const tokenData = await tokenResponse.json();
-  let parsedTokenResponse;
-  try {
-    parsedTokenResponse = parseOAuthTokenResponse(tokenData);
-  } catch {
-    return htmlErrorResponse(
-      "Connection failed",
-      "The provider returned an incomplete token response. Please try again.",
-      500
-    );
-  }
-  const userTokenStore = createUserTokenStore();
-  await userTokenStore.set(stored.userId, provider, parsedTokenResponse);
-  after2(async () => {
-    try {
-      await publishAppHomeView(getSlackClient(), stored.userId, userTokenStore);
-    } catch {
-    }
-  });
-  if (stored.pendingMessage && stored.channelId && stored.threadTs) {
-    after2(() => resumePendingOAuthMessage(stored));
-  } else if (stored.channelId && stored.threadTs) {
-    const { channelId, threadTs } = stored;
-    after2(async () => {
-      await postSlackMessage(
-        channelId,
-        threadTs,
-        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
-      );
-    });
-  }
-  const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
-  const html = `<!DOCTYPE html>
-<html>
-<head><title>${providerLabel} Connected</title></head>
-<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
-  <div style="text-align: center;">
-    <h1>${providerLabel} account connected</h1>
-    <p>${statusMessage}</p>
-  </div>
-</body>
-</html>`;
-  return new Response(html, {
-    status: 200,
-    headers: { "Content-Type": "text/html; charset=utf-8" }
-  });
-}
-
-// src/handlers/router.ts
-function trimEdgeSlashes(value) {
-  let start = 0;
-  let end = value.length;
-  while (start < end && value[start] === "/") {
-    start += 1;
-  }
-  while (end > start && value[end - 1] === "/") {
-    end -= 1;
-  }
-  return value.slice(start, end);
-}
-function normalizeRoutePath(pathParts) {
-  const route = trimEdgeSlashes(pathParts.join("/"));
-  return route.startsWith("api/") ? route.slice("api/".length) : route;
-}
-function getRoutePathParts(params) {
-  if (!params || typeof params !== "object" || !("path" in params)) {
-    return [];
-  }
-  const candidate = params.path;
-  if (!Array.isArray(candidate) || candidate.some((segment) => typeof segment !== "string")) {
-    return [];
-  }
-  return candidate;
-}
-async function GET4(request, context) {
-  const route = normalizeRoutePath(getRoutePathParts(await context.params));
-  if (route === "health") {
-    return GET();
-  }
-  const mcpOauthCallbackMatch = route.match(/^oauth\/callback\/mcp\/([^/]+)$/);
-  if (mcpOauthCallbackMatch) {
-    const provider = mcpOauthCallbackMatch[1];
-    return GET2(request, {
-      params: Promise.resolve({ provider })
-    });
-  }
-  const oauthCallbackMatch = route.match(/^oauth\/callback\/([^/]+)$/);
-  if (oauthCallbackMatch) {
-    const provider = oauthCallbackMatch[1];
-    return GET3(request, {
-      params: Promise.resolve({ provider })
-    });
-  }
-  return new Response("Not Found", { status: 404 });
-}
-async function POST2(request, context) {
-  const route = normalizeRoutePath(getRoutePathParts(await context.params));
-  const webhookMatch = route.match(/^webhooks\/([^/]+)$/);
-  if (webhookMatch) {
-    const platform = webhookMatch[1];
-    return POST(request, {
-      params: Promise.resolve({ platform })
-    });
-  }
-  return new Response("Not Found", { status: 404 });
-}
-export {
-  GET4 as GET,
-  POST2 as POST,
-  maxDuration
-};