@sentry/junior 0.1.0

package/dist/chunk-ZBFSIN6G.js

@@ -0,0 +1,323 @@
+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

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

package/dist/handlers/health.d.ts

@@ -0,0 +1,3 @@
+declare function GET(): Promise<Response>;
+
+export { GET };

package/dist/handlers/health.js

@@ -0,0 +1,6 @@
+import {
+  GET
+} from "../chunk-4RBEYCOG.js";
+export {
+  GET
+};

package/dist/handlers/queue-callback.d.ts

@@ -0,0 +1,3 @@
+declare function POST(request: Request): Promise<Response>;
+
+export { POST };

package/dist/handlers/queue-callback.js

@@ -0,0 +1,272 @@
+import {
+  createQueueCallbackHandler,
+  getThreadMessageTopic
+} from "../chunk-ZA2IDPVG.js";
+import {
+  acquireQueueMessageProcessingOwnership,
+  completeQueueMessageProcessingOwnership,
+  failQueueMessageProcessingOwnership,
+  getQueueMessageProcessingState,
+  getStateAdapter,
+  refreshQueueMessageProcessingOwnership
+} from "../chunk-ZBFSIN6G.js";
+import {
+  downloadPrivateSlackFile
+} from "../chunk-GDNDYMGX.js";
+import {
+  createRequestContext,
+  logError,
+  logException,
+  logWarn,
+  setSpanStatus,
+  withContext,
+  withSpan
+} from "../chunk-BBOVH5RF.js";
+
+// src/chat/queue/process-thread-message.ts
+import { Message, ThreadImpl } from "chat";
+
+// src/chat/thread-runtime/process-thread-message-runtime.ts
+function rehydrateAttachmentFetchers(payload) {
+  for (const attachment of payload.message.attachments) {
+    if (!attachment.fetchData && attachment.url) {
+      attachment.fetchData = () => downloadPrivateSlackFile(attachment.url);
+    }
+  }
+}
+async function processThreadMessageRuntime(args) {
+  const { appSlackRuntime } = await import("../bot-DLML4Z7F.js");
+  const runtimePayload = {
+    message: args.message,
+    thread: args.thread
+  };
+  rehydrateAttachmentFetchers(runtimePayload);
+  if (args.kind === "new_mention") {
+    await appSlackRuntime.handleNewMention(args.thread, args.message, {
+      beforeFirstResponsePost: args.beforeFirstResponsePost
+    });
+    return;
+  }
+  if (args.kind === "subscribed_reply") {
+    await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
+      beforeFirstResponsePost: args.beforeFirstResponsePost,
+      preApprovedReply: true
+    });
+    return;
+  }
+  await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
+    beforeFirstResponsePost: args.beforeFirstResponsePost
+  });
+}
+
+// src/chat/queue/process-thread-message.ts
+var stateAdapterConnected = false;
+function isSerializedThread(thread) {
+  return typeof thread === "object" && thread !== null && thread._type === "chat:Thread";
+}
+function isSerializedMessage(message) {
+  return typeof message === "object" && message !== null && message._type === "chat:Message";
+}
+function getPayloadChannelId(payload) {
+  return payload.thread.channelId;
+}
+function getPayloadUserId(payload) {
+  return payload.message.author?.userId;
+}
+function createMessageOwnerToken() {
+  return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+var QueueMessageOwnershipError = class extends Error {
+  constructor(stage, dedupKey) {
+    super(`Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`);
+    this.name = "QueueMessageOwnershipError";
+  }
+};
+var defaultProcessQueuedThreadMessageDeps = {
+  clearProcessingReaction: async ({ channelId, timestamp }) => {
+    const { removeReactionFromMessage } = await import("../channel-HJO33DGJ.js");
+    await removeReactionFromMessage({
+      channelId,
+      timestamp,
+      emoji: "eyes"
+    });
+  },
+  logWarn,
+  processRuntime: processThreadMessageRuntime
+};
+function deserializeThread(thread) {
+  if (isSerializedThread(thread)) {
+    return ThreadImpl.fromJSON(thread);
+  }
+  return thread;
+}
+function deserializeMessage(message) {
+  if (isSerializedMessage(message)) {
+    return Message.fromJSON(message);
+  }
+  return message;
+}
+async function logThreadMessageFailure(payload, errorMessage) {
+  logError(
+    "queue_message_failed",
+    {
+      slackThreadId: payload.normalizedThreadId,
+      slackChannelId: getPayloadChannelId(payload),
+      slackUserId: getPayloadUserId(payload)
+    },
+    {
+      "messaging.message.id": payload.message.id,
+      "app.queue.message_kind": payload.kind,
+      "app.queue.message_id": payload.queueMessageId,
+      "error.message": errorMessage
+    },
+    "Queue message processing failed"
+  );
+}
+async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedThreadMessageDeps) {
+  const existingMessageState = await getQueueMessageProcessingState(payload.dedupKey);
+  if (existingMessageState?.status === "completed") {
+    return;
+  }
+  const ownerToken = createMessageOwnerToken();
+  const claimResult = await acquireQueueMessageProcessingOwnership({
+    rawKey: payload.dedupKey,
+    ownerToken,
+    queueMessageId: payload.queueMessageId
+  });
+  if (claimResult === "blocked") {
+    return;
+  }
+  const threadWasSerialized = isSerializedThread(payload.thread);
+  if (threadWasSerialized && !stateAdapterConnected) {
+    await getStateAdapter().connect();
+    stateAdapterConnected = true;
+  }
+  const runtimePayload = {
+    ...payload,
+    thread: deserializeThread(payload.thread),
+    message: deserializeMessage(payload.message)
+  };
+  try {
+    const refreshed = await refreshQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!refreshed) {
+      throw new QueueMessageOwnershipError("refresh", payload.dedupKey);
+    }
+    let reactionCleared = false;
+    const clearReactionBeforeFirstResponsePost = async () => {
+      if (reactionCleared) {
+        return;
+      }
+      reactionCleared = true;
+      try {
+        await deps.clearProcessingReaction({
+          channelId: runtimePayload.thread.channelId,
+          timestamp: runtimePayload.message.id
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        deps.logWarn(
+          "queue_processing_reaction_clear_failed",
+          {
+            slackThreadId: payload.normalizedThreadId,
+            slackChannelId: getPayloadChannelId(payload),
+            slackUserId: getPayloadUserId(payload)
+          },
+          {
+            "messaging.message.id": payload.message.id,
+            "app.queue.message_kind": payload.kind,
+            "app.queue.message_id": payload.queueMessageId,
+            "error.message": errorMessage
+          },
+          "Failed to remove processing reaction before sending queue response"
+        );
+      }
+    };
+    await deps.processRuntime({
+      kind: runtimePayload.kind,
+      thread: runtimePayload.thread,
+      message: runtimePayload.message,
+      beforeFirstResponsePost: clearReactionBeforeFirstResponsePost
+    });
+    const completed = await completeQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!completed) {
+      throw new QueueMessageOwnershipError("complete", payload.dedupKey);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await logThreadMessageFailure(payload, errorMessage);
+    const failed = await failQueueMessageProcessingOwnership({
+      rawKey: payload.dedupKey,
+      ownerToken,
+      errorMessage,
+      queueMessageId: payload.queueMessageId
+    });
+    if (!failed && !(error instanceof QueueMessageOwnershipError)) {
+      throw new Error(`Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`);
+    }
+    throw error;
+  }
+}
+
+// src/handlers/queue-callback.ts
+var callbackHandler = createQueueCallbackHandler(async (message, metadata) => {
+  const payload = {
+    ...message,
+    queueMessageId: metadata.messageId
+  };
+  if (metadata.topicName !== getThreadMessageTopic()) {
+    throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
+  }
+  await withSpan(
+    "queue.process_message",
+    "queue.process_message",
+    {
+      slackThreadId: payload.normalizedThreadId,
+      slackChannelId: payload.thread.channelId,
+      slackUserId: payload.message.author?.userId
+    },
+    async () => {
+      await processQueuedThreadMessage(payload);
+    },
+    {
+      "messaging.message.id": payload.message.id,
+      "app.queue.message_kind": payload.kind,
+      "app.queue.message_id": payload.queueMessageId,
+      "app.queue.delivery_count": metadata.deliveryCount,
+      "app.queue.topic": metadata.topicName
+    }
+  );
+});
+async function POST(request) {
+  const requestContext = createRequestContext(request, { platform: "queue" });
+  return withContext(requestContext, async () => {
+    try {
+      const response = await callbackHandler(request);
+      setSpanStatus(response.status >= 500 ? "error" : "ok");
+      return response;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logError(
+        "queue_callback_failed",
+        {},
+        {
+          "error.message": message
+        },
+        "Queue callback processing failed"
+      );
+      logException(error, "queue_callback_failed");
+      throw error;
+    }
+  });
+}
+export {
+  POST
+};

package/dist/handlers/router.d.ts

@@ -0,0 +1,9 @@
+type RouteContext = {
+    params: Promise<{
+        path: string[];
+    }>;
+};
+declare function GET(request: Request, context: RouteContext): Promise<Response>;
+declare function POST(request: Request, context: RouteContext): Promise<Response>;
+
+export { GET, POST };

package/dist/handlers/router.js

@@ -0,0 +1,53 @@
+import {
+  POST
+} from "../chunk-OD6TOSY4.js";
+import {
+  GET
+} from "../chunk-4RBEYCOG.js";
+import "../chunk-BBOVH5RF.js";
+
+// src/handlers/oauth-callback.ts
+async function loadOAuthRoute() {
+  return import("../route-XLYK6CKP.js");
+}
+async function GET2(request, context) {
+  const route = await loadOAuthRoute();
+  return route.GET(request, context);
+}
+
+// src/handlers/router.ts
+function normalizeRoutePath(pathParts) {
+  const route = pathParts.join("/").replace(/^\/+|\/+$/g, "");
+  return route.startsWith("api/") ? route.slice("api/".length) : route;
+}
+async function GET3(request, context) {
+  const { path } = await context.params;
+  const route = normalizeRoutePath(path);
+  if (route === "health") {
+    return GET();
+  }
+  const oauthCallbackMatch = route.match(/^oauth\/callback\/([^/]+)$/);
+  if (oauthCallbackMatch) {
+    const provider = oauthCallbackMatch[1];
+    return GET2(request, {
+      params: Promise.resolve({ provider })
+    });
+  }
+  return new Response("Not Found", { status: 404 });
+}
+async function POST2(request, context) {
+  const { path } = await context.params;
+  const route = normalizeRoutePath(path);
+  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 {
+  GET3 as GET,
+  POST2 as POST
+};

package/dist/handlers/webhooks.d.ts

@@ -0,0 +1,8 @@
+type WebhookRouteContext = {
+    params: Promise<{
+        platform: string;
+    }>;
+};
+declare function POST(request: Request, context: WebhookRouteContext): Promise<Response>;
+
+export { POST };

package/dist/handlers/webhooks.js

@@ -0,0 +1,7 @@
+import {
+  POST
+} from "../chunk-OD6TOSY4.js";
+import "../chunk-BBOVH5RF.js";
+export {
+  POST
+};