@pocketping/sdk-node 0.1.0 → 1.0.0

package/dist/index.d.mts

@@ -1,222 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-
-/**
- * Storage adapter interface.
- * Implement this interface to use any database with PocketPing.
- */
-interface Storage {
-    createSession(session: Session): Promise<void>;
-    getSession(sessionId: string): Promise<Session | null>;
-    getSessionByVisitorId?(visitorId: string): Promise<Session | null>;
-    updateSession(session: Session): Promise<void>;
-    deleteSession(sessionId: string): Promise<void>;
-    saveMessage(message: Message): Promise<void>;
-    getMessages(sessionId: string, after?: string, limit?: number): Promise<Message[]>;
-    getMessage(messageId: string): Promise<Message | null>;
-    cleanupOldSessions?(olderThan: Date): Promise<number>;
-}
-
-/**
- * Bridge interface for notification channels.
- * Implement this interface to add support for Telegram, Discord, Slack, etc.
- */
-interface Bridge {
-    /** Unique name for this bridge */
-    name: string;
-    /** Called when the bridge is added to PocketPing */
-    init?(pocketping: PocketPing): void | Promise<void>;
-    /** Called when a new chat session is created */
-    onNewSession?(session: Session): void | Promise<void>;
-    /** Called when a visitor sends a message */
-    onMessage?(message: Message, session: Session): void | Promise<void>;
-    /** Called when visitor starts/stops typing */
-    onTyping?(sessionId: string, isTyping: boolean): void | Promise<void>;
-    /** Called when messages are marked as delivered/read */
-    onMessageRead?(sessionId: string, messageIds: string[], status: MessageStatus): void | Promise<void>;
-    /** Cleanup when bridge is removed */
-    destroy?(): void | Promise<void>;
-}
-
-/**
- * AI provider interface.
- * Implement this to add support for OpenAI, Gemini, Claude, or local models.
- */
-interface AIProvider {
-    /** Provider name */
-    name: string;
-    /** Generate a response to the conversation */
-    generateResponse(messages: Message[], systemPrompt?: string): Promise<string>;
-    /** Check if the provider is available */
-    isAvailable(): Promise<boolean>;
-}
-
-interface PocketPingConfig {
-    /** Storage adapter for sessions and messages */
-    storage?: Storage | 'memory';
-    /** Notification bridges (Telegram, Discord, etc.) */
-    bridges?: Bridge[];
-    /** AI fallback configuration */
-    ai?: AIConfig;
-    /** Welcome message shown to new visitors */
-    welcomeMessage?: string;
-    /** Seconds of inactivity before AI takes over (default: 300) */
-    aiTakeoverDelay?: number;
-    /** Callback when a new session is created */
-    onNewSession?: (session: Session) => void | Promise<void>;
-    /** Callback when a message is received */
-    onMessage?: (message: Message, session: Session) => void | Promise<void>;
-}
-interface AIConfig {
-    provider: AIProvider | 'openai' | 'gemini' | 'anthropic';
-    apiKey?: string;
-    model?: string;
-    systemPrompt?: string;
-    fallbackAfter?: number;
-}
-interface Session {
-    id: string;
-    visitorId: string;
-    createdAt: Date;
-    lastActivity: Date;
-    operatorOnline: boolean;
-    aiActive: boolean;
-    metadata?: SessionMetadata;
-}
-interface SessionMetadata {
-    url?: string;
-    referrer?: string;
-    pageTitle?: string;
-    userAgent?: string;
-    timezone?: string;
-    language?: string;
-    screenResolution?: string;
-    ip?: string;
-    country?: string;
-    city?: string;
-    deviceType?: 'desktop' | 'mobile' | 'tablet';
-    browser?: string;
-    os?: string;
-    [key: string]: unknown;
-}
-type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read';
-interface Message {
-    id: string;
-    sessionId: string;
-    content: string;
-    sender: 'visitor' | 'operator' | 'ai';
-    timestamp: Date;
-    replyTo?: string;
-    metadata?: Record<string, unknown>;
-    status?: MessageStatus;
-    deliveredAt?: Date;
-    readAt?: Date;
-}
-interface ConnectRequest {
-    visitorId: string;
-    sessionId?: string;
-    metadata?: SessionMetadata;
-}
-interface ConnectResponse {
-    sessionId: string;
-    visitorId: string;
-    operatorOnline: boolean;
-    welcomeMessage?: string;
-    messages: Message[];
-}
-interface SendMessageRequest {
-    sessionId: string;
-    content: string;
-    sender: 'visitor' | 'operator';
-    replyTo?: string;
-}
-interface SendMessageResponse {
-    messageId: string;
-    timestamp: string;
-}
-interface GetMessagesRequest {
-    sessionId: string;
-    after?: string;
-    limit?: number;
-}
-interface GetMessagesResponse {
-    messages: Message[];
-    hasMore: boolean;
-}
-interface TypingRequest {
-    sessionId: string;
-    sender: 'visitor' | 'operator';
-    isTyping?: boolean;
-}
-interface ReadRequest {
-    sessionId: string;
-    messageIds: string[];
-    status?: MessageStatus;
-}
-interface ReadResponse {
-    updated: number;
-}
-interface PresenceResponse {
-    online: boolean;
-    operators?: Array<{
-        id: string;
-        name: string;
-        avatar?: string;
-    }>;
-    aiEnabled: boolean;
-    aiActiveAfter?: number;
-}
-
-declare class PocketPing {
-    private storage;
-    private bridges;
-    private config;
-    private wss;
-    private sessionSockets;
-    private operatorOnline;
-    constructor(config?: PocketPingConfig);
-    private initStorage;
-    middleware(): (req: IncomingMessage & {
-        body?: unknown;
-        query?: Record<string, string>;
-    }, res: ServerResponse, next?: () => void) => void;
-    private parseBody;
-    attachWebSocket(server: any): void;
-    private handleWebSocketMessage;
-    private broadcastToSession;
-    handleConnect(request: ConnectRequest): Promise<ConnectResponse>;
-    handleMessage(request: SendMessageRequest): Promise<SendMessageResponse>;
-    handleGetMessages(request: GetMessagesRequest): Promise<GetMessagesResponse>;
-    handleTyping(request: TypingRequest): Promise<{
-        ok: boolean;
-    }>;
-    handlePresence(): Promise<PresenceResponse>;
-    handleRead(request: ReadRequest): Promise<ReadResponse>;
-    sendOperatorMessage(sessionId: string, content: string): Promise<Message>;
-    setOperatorOnline(online: boolean): void;
-    private notifyBridges;
-    private notifyBridgesRead;
-    addBridge(bridge: Bridge): void;
-    private generateId;
-    getStorage(): Storage;
-}
-
-/**
- * In-memory storage adapter.
- * Useful for development and testing. Data is lost on restart.
- */
-declare class MemoryStorage implements Storage {
-    private sessions;
-    private messages;
-    private messageById;
-    createSession(session: Session): Promise<void>;
-    getSession(sessionId: string): Promise<Session | null>;
-    getSessionByVisitorId(visitorId: string): Promise<Session | null>;
-    updateSession(session: Session): Promise<void>;
-    deleteSession(sessionId: string): Promise<void>;
-    saveMessage(message: Message): Promise<void>;
-    getMessages(sessionId: string, after?: string, limit?: number): Promise<Message[]>;
-    getMessage(messageId: string): Promise<Message | null>;
-    cleanupOldSessions(olderThan: Date): Promise<number>;
-}
-
-export { type AIProvider, type Bridge, type ConnectRequest, type ConnectResponse, MemoryStorage, type Message, PocketPing, type PocketPingConfig, type PresenceResponse, type SendMessageRequest, type SendMessageResponse, type Session, type Storage };

package/dist/index.mjs

@@ -1,468 +0,0 @@
-// src/pocketping.ts
-import { WebSocketServer, WebSocket } from "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 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 === 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;
-  }
-};
-export {
-  MemoryStorage,
-  PocketPing
-};