@pocketping/sdk-node 0.1.0

package/dist/index.js

@@ -0,0 +1,496 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MemoryStorage: () => MemoryStorage,
+  PocketPing: () => PocketPing
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pocketping.ts
+var import_ws = require("ws");
+
+// src/storage/memory.ts
+var MemoryStorage = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.messages = /* @__PURE__ */ new Map();
+    this.messageById = /* @__PURE__ */ new Map();
+  }
+  async createSession(session) {
+    this.sessions.set(session.id, session);
+    this.messages.set(session.id, []);
+  }
+  async getSession(sessionId) {
+    return this.sessions.get(sessionId) ?? null;
+  }
+  async getSessionByVisitorId(visitorId) {
+    const visitorSessions = Array.from(this.sessions.values()).filter(
+      (s) => s.visitorId === visitorId
+    );
+    if (visitorSessions.length === 0) return null;
+    return visitorSessions.reduce(
+      (latest, s) => s.lastActivity > latest.lastActivity ? s : latest
+    );
+  }
+  async updateSession(session) {
+    this.sessions.set(session.id, session);
+  }
+  async deleteSession(sessionId) {
+    this.sessions.delete(sessionId);
+    this.messages.delete(sessionId);
+  }
+  async saveMessage(message) {
+    const sessionMessages = this.messages.get(message.sessionId) ?? [];
+    sessionMessages.push(message);
+    this.messages.set(message.sessionId, sessionMessages);
+    this.messageById.set(message.id, message);
+  }
+  async getMessages(sessionId, after, limit = 50) {
+    const sessionMessages = this.messages.get(sessionId) ?? [];
+    let startIndex = 0;
+    if (after) {
+      const afterIndex = sessionMessages.findIndex((m) => m.id === after);
+      if (afterIndex !== -1) {
+        startIndex = afterIndex + 1;
+      }
+    }
+    return sessionMessages.slice(startIndex, startIndex + limit);
+  }
+  async getMessage(messageId) {
+    return this.messageById.get(messageId) ?? null;
+  }
+  async cleanupOldSessions(olderThan) {
+    let count = 0;
+    for (const [id, session] of this.sessions) {
+      if (session.lastActivity < olderThan) {
+        this.sessions.delete(id);
+        this.messages.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+};
+
+// src/pocketping.ts
+function getClientIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (forwarded) {
+    const ip = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0];
+    return ip?.trim() ?? "unknown";
+  }
+  const realIp = req.headers["x-real-ip"];
+  if (realIp) {
+    return Array.isArray(realIp) ? realIp[0] ?? "unknown" : realIp;
+  }
+  return req.socket?.remoteAddress ?? "unknown";
+}
+function parseUserAgent(userAgent) {
+  if (!userAgent) {
+    return { deviceType: void 0, browser: void 0, os: void 0 };
+  }
+  const ua = userAgent.toLowerCase();
+  let deviceType;
+  if (["mobile", "android", "iphone", "ipod"].some((x) => ua.includes(x))) {
+    deviceType = "mobile";
+  } else if (["ipad", "tablet"].some((x) => ua.includes(x))) {
+    deviceType = "tablet";
+  } else {
+    deviceType = "desktop";
+  }
+  let browser;
+  if (ua.includes("firefox")) browser = "Firefox";
+  else if (ua.includes("edg")) browser = "Edge";
+  else if (ua.includes("chrome")) browser = "Chrome";
+  else if (ua.includes("safari")) browser = "Safari";
+  else if (ua.includes("opera") || ua.includes("opr")) browser = "Opera";
+  let os;
+  if (ua.includes("windows")) os = "Windows";
+  else if (ua.includes("mac os") || ua.includes("macos")) os = "macOS";
+  else if (ua.includes("linux")) os = "Linux";
+  else if (ua.includes("android")) os = "Android";
+  else if (ua.includes("iphone") || ua.includes("ipad")) os = "iOS";
+  return { deviceType, browser, os };
+}
+var PocketPing = class {
+  constructor(config = {}) {
+    this.wss = null;
+    this.sessionSockets = /* @__PURE__ */ new Map();
+    this.operatorOnline = false;
+    this.config = config;
+    this.storage = this.initStorage(config.storage);
+    this.bridges = config.bridges ?? [];
+  }
+  initStorage(storage) {
+    if (!storage || storage === "memory") {
+      return new MemoryStorage();
+    }
+    return storage;
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Express/Connect Middleware
+  // ─────────────────────────────────────────────────────────────────
+  middleware() {
+    return async (req, res, next) => {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      const path = url.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+      try {
+        const body = await this.parseBody(req);
+        const query = Object.fromEntries(url.searchParams);
+        let result;
+        switch (path) {
+          case "connect": {
+            const connectReq = body;
+            const clientIp = getClientIp(req);
+            const userAgent = req.headers["user-agent"];
+            const uaInfo = parseUserAgent(connectReq.metadata?.userAgent ?? userAgent);
+            if (connectReq.metadata) {
+              connectReq.metadata.ip = clientIp;
+              connectReq.metadata.deviceType = connectReq.metadata.deviceType ?? uaInfo.deviceType;
+              connectReq.metadata.browser = connectReq.metadata.browser ?? uaInfo.browser;
+              connectReq.metadata.os = connectReq.metadata.os ?? uaInfo.os;
+            } else {
+              connectReq.metadata = {
+                ip: clientIp,
+                userAgent,
+                ...uaInfo
+              };
+            }
+            result = await this.handleConnect(connectReq);
+            break;
+          }
+          case "message":
+            result = await this.handleMessage(body);
+            break;
+          case "messages":
+            result = await this.handleGetMessages(query);
+            break;
+          case "typing":
+            result = await this.handleTyping(body);
+            break;
+          case "presence":
+            result = await this.handlePresence();
+            break;
+          case "read":
+            result = await this.handleRead(body);
+            break;
+          default:
+            if (next) {
+              next();
+              return;
+            }
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: "Not found" }));
+            return;
+        }
+        res.setHeader("Content-Type", "application/json");
+        res.statusCode = 200;
+        res.end(JSON.stringify(result));
+      } catch (error) {
+        console.error("[PocketPing] Error:", error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    };
+  }
+  async parseBody(req) {
+    if (req.body) return req.body;
+    return new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => data += chunk);
+      req.on("end", () => {
+        try {
+          resolve(data ? JSON.parse(data) : {});
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // WebSocket
+  // ─────────────────────────────────────────────────────────────────
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  attachWebSocket(server) {
+    this.wss = new import_ws.WebSocketServer({
+      server,
+      path: "/pocketping/stream"
+    });
+    this.wss.on("connection", (ws, req) => {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      const sessionId = url.searchParams.get("sessionId");
+      if (!sessionId) {
+        ws.close(4e3, "sessionId required");
+        return;
+      }
+      if (!this.sessionSockets.has(sessionId)) {
+        this.sessionSockets.set(sessionId, /* @__PURE__ */ new Set());
+      }
+      this.sessionSockets.get(sessionId).add(ws);
+      ws.on("close", () => {
+        this.sessionSockets.get(sessionId)?.delete(ws);
+      });
+      ws.on("message", async (data) => {
+        try {
+          const event = JSON.parse(data.toString());
+          await this.handleWebSocketMessage(sessionId, event);
+        } catch (err) {
+          console.error("[PocketPing] WS message error:", err);
+        }
+      });
+    });
+  }
+  async handleWebSocketMessage(sessionId, event) {
+    switch (event.type) {
+      case "typing":
+        this.broadcastToSession(sessionId, {
+          type: "typing",
+          data: event.data
+        });
+        break;
+    }
+  }
+  broadcastToSession(sessionId, event) {
+    const sockets = this.sessionSockets.get(sessionId);
+    if (!sockets) return;
+    const message = JSON.stringify(event);
+    for (const ws of sockets) {
+      if (ws.readyState === import_ws.WebSocket.OPEN) {
+        ws.send(message);
+      }
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Protocol Handlers
+  // ─────────────────────────────────────────────────────────────────
+  async handleConnect(request) {
+    let session = null;
+    if (request.sessionId) {
+      session = await this.storage.getSession(request.sessionId);
+    }
+    if (!session && this.storage.getSessionByVisitorId) {
+      session = await this.storage.getSessionByVisitorId(request.visitorId);
+    }
+    if (!session) {
+      session = {
+        id: this.generateId(),
+        visitorId: request.visitorId,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastActivity: /* @__PURE__ */ new Date(),
+        operatorOnline: this.operatorOnline,
+        aiActive: false,
+        metadata: request.metadata
+      };
+      await this.storage.createSession(session);
+      await this.notifyBridges("new_session", session);
+      await this.config.onNewSession?.(session);
+    } else if (request.metadata) {
+      if (session.metadata) {
+        request.metadata.ip = session.metadata.ip ?? request.metadata.ip;
+        request.metadata.country = session.metadata.country ?? request.metadata.country;
+        request.metadata.city = session.metadata.city ?? request.metadata.city;
+      }
+      session.metadata = request.metadata;
+      session.lastActivity = /* @__PURE__ */ new Date();
+      await this.storage.updateSession(session);
+    }
+    const messages = await this.storage.getMessages(session.id);
+    return {
+      sessionId: session.id,
+      visitorId: session.visitorId,
+      operatorOnline: this.operatorOnline,
+      welcomeMessage: this.config.welcomeMessage,
+      messages
+    };
+  }
+  async handleMessage(request) {
+    const session = await this.storage.getSession(request.sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const message = {
+      id: this.generateId(),
+      sessionId: request.sessionId,
+      content: request.content,
+      sender: request.sender,
+      timestamp: /* @__PURE__ */ new Date(),
+      replyTo: request.replyTo
+    };
+    await this.storage.saveMessage(message);
+    session.lastActivity = /* @__PURE__ */ new Date();
+    await this.storage.updateSession(session);
+    if (request.sender === "visitor") {
+      await this.notifyBridges("message", message, session);
+    }
+    this.broadcastToSession(request.sessionId, {
+      type: "message",
+      data: message
+    });
+    await this.config.onMessage?.(message, session);
+    return {
+      messageId: message.id,
+      timestamp: message.timestamp.toISOString()
+    };
+  }
+  async handleGetMessages(request) {
+    const limit = Math.min(request.limit ?? 50, 100);
+    const messages = await this.storage.getMessages(request.sessionId, request.after, limit + 1);
+    return {
+      messages: messages.slice(0, limit),
+      hasMore: messages.length > limit
+    };
+  }
+  async handleTyping(request) {
+    this.broadcastToSession(request.sessionId, {
+      type: "typing",
+      data: {
+        sessionId: request.sessionId,
+        sender: request.sender,
+        isTyping: request.isTyping ?? true
+      }
+    });
+    return { ok: true };
+  }
+  async handlePresence() {
+    return {
+      online: this.operatorOnline,
+      aiEnabled: !!this.config.ai,
+      aiActiveAfter: this.config.aiTakeoverDelay ?? 300
+    };
+  }
+  async handleRead(request) {
+    const session = await this.storage.getSession(request.sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const status = request.status ?? "read";
+    const now = /* @__PURE__ */ new Date();
+    let updated = 0;
+    const messages = await this.storage.getMessages(request.sessionId);
+    for (const msg of messages) {
+      if (request.messageIds.includes(msg.id)) {
+        msg.status = status;
+        if (status === "delivered") {
+          msg.deliveredAt = now;
+        } else if (status === "read") {
+          msg.deliveredAt = msg.deliveredAt ?? now;
+          msg.readAt = now;
+        }
+        await this.storage.saveMessage(msg);
+        updated++;
+      }
+    }
+    this.broadcastToSession(request.sessionId, {
+      type: "read",
+      data: {
+        messageIds: request.messageIds,
+        status,
+        deliveredAt: status === "delivered" ? now.toISOString() : void 0,
+        readAt: status === "read" ? now.toISOString() : void 0
+      }
+    });
+    await this.notifyBridgesRead(request.sessionId, request.messageIds, status);
+    return { updated };
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Operator Actions (for bridges)
+  // ─────────────────────────────────────────────────────────────────
+  async sendOperatorMessage(sessionId, content) {
+    const response = await this.handleMessage({
+      sessionId,
+      content,
+      sender: "operator"
+    });
+    const message = {
+      id: response.messageId,
+      sessionId,
+      content,
+      sender: "operator",
+      timestamp: new Date(response.timestamp)
+    };
+    return message;
+  }
+  setOperatorOnline(online) {
+    this.operatorOnline = online;
+    for (const sessionId of this.sessionSockets.keys()) {
+      this.broadcastToSession(sessionId, {
+        type: "presence",
+        data: { online }
+      });
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Bridges
+  // ─────────────────────────────────────────────────────────────────
+  async notifyBridges(event, ...args) {
+    for (const bridge of this.bridges) {
+      try {
+        switch (event) {
+          case "new_session":
+            await bridge.onNewSession?.(args[0]);
+            break;
+          case "message":
+            await bridge.onMessage?.(args[0], args[1]);
+            break;
+        }
+      } catch (err) {
+        console.error(`[PocketPing] Bridge ${bridge.name} error:`, err);
+      }
+    }
+  }
+  async notifyBridgesRead(sessionId, messageIds, status) {
+    for (const bridge of this.bridges) {
+      try {
+        await bridge.onMessageRead?.(sessionId, messageIds, status);
+      } catch (err) {
+        console.error(`[PocketPing] Bridge ${bridge.name} read notification error:`, err);
+      }
+    }
+  }
+  addBridge(bridge) {
+    this.bridges.push(bridge);
+    bridge.init?.(this);
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Utilities
+  // ─────────────────────────────────────────────────────────────────
+  generateId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  getStorage() {
+    return this.storage;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryStorage,
+  PocketPing
+});