wakz-sdk 1.0.0

package/dist/esm/websocket.mjs

@@ -0,0 +1,363 @@
+// ═══════════════════════════════════════════════════════════════
+// WAKZ SDK — WebSocket Transport Manager
+// ═══════════════════════════════════════════════════════════════
+import { WAKZEventEmitter } from './events';
+import { calculateBackoff, sleep, nowISO, generateId, Logger } from './utils';
+/**
+ * WebSocket transport manager with automatic reconnection.
+ * Handles connection lifecycle, message framing, and keep-alive.
+ */
+export class WebSocketTransport extends WAKZEventEmitter {
+    // Re-export connected state
+    get isConnected() {
+        return this._isConnected && this.ws?.readyState === WebSocket.OPEN;
+    }
+    constructor(apiKey, wsUrl, options = {}) {
+        super();
+        this.ws = null;
+        this._isConnected = false;
+        this._isConnecting = false;
+        this._retryCount = 0;
+        this._isDestroyed = false;
+        this._reconnectTimer = null;
+        this._pingInterval = null;
+        this._messageQueue = [];
+        this._pendingRequests = new Map();
+        /**
+         * Handle WebSocket open event.
+         */
+        this.handleOpen = () => {
+            this._isConnecting = false;
+            this._isConnected = true;
+            this._retryCount = 0;
+            this.logger.debug('[WS] Connected');
+            this.emit('connected', undefined);
+            // Flush queued messages
+            this.flushMessageQueue();
+            // Start ping interval (every 30s)
+            this._pingInterval = setInterval(() => {
+                this.send({ type: 'ping', timestamp: nowISO() });
+            }, 30000);
+        };
+        /**
+         * Handle WebSocket close event.
+         */
+        this.handleClose = (event) => {
+            this._isConnected = false;
+            this._isConnecting = false;
+            this.clearPingInterval();
+            this.logger.debug('[WS] Closed:', event.code, event.reason);
+            this.emit('disconnected', { code: event.code, reason: event.reason });
+            // Auto-reconnect if enabled
+            if (this.autoReconnect && !this._isDestroyed) {
+                this.attemptReconnect();
+            }
+        };
+        /**
+         * Handle WebSocket error event.
+         */
+        this.handleError = (event) => {
+            this.logger.error('[WS] Error:', event);
+            this.emit('error', new Error('WebSocket error occurred'));
+        };
+        /**
+         * Handle incoming WebSocket message.
+         */
+        this.handleMessage = (event) => {
+            try {
+                const data = JSON.parse(String(event.data));
+                // Handle pong (keep-alive response)
+                if (data.type === 'pong')
+                    return;
+                // Handle errors
+                if (data.type === 'error') {
+                    this.emit('error', new Error(String(data.payload ?? 'Server error')));
+                    // Resolve pending request with error
+                    if (data.id && this._pendingRequests.has(data.id)) {
+                        const pending = this._pendingRequests.get(data.id);
+                        clearTimeout(pending.timer);
+                        this._pendingRequests.delete(data.id);
+                        pending.reject(new Error(String(data.payload ?? 'Server error')));
+                    }
+                    return;
+                }
+                // Handle message response
+                if (data.type === 'message' && data.id && this._pendingRequests.has(data.id)) {
+                    const pending = this._pendingRequests.get(data.id);
+                    clearTimeout(pending.timer);
+                    this._pendingRequests.delete(data.id);
+                    const msg = {
+                        id: data.id,
+                        role: 'assistant',
+                        content: data.payload?.content
+                            || String(data.payload ?? ''),
+                        timestamp: data.timestamp || nowISO(),
+                    };
+                    pending.resolve(msg);
+                    this.emit('message', msg);
+                    return;
+                }
+                // Handle session events
+                if (data.type === 'session') {
+                    this.logger.debug('[WS] Session event:', data.payload);
+                    return;
+                }
+                // Handle unsolicited messages (server push)
+                if (data.type === 'message') {
+                    const msg = {
+                        id: data.id || generateId('msg'),
+                        role: data.payload?.role || 'assistant',
+                        content: data.payload?.content || String(data.payload ?? ''),
+                        timestamp: data.timestamp || nowISO(),
+                    };
+                    this.emit('message', msg);
+                }
+            }
+            catch (err) {
+                this.logger.error('[WS] Failed to parse message:', err);
+            }
+        };
+        this.apiKey = apiKey;
+        this.wsUrl = wsUrl;
+        this.autoReconnect = options.autoReconnect ?? true;
+        this.maxRetries = options.maxRetries ?? 5;
+        this.initialRetryDelay = options.initialRetryDelay ?? 1000;
+        this.maxRetryDelay = options.maxRetryDelay ?? 30000;
+        this.logger = new Logger(options.debug ?? false);
+    }
+    /**
+     * Connect to the WebSocket server.
+     */
+    async connect() {
+        if (this._isConnecting || this.isConnected)
+            return;
+        if (this._isDestroyed)
+            throw new Error('Transport is destroyed');
+        this._isConnecting = true;
+        this.logger.debug('[WS] Connecting to:', this.wsUrl);
+        try {
+            this.ws = this.createWebSocket();
+            await this.waitForConnection();
+        }
+        catch (err) {
+            this._isConnecting = false;
+            this.logger.error('[WS] Connection failed:', err);
+            throw err;
+        }
+    }
+    /**
+     * Send a message through the WebSocket.
+     */
+    async sendMessage(content, sessionId, visitorId) {
+        const envelope = {
+            type: 'message',
+            id: generateId('req'),
+            timestamp: nowISO(),
+            payload: {
+                content,
+                role: 'user',
+                session_id: sessionId,
+                visitor_id: visitorId,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            // If not connected, queue the message
+            if (!this.isConnected) {
+                this._messageQueue.push(envelope);
+                reject(new Error('WebSocket not connected. Message queued.'));
+                return;
+            }
+            // Set up response timeout (30s)
+            const timer = setTimeout(() => {
+                this._pendingRequests.delete(envelope.id);
+                reject(new Error('Response timeout'));
+            }, 30000);
+            this._pendingRequests.set(envelope.id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            this.send(envelope);
+        });
+    }
+    /**
+     * Disconnect from the WebSocket server.
+     */
+    disconnect(code = 1000, reason = 'Client disconnect') {
+        this._isDestroyed = true;
+        this._isConnecting = false;
+        this.clearTimers();
+        if (this.ws) {
+            try {
+                this.ws.close(code, reason);
+            }
+            catch {
+                // Already closed
+            }
+            this.ws = null;
+        }
+        this._isConnected = false;
+        this.logger.debug('[WS] Disconnected');
+        this.emit('disconnected', { code, reason });
+    }
+    /**
+     * Create a WebSocket instance (handles browser vs Node.js).
+     */
+    createWebSocket() {
+        // Build authenticated URL
+        const url = new URL(this.wsUrl);
+        url.searchParams.set('api_key', this.apiKey);
+        let ws;
+        if (typeof WebSocket !== 'undefined') {
+            // Browser WebSocket
+            ws = new WebSocket(url.toString());
+        }
+        else {
+            // Node.js — try to use ws package
+            try {
+                const WS = require('ws');
+                ws = new WS(url.toString());
+            }
+            catch {
+                throw new Error('[WAKZ SDK] WebSocket not available. Install "ws" package for Node.js, or use HTTP transport.');
+            }
+        }
+        ws.onopen = this.handleOpen;
+        ws.onclose = this.handleClose;
+        ws.onerror = this.handleError;
+        ws.onmessage = this.handleMessage;
+        return ws;
+    }
+    /**
+     * Wait for the WebSocket to open.
+     */
+    waitForConnection() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('WebSocket connection timeout'));
+            }, 15000);
+            const ws = this.ws;
+            const onOpen = () => {
+                clearTimeout(timeout);
+                ws.removeEventListener('open', onOpen);
+                ws.removeEventListener('error', onError);
+                resolve();
+            };
+            const onError = (event) => {
+                clearTimeout(timeout);
+                ws.removeEventListener('open', onOpen);
+                ws.removeEventListener('error', onError);
+                reject(new Error('WebSocket connection error'));
+            };
+            ws.addEventListener('open', onOpen);
+            ws.addEventListener('error', onError);
+        });
+    }
+    /**
+     * Attempt to reconnect with exponential backoff.
+     */
+    async attemptReconnect() {
+        if (this._retryCount >= this.maxRetries) {
+            this.logger.error('[WS] Max retries reached, giving up');
+            this.emit('reconnect_failed', { reason: 'Max retries exceeded' });
+            return;
+        }
+        const delay = calculateBackoff(this._retryCount, this.initialRetryDelay, this.maxRetryDelay);
+        this._retryCount++;
+        this.logger.debug(`[WS] Reconnecting in ${Math.round(delay)}ms (attempt ${this._retryCount}/${this.maxRetries})`);
+        this.emit('reconnecting', { attempt: this._retryCount, delay });
+        await sleep(delay);
+        if (this._isDestroyed)
+            return;
+        try {
+            this._isConnecting = true;
+            this.ws = this.createWebSocket();
+            await this.waitForConnection();
+        }
+        catch (err) {
+            this.logger.error('[WS] Reconnect attempt failed:', err);
+            this.attemptReconnect(); // Recursive retry
+        }
+    }
+    /**
+     * Flush queued messages after reconnection.
+     */
+    flushMessageQueue() {
+        while (this._messageQueue.length > 0 && this.isConnected) {
+            const envelope = this._messageQueue.shift();
+            this.send(envelope);
+        }
+    }
+    /**
+     * Send a raw envelope through the WebSocket.
+     */
+    send(envelope) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this._messageQueue.push(envelope);
+            return;
+        }
+        try {
+            this.ws.send(JSON.stringify(envelope));
+        }
+        catch (err) {
+            this.logger.error('[WS] Send error:', err);
+            this._messageQueue.push(envelope);
+        }
+    }
+    /**
+     * Perform a health check via WebSocket.
+     */
+    async healthCheck() {
+        const startTime = Date.now();
+        try {
+            if (!this.isConnected) {
+                return { healthy: false, latency: 0 };
+            }
+            return new Promise((resolve) => {
+                const envelope = {
+                    type: 'ping',
+                    id: generateId('hc'),
+                    timestamp: nowISO(),
+                };
+                const timer = setTimeout(() => {
+                    resolve({ healthy: false, latency: Date.now() - startTime });
+                }, 5000);
+                const handler = () => {
+                    clearTimeout(timer);
+                    this.off('message', handler);
+                    resolve({ healthy: true, latency: Date.now() - startTime });
+                };
+                this.on('message', handler);
+                this.send(envelope);
+            });
+        }
+        catch {
+            return { healthy: false, latency: Date.now() - startTime };
+        }
+    }
+    /**
+     * Clear all timers.
+     */
+    clearTimers() {
+        this.clearPingInterval();
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = null;
+        }
+        // Clear pending request timeouts
+        for (const [, pending] of this._pendingRequests) {
+            clearTimeout(pending.timer);
+        }
+        this._pendingRequests.clear();
+    }
+    /**
+     * Clear the ping interval.
+     */
+    clearPingInterval() {
+        if (this._pingInterval) {
+            clearInterval(this._pingInterval);
+            this._pingInterval = null;
+        }
+    }
+}
+//# sourceMappingURL=websocket.js.map

