@recursorsdk/sdk 1.0.0

package/dist/websocket.js

@@ -0,0 +1,190 @@
+/**
+ * WebSocket Client for Recursor SDK
+ * Provides real-time updates via WebSocket connection
+ */
+export class RecursorWebSocket {
+    constructor(baseUrl, accessToken) {
+        this.ws = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.pingInterval = null;
+        this.isConnecting = false;
+        this.shouldReconnect = true;
+        this.eventHandlers = new Map();
+        // Convert http/https to ws/wss
+        this.baseUrl = baseUrl.replace(/^http/, "ws");
+        this.accessToken = accessToken;
+    }
+    /**
+     * Connect to WebSocket server
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.isConnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
+                resolve();
+                return;
+            }
+            this.isConnecting = true;
+            this.shouldReconnect = true;
+            const wsUrl = `${this.baseUrl}/client/ws?token=${this.accessToken}`;
+            try {
+                this.ws = new WebSocket(wsUrl);
+                this.ws.onopen = () => {
+                    this.isConnecting = false;
+                    this.reconnectAttempts = 0;
+                    this.startPing();
+                    resolve();
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const message = JSON.parse(event.data);
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        console.error("Failed to parse WebSocket message:", error);
+                    }
+                };
+                this.ws.onclose = () => {
+                    this.isConnecting = false;
+                    this.stopPing();
+                    if (this.shouldReconnect) {
+                        this.attemptReconnect();
+                    }
+                };
+                this.ws.onerror = (error) => {
+                    console.error("WebSocket error:", error);
+                    this.isConnecting = false;
+                    reject(error);
+                };
+            }
+            catch (error) {
+                this.isConnecting = false;
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error("Max reconnection attempts reached");
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        setTimeout(() => {
+            this.connect().catch(console.error);
+        }, delay);
+    }
+    /**
+     * Start ping interval to keep connection alive
+     */
+    startPing() {
+        this.stopPing();
+        this.pingInterval = setInterval(() => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.send({ type: "ping" });
+            }
+        }, 30000); // Ping every 30 seconds
+    }
+    /**
+     * Stop ping interval
+     */
+    stopPing() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    /**
+     * Send message to server
+     */
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Subscribe to event type
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    /**
+     * Unsubscribe from event type
+     */
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(message) {
+        // Handle connection confirmation
+        if (message.type === "connected") {
+            // Connection confirmed, emit connected event
+            this.emit("connected", message);
+            return;
+        }
+        // Handle pong response
+        if (message.type === "pong") {
+            return;
+        }
+        // Emit event based on message type
+        if (message.type) {
+            this.emit(message.type, message.data || message);
+        }
+    }
+    /**
+     * Emit event to handlers
+     */
+    emit(event, data) {
+        const handlers = this.eventHandlers.get(event);
+        if (!handlers || handlers.size === 0)
+            return;
+        handlers.forEach((handler) => {
+            try {
+                handler(data);
+            }
+            catch (error) {
+                console.error(`Error in WebSocket handler for ${event}:`, error);
+            }
+        });
+    }
+    /**
+     * Disconnect WebSocket
+     */
+    disconnect() {
+        this.shouldReconnect = false;
+        this.stopPing();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+        this.eventHandlers.clear();
+    }
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Update access token (useful after token refresh)
+     */
+    updateToken(newToken) {
+        this.accessToken = newToken;
+        // Reconnect with new token
+        if (this.isConnected()) {
+            this.disconnect();
+            this.connect().catch(console.error);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@recursorsdk/sdk",
+  "version": "1.0.0",
+  "description": "Recursor SDK for Node.js",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/fix-esm-imports.js",
+    "clean": "rm -rf dist",
+    "test": "npm run build && node --test test/*.test.ts test/*.test.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "@types/node": "^20.11.30"
+  }
+}