@sentry/junior 0.1.0 → 0.2.0

package/dist/chunk-ZBFSIN6G.js

@@ -1,323 +0,0 @@
-import {
-  hasRedisConfig
-} from "./chunk-GDNDYMGX.js";
-
-// src/chat/state.ts
-import { createRedisState } from "@chat-adapter/state-redis";
-import { createMemoryState } from "@chat-adapter/state-memory";
-var MIN_LOCK_TTL_MS = 1e3 * 60 * 5;
-var QUEUE_INGRESS_DEDUP_PREFIX = "junior:queue_ingress";
-var QUEUE_MESSAGE_PROCESSING_PREFIX = "junior:queue_message";
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var QUEUE_MESSAGE_PROCESSING_TTL_MS = 30 * 60 * 1e3;
-var QUEUE_MESSAGE_COMPLETED_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var QUEUE_MESSAGE_FAILED_TTL_MS = 6 * 60 * 60 * 1e3;
-var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-var CLAIM_OR_RECLAIM_PROCESSING_SCRIPT = `
-  local key = KEYS[1]
-  local nowMs = tonumber(ARGV[1])
-  local ttlMs = tonumber(ARGV[2])
-  local payload = ARGV[3]
-  local current = redis.call("get", key)
-
-  if not current then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 1
-  end
-
-  local ok, parsed = pcall(cjson.decode, current)
-  if not ok or type(parsed) ~= "table" then
-    return 0
-  end
-
-  local status = parsed["status"]
-  if status == "failed" then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 3
-  end
-  if status ~= "processing" then
-    return 0
-  end
-
-  local updatedAtMs = tonumber(parsed["updatedAtMs"])
-  if not updatedAtMs then
-    return 0
-  end
-
-  if updatedAtMs + ttlMs < nowMs then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 2
-  end
-
-  return 0
-`;
-var UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT = `
-  local key = KEYS[1]
-  local ownerToken = ARGV[1]
-  local ttlMs = tonumber(ARGV[2])
-  local payload = ARGV[3]
-  local current = redis.call("get", key)
-
-  if not current then
-    return 0
-  end
-
-  local ok, parsed = pcall(cjson.decode, current)
-  if not ok or type(parsed) ~= "table" then
-    return 0
-  end
-
-  local currentOwner = parsed["ownerToken"]
-  local status = parsed["status"]
-  if currentOwner ~= ownerToken then
-    return 0
-  end
-  if status ~= "processing" then
-    return 0
-  end
-
-  redis.call("set", key, payload, "PX", ttlMs)
-  return 1
-`;
-function createQueuedStateAdapter(base) {
-  const acquireLock = async (threadId, ttlMs) => {
-    const effectiveTtlMs = Math.max(ttlMs, MIN_LOCK_TTL_MS);
-    const lock = await base.acquireLock(threadId, effectiveTtlMs);
-    return lock;
-  };
-  return {
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => base.subscribe(threadId),
-    unsubscribe: (threadId) => base.unsubscribe(threadId),
-    isSubscribed: (threadId) => base.isSubscribed(threadId),
-    acquireLock,
-    releaseLock: (lock) => base.releaseLock(lock),
-    extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
-    get: (key) => base.get(key),
-    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
-    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
-    delete: (key) => base.delete(key)
-  };
-}
-function createStateAdapter() {
-  if (process.env.JUNIOR_STATE_ADAPTER?.trim().toLowerCase() === "memory") {
-    _redisStateAdapter = void 0;
-    return createQueuedStateAdapter(createMemoryState());
-  }
-  if (!hasRedisConfig()) {
-    throw new Error("REDIS_URL is required for durable Slack thread state");
-  }
-  const redisState = createRedisState({
-    url: process.env.REDIS_URL
-  });
-  _redisStateAdapter = redisState;
-  return createQueuedStateAdapter(redisState);
-}
-var _stateAdapter;
-var _redisStateAdapter;
-function getRedisStateAdapter() {
-  if (!_redisStateAdapter) {
-    getStateAdapter();
-  }
-  if (!_redisStateAdapter) {
-    throw new Error("Redis state adapter is unavailable for this runtime");
-  }
-  return _redisStateAdapter;
-}
-function queueMessageKey(rawKey) {
-  return `${QUEUE_MESSAGE_PROCESSING_PREFIX}:${rawKey}`;
-}
-function parseQueueMessageState(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!parsed || parsed.status !== "processing" && parsed.status !== "completed" && parsed.status !== "failed" || typeof parsed.updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      status: parsed.status,
-      updatedAtMs: parsed.updatedAtMs,
-      ...typeof parsed.ownerToken === "string" ? { ownerToken: parsed.ownerToken } : {},
-      ...typeof parsed.queueMessageId === "string" ? { queueMessageId: parsed.queueMessageId } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function parseAgentTurnSessionCheckpoint(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    const status = parsed.state;
-    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed") {
-      return void 0;
-    }
-    const conversationId = parsed.conversationId;
-    const sessionId = parsed.sessionId;
-    const sliceId = parsed.sliceId;
-    const checkpointVersion = parsed.checkpointVersion;
-    const updatedAtMs = parsed.updatedAtMs;
-    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function getStateAdapter() {
-  if (!_stateAdapter) {
-    _stateAdapter = createStateAdapter();
-  }
-  return _stateAdapter;
-}
-async function claimQueueIngressDedup(rawKey, ttlMs) {
-  await getStateAdapter().connect();
-  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
-  const result = await getRedisStateAdapter().getClient().set(key, "1", {
-    NX: true,
-    PX: ttlMs
-  });
-  return result === "OK";
-}
-async function hasQueueIngressDedup(rawKey) {
-  await getStateAdapter().connect();
-  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
-  const value = await getRedisStateAdapter().getClient().get(key);
-  return typeof value === "string" && value.length > 0;
-}
-async function getQueueMessageProcessingState(rawKey) {
-  await getStateAdapter().connect();
-  const state = await getStateAdapter().get(queueMessageKey(rawKey));
-  return parseQueueMessageState(state);
-}
-async function acquireQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const key = queueMessageKey(args.rawKey);
-  const nowMs = Date.now();
-  const payload = JSON.stringify({
-    status: "processing",
-    updatedAtMs: nowMs,
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().getClient().eval(CLAIM_OR_RECLAIM_PROCESSING_SCRIPT, {
-    keys: [key],
-    arguments: [String(nowMs), String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
-  });
-  if (result === 1) {
-    return "acquired";
-  }
-  if (result === 2) {
-    return "reclaimed";
-  }
-  if (result === 3) {
-    return "recovered";
-  }
-  return "blocked";
-}
-async function refreshQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const nowMs = Date.now();
-  const payload = JSON.stringify({
-    status: "processing",
-    updatedAtMs: nowMs,
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-    keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
-  });
-  return result === 1;
-}
-async function completeQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const payload = JSON.stringify({
-    status: "completed",
-    updatedAtMs: Date.now(),
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-    keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_COMPLETED_TTL_MS), payload]
-  });
-  return result === 1;
-}
-async function failQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const payload = JSON.stringify({
-    status: "failed",
-    updatedAtMs: Date.now(),
-    ownerToken: args.ownerToken,
-    errorMessage: args.errorMessage,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-    keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_FAILED_TTL_MS), payload]
-  });
-  return result === 1;
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  await getStateAdapter().connect();
-  const value = await getStateAdapter().get(agentTurnSessionKey(conversationId, sessionId));
-  return parseAgentTurnSessionCheckpoint(value);
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  await getStateAdapter().connect();
-  const existing = await getAgentTurnSessionCheckpoint(args.conversationId, args.sessionId);
-  const checkpoint = {
-    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await getStateAdapter().set(agentTurnSessionKey(args.conversationId, args.sessionId), JSON.stringify(checkpoint), ttlMs);
-  return checkpoint;
-}
-
-export {
-  getStateAdapter,
-  claimQueueIngressDedup,
-  hasQueueIngressDedup,
-  getQueueMessageProcessingState,
-  acquireQueueMessageProcessingOwnership,
-  refreshQueueMessageProcessingOwnership,
-  completeQueueMessageProcessingOwnership,
-  failQueueMessageProcessingOwnership,
-  getAgentTurnSessionCheckpoint,
-  upsertAgentTurnSessionCheckpoint
-};

package/dist/client-3GAEMIQ3.js

@@ -1,10 +0,0 @@
-import {
-  createQueueCallbackHandler,
-  enqueueThreadMessage,
-  getThreadMessageTopic
-} from "./chunk-ZA2IDPVG.js";
-export {
-  createQueueCallbackHandler,
-  enqueueThreadMessage,
-  getThreadMessageTopic
-};

package/dist/route-XLYK6CKP.js

@@ -1,309 +0,0 @@
-import {
-  escapeXml,
-  generateAssistantReply,
-  getOAuthProviderConfig,
-  getUserTokenStore,
-  publishAppHomeView,
-  resolveBaseUrl,
-  truncateStatusText
-} from "./chunk-7E56WM6K.js";
-import {
-  getStateAdapter
-} from "./chunk-ZBFSIN6G.js";
-import "./chunk-MM3YNA4F.js";
-import {
-  botConfig,
-  getSlackClient
-} from "./chunk-GDNDYMGX.js";
-import {
-  logException,
-  logInfo
-} from "./chunk-BBOVH5RF.js";
-
-// app/api/oauth/callback/[provider]/route.ts
-import { after } from "next/server";
-var runtime = "nodejs";
-function htmlErrorResponse(title, message, status) {
-  const safeTitle = escapeXml(title);
-  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>${message}</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 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((e) => e.key === key),
-    set: async () => {
-      throw new Error("Read-only configuration in resumed context");
-    },
-    unset: async () => false,
-    list: async ({ prefix } = {}) => entries.filter((e) => !prefix || e.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 resumePendingMessage(stored) {
-  if (!stored.pendingMessage || !stored.channelId || !stored.threadTs) return;
-  const providerLabel = stored.provider.charAt(0).toUpperCase() + stored.provider.slice(1);
-  await postSlackMessage(
-    stored.channelId,
-    stored.threadTs,
-    `Your ${providerLabel} account is now connected. Processing your request...`
-  );
-  const postStatus = createDebouncedStatusPoster(stored.channelId, stored.threadTs);
-  await setAssistantStatus(stored.channelId, stored.threadTs, "Thinking...");
-  try {
-    const reply = await generateAssistantReply(stored.pendingMessage, {
-      assistant: { userName: botConfig.userName },
-      requester: { userId: stored.userId },
-      correlation: {
-        channelId: stored.channelId,
-        threadTs: stored.threadTs,
-        requesterId: stored.userId
-      },
-      configuration: stored.configuration,
-      channelConfiguration: stored.configuration ? createReadOnlyConfigService(stored.configuration) : void 0,
-      onStatus: postStatus
-    });
-    postStatus.stop();
-    if (reply.text) {
-      await postSlackMessage(stored.channelId, stored.threadTs, reply.text);
-    }
-    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"
-    );
-  } catch (error) {
-    postStatus.stop();
-    logException(
-      error,
-      "oauth_callback_resume_failed",
-      {},
-      { "app.credential.provider": stored.provider },
-      "Failed to auto-resume pending message after OAuth callback"
-    );
-    await postSlackMessage(
-      stored.channelId,
-      stored.threadTs,
-      `I connected your account but hit an error processing your request. Please try \`${stored.pendingMessage}\` again.`
-    );
-  }
-}
-async function GET(request, context) {
-  const { provider } = await context.params;
-  const providerConfig = getOAuthProviderConfig(provider);
-  if (!providerConfig) {
-    return htmlErrorResponse("Unknown provider", "The OAuth provider in this link is not recognized.", 404);
-  }
-  const providerLabel = provider.charAt(0).toUpperCase() + provider.slice(1);
-  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 run the auth command again if you change your mind.`,
-        400
-      );
-    }
-    return htmlErrorResponse(
-      "Authorization failed",
-      `${providerLabel} returned an error: ${escapeXml(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 to connect your ${providerLabel} account again, or retry your original command 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 {
-    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        code,
-        client_id: clientId,
-        client_secret: clientSecret,
-        redirect_uri: redirectUri
-      })
-    });
-  } 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();
-  if (!tokenData.access_token || !tokenData.refresh_token || typeof tokenData.expires_in !== "number") {
-    return htmlErrorResponse("Connection failed", "The provider returned an incomplete token response. Please try again.", 500);
-  }
-  const accessToken = tokenData.access_token;
-  const refreshToken = tokenData.refresh_token;
-  const expiresAt = Date.now() + tokenData.expires_in * 1e3;
-  const userTokenStore = getUserTokenStore();
-  await userTokenStore.set(stored.userId, provider, {
-    accessToken,
-    refreshToken,
-    expiresAt
-  });
-  after(async () => {
-    try {
-      await publishAppHomeView(getSlackClient(), stored.userId, userTokenStore);
-    } catch {
-    }
-  });
-  if (stored.pendingMessage && stored.channelId && stored.threadTs) {
-    after(() => resumePendingMessage(stored));
-  } else if (stored.channelId && stored.threadTs) {
-    after(async () => {
-      await postSlackMessage(
-        stored.channelId,
-        stored.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" }
-  });
-}
-export {
-  GET,
-  runtime
-};