package/dist/events.d.ts

@@ -0,0 +1,38 @@
+import type { WAKZEventType, WAKZEventMap, WAKZEventCallback } from './types';
+/**
+ * Lightweight typed event emitter for the WAKZ SDK.
+ * Zero external dependencies.
+ */
+export declare class WAKZEventEmitter {
+    private listeners;
+    private onceListeners;
+    /**
+     * Register an event listener.
+     */
+    on<K extends WAKZEventType>(event: K, callback: WAKZEventCallback<WAKZEventMap[K]>): this;
+    /**
+     * Register a one-time event listener (auto-removes after first call).
+     */
+    once<K extends WAKZEventType>(event: K, callback: WAKZEventCallback<WAKZEventMap[K]>): this;
+    /**
+     * Remove a specific event listener.
+     */
+    off<K extends WAKZEventType>(event: K, callback: WAKZEventCallback<WAKZEventMap[K]>): this;
+    /**
+     * Remove all listeners for a specific event, or all events if no event specified.
+     */
+    removeAllListeners(event?: WAKZEventType): this;
+    /**
+     * Emit an event to all registered listeners.
+     */
+    protected emit<K extends WAKZEventType>(event: K, data: WAKZEventMap[K]): void;
+    /**
+     * Get the count of listeners for a specific event.
+     */
+    listenerCount(event: WAKZEventType): number;
+    /**
+     * Destroy the emitter — remove all listeners.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI9E;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,aAAa,CAA0B;IAE/C;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQzF;;OAEG;IACH,IAAI,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQ3F;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAM1F;;OAEG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI;IAW/C;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IA4B9E;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM;IAI3C;;OAEG;IACH,OAAO,IAAI,IAAI;CAIhB"}

package/dist/events.js

@@ -0,0 +1,104 @@
+"use strict";
+// ═══════════════════════════════════════════════════════════════
+// WAKZ SDK — Event Emitter System
+// ═══════════════════════════════════════════════════════════════
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAKZEventEmitter = void 0;
+/**
+ * Lightweight typed event emitter for the WAKZ SDK.
+ * Zero external dependencies.
+ */
+class WAKZEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+        this.onceListeners = new Map();
+    }
+    /**
+     * Register an event listener.
+     */
+    on(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        return this;
+    }
+    /**
+     * Register a one-time event listener (auto-removes after first call).
+     */
+    once(event, callback) {
+        if (!this.onceListeners.has(event)) {
+            this.onceListeners.set(event, new Set());
+        }
+        this.onceListeners.get(event).add(callback);
+        return this;
+    }
+    /**
+     * Remove a specific event listener.
+     */
+    off(event, callback) {
+        this.listeners.get(event)?.delete(callback);
+        this.onceListeners.get(event)?.delete(callback);
+        return this;
+    }
+    /**
+     * Remove all listeners for a specific event, or all events if no event specified.
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+            this.onceListeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+            this.onceListeners.clear();
+        }
+        return this;
+    }
+    /**
+     * Emit an event to all registered listeners.
+     */
+    emit(event, data) {
+        // Fire persistent listeners
+        const persistent = this.listeners.get(event);
+        if (persistent) {
+            for (const cb of persistent) {
+                try {
+                    cb(data);
+                }
+                catch (err) {
+                    // Prevent listener errors from breaking the emitter
+                    console.error(`[WAKZ SDK] Error in "${event}" listener:`, err);
+                }
+            }
+        }
+        // Fire and consume once-listeners
+        const once = this.onceListeners.get(event);
+        if (once) {
+            for (const cb of once) {
+                try {
+                    cb(data);
+                }
+                catch (err) {
+                    console.error(`[WAKZ SDK] Error in "${event}" once-listener:`, err);
+                }
+            }
+            this.onceListeners.delete(event);
+        }
+    }
+    /**
+     * Get the count of listeners for a specific event.
+     */
+    listenerCount(event) {
+        return (this.listeners.get(event)?.size ?? 0) + (this.onceListeners.get(event)?.size ?? 0);
+    }
+    /**
+     * Destroy the emitter — remove all listeners.
+     */
+    destroy() {
+        this.listeners.clear();
+        this.onceListeners.clear();
+    }
+}
+exports.WAKZEventEmitter = WAKZEventEmitter;
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}

package/dist/http.d.ts

@@ -0,0 +1,37 @@
+import type { SendMessageResponse, WidgetConfig, HealthCheckResult } from './types';
+/**
+ * HTTP/REST fallback transport for environments where WebSocket is unavailable.
+ * All requests are signed with HMAC-SHA256 for secure authentication.
+ */
+export declare class HttpTransport {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    private logger;
+    constructor(apiKey: string, baseUrl: string, timeout?: number, debug?: boolean);
+    /**
+     * Send a chat message via REST API.
+     */
+    sendMessage(content: string, sessionId?: string, visitorId?: string): Promise<SendMessageResponse>;
+    /**
+     * Fetch widget configuration.
+     */
+    fetchWidgetConfig(): Promise<WidgetConfig | null>;
+    /**
+     * Perform a health check against the API.
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Get the current session from the server.
+     */
+    getSession(visitorId: string): Promise<{
+        id: string;
+        messageCount: number;
+        isActive: boolean;
+    } | null>;
+    /**
+     * Fetch with timeout support.
+     */
+    private fetchWithTimeout;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,mBAAmB,EAEnB,YAAY,EACZ,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAIjB;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;gBAGrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAc,EACvB,KAAK,GAAE,OAAe;IAQxB;;OAEG;IACG,WAAW,CACf,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,mBAAmB,CAAC;IAiD/B;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAuBvD;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IA2B/C;;OAEG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAC3C,EAAE,EAAE,MAAM,CAAC;QACX,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,OAAO,CAAC;KACnB,GAAG,IAAI,CAAC;IAkBT;;OAEG;YACW,gBAAgB;CAyB/B"}