simple-support-chat 0.3.3 → 0.4.1

package/dist/server/index.cjs

@@ -45,7 +45,7 @@ var InMemoryStore = class {
 
 // src/server/handler.ts
 async function handleMessage(body, options) {
-  const { slack, slackChannel, botName, botIcon, onMessage, store } = options;
+  const { slack, slackChannel, botName, botIcon, onMessage, store, emitter } = options;
   if (!body.message || typeof body.message !== "string") {
     return {
       data: { success: false, error: "Missing required field: message" },
@@ -108,6 +108,9 @@ ${body.message}`,
         user: body.user,
         context: body.context
       });
+      if (emitter) {
+        emitter.emitThreadCreated(body.sessionId, threadTs);
+      }
       return {
         data: { success: true, threadId: threadTs },
         status: 200
@@ -122,7 +125,7 @@ ${body.message}`,
   }
 }
 function createSupportHandler(options) {
-  const { slackBotToken, slackChannel, botName, botIcon, onMessage, store } = options;
+  const { slackBotToken, slackChannel, botName, botIcon, onMessage, store, emitter } = options;
   const slack = new webApi.WebClient(slackBotToken);
   const resolvedStore = store ?? new InMemoryStore();
   return async (request) => {
@@ -147,13 +150,14 @@ function createSupportHandler(options) {
       botName,
       botIcon,
       onMessage,
-      store: resolvedStore
+      store: resolvedStore,
+      emitter
     });
     return jsonResponse(result.data, result.status);
   };
 }
 function createExpressHandler(options) {
-  const { slackBotToken, slackChannel, botName, botIcon, onMessage, store } = options;
+  const { slackBotToken, slackChannel, botName, botIcon, onMessage, store, emitter } = options;
   const slack = new webApi.WebClient(slackBotToken);
   const resolvedStore = store ?? new InMemoryStore();
   return async (req, res) => {
@@ -164,7 +168,8 @@ function createExpressHandler(options) {
       botName,
       botIcon,
       onMessage,
-      store: resolvedStore
+      store: resolvedStore,
+      emitter
     });
     res.status(result.status).json(result.data);
   };
@@ -2136,7 +2141,7 @@ function verifySlackSignature(signingSecret, signature, timestamp, rawBody) {
   }
 }
 function createWebhookHandler(options) {
-  const { store, signingSecret } = options;
+  const { store, signingSecret, emitter } = options;
   return async (request) => {
     let rawBody;
     try {
@@ -2187,13 +2192,16 @@ function createWebhookHandler(options) {
         threadTs: event.thread_ts
       };
       await store.saveReply(threadRecord.sessionId, reply);
+      if (emitter) {
+        emitter.emit(threadRecord.sessionId, reply);
+      }
       return jsonResponse2({ ok: true }, 200);
     }
     return jsonResponse2({ ok: true }, 200);
   };
 }
 function createExpressWebhookHandler(options) {
-  const { store, signingSecret } = options;
+  const { store, signingSecret, emitter } = options;
   return async (req, res) => {
     const rawBody = typeof req.body === "string" ? req.body : Buffer.isBuffer(req.body) ? req.body.toString("utf-8") : JSON.stringify(req.body);
     const signature = req.headers?.["x-slack-signature"] ?? "";
@@ -2244,6 +2252,9 @@ function createExpressWebhookHandler(options) {
         threadTs: event.thread_ts
       };
       await store.saveReply(threadRecord.sessionId, reply);
+      if (emitter) {
+        emitter.emit(threadRecord.sessionId, reply);
+      }
       res.status(200).json({ ok: true });
       return;
     }
@@ -2306,11 +2317,196 @@ function jsonResponse3(data, status = 200) {
   });
 }
 
+// src/server/emitter.ts
+function createReplyEmitter() {
+  const subscribers = /* @__PURE__ */ new Map();
+  return {
+    emit(sessionId, reply) {
+      const callbacks = subscribers.get(sessionId);
+      if (!callbacks) return;
+      const event = { type: "reply", sessionId, reply };
+      for (const cb of callbacks) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+    },
+    emitThreadCreated(sessionId, threadTs) {
+      const callbacks = subscribers.get(sessionId);
+      if (!callbacks) return;
+      const event = {
+        type: "thread_created",
+        sessionId,
+        threadTs
+      };
+      for (const cb of callbacks) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+    },
+    subscribe(sessionId, callback) {
+      let callbacks = subscribers.get(sessionId);
+      if (!callbacks) {
+        callbacks = /* @__PURE__ */ new Set();
+        subscribers.set(sessionId, callbacks);
+      }
+      callbacks.add(callback);
+    },
+    unsubscribe(sessionId, callback) {
+      const callbacks = subscribers.get(sessionId);
+      if (!callbacks) return;
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
+        subscribers.delete(sessionId);
+      }
+    }
+  };
+}
+
+// src/server/sse.ts
+function createSSEHandler(options) {
+  const { emitter, heartbeatInterval = 3e4 } = options;
+  return (request) => {
+    const url = new URL(request.url);
+    const sessionId = url.searchParams.get("sessionId");
+    if (!sessionId) {
+      return new Response(
+        JSON.stringify({ error: "Missing required query parameter: sessionId" }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    const sid = sessionId;
+    let heartbeatTimer = null;
+    let unsubscribed = false;
+    const stream = new ReadableStream({
+      start(controller) {
+        const callback = (event) => {
+          if (unsubscribed) return;
+          try {
+            if (event.type === "reply") {
+              const data = JSON.stringify({ reply: event.reply });
+              controller.enqueue(formatSSE("reply", data));
+            } else if (event.type === "thread_created") {
+              const data = JSON.stringify({ threadTs: event.threadTs });
+              controller.enqueue(formatSSE("thread_created", data));
+            }
+          } catch {
+            cleanup();
+          }
+        };
+        emitter.subscribe(sid, callback);
+        heartbeatTimer = setInterval(() => {
+          try {
+            controller.enqueue(formatSSE("heartbeat", "{}"));
+          } catch {
+            cleanup();
+          }
+        }, heartbeatInterval);
+        function cleanup() {
+          if (unsubscribed) return;
+          unsubscribed = true;
+          emitter.unsubscribe(sid, callback);
+          if (heartbeatTimer !== null) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
+          }
+        }
+        if (request.signal) {
+          request.signal.addEventListener("abort", () => {
+            cleanup();
+            try {
+              controller.close();
+            } catch {
+            }
+          });
+        }
+      },
+      cancel() {
+        unsubscribed = true;
+        if (heartbeatTimer !== null) {
+          clearInterval(heartbeatTimer);
+          heartbeatTimer = null;
+        }
+      }
+    });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  };
+}
+function createExpressSSEHandler(options) {
+  const { emitter, heartbeatInterval = 3e4 } = options;
+  return (req, res) => {
+    const sessionId = req.query?.sessionId;
+    if (!sessionId || typeof sessionId !== "string") {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.write(JSON.stringify({ error: "Missing required query parameter: sessionId" }));
+      res.end();
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    let cleaned = false;
+    const callback = (event) => {
+      if (cleaned) return;
+      if (event.type === "reply") {
+        const data = JSON.stringify({ reply: event.reply });
+        res.write(formatSSEString("reply", data));
+      } else if (event.type === "thread_created") {
+        const data = JSON.stringify({ threadTs: event.threadTs });
+        res.write(formatSSEString("thread_created", data));
+      }
+    };
+    emitter.subscribe(sessionId, callback);
+    const heartbeatTimer = setInterval(() => {
+      if (cleaned) return;
+      res.write(formatSSEString("heartbeat", "{}"));
+    }, heartbeatInterval);
+    function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      emitter.unsubscribe(sessionId, callback);
+      clearInterval(heartbeatTimer);
+    }
+    res.on("close", cleanup);
+  };
+}
+function formatSSE(event, data) {
+  const text = `event: ${event}
+data: ${data}
+
+`;
+  return new TextEncoder().encode(text);
+}
+function formatSSEString(event, data) {
+  return `event: ${event}
+data: ${data}
+
+`;
+}
+
 exports.InMemoryStore = InMemoryStore;
 exports.createExpressHandler = createExpressHandler;
 exports.createExpressRepliesHandler = createExpressRepliesHandler;
+exports.createExpressSSEHandler = createExpressSSEHandler;
 exports.createExpressWebhookHandler = createExpressWebhookHandler;
 exports.createRepliesHandler = createRepliesHandler;
+exports.createReplyEmitter = createReplyEmitter;
+exports.createSSEHandler = createSSEHandler;
 exports.createSupportHandler = createSupportHandler;
 exports.createWebhookHandler = createWebhookHandler;
 exports.emojify = emojify;