skikrumb-api 2.1.20 → 2.2.0

package/dist/index.d.ts

@@ -8,21 +8,34 @@ declare class SkiKrumbRealtimeClient {
     private userId;
     private endpointType;
     private listeners;
-    private isConnecting;
     private reconnectAttempts;
     private maxReconnectAttempts;
     private reconnectDelay;
     private maxReconnectDelay;
+    private reconnectTimer;
+    private manuallyDisconnected;
+    private connectPromise;
+    private connectReject;
+    private connectTimeoutTimer;
+    private connectTimeout;
+    private heartbeatTimer;
+    private pongTimer;
+    private heartbeatIntervalMs;
+    private pongTimeoutMs;
     constructor(userId: string, url: string, endpointType: RealtimeEndpointType, sessionToken?: string, supabaseToken?: string);
     connect(): Promise<void>;
     private connectToWebSocket;
     private scheduleReconnect;
+    private resetHeartbeat;
+    private clearHeartbeat;
     disconnect(): void;
-    ping(): void;
-    sendPong(): void;
-    requestRefresh(): void;
+    destroy(): void;
+    ping(): boolean;
+    sendPong(): boolean;
+    requestRefresh(): boolean;
     on(event: string, callback: Function): void;
     off(event: string, callback?: Function): void;
+    removeAllListeners(): void;
     private emit;
     isConnected(): boolean;
 }
@@ -41,6 +54,9 @@ export declare const skiKrumb: (options?: {
     readOrganizationData: () => Promise<Data[]>;
     readGateways: () => Promise<Gateways>;
     readShippingRates: (rateRequest: RateRequest) => Promise<Rates>;
+    sendLogs: (payload: {
+        logs: any[];
+    }) => Promise<unknown>;
     sendMobileLocation: (payload: {
         deviceId: string;
         locations: any[];

package/dist/index.js

@@ -3,11 +3,20 @@ class SkiKrumbRealtimeClient {
     constructor(userId, url, endpointType, sessionToken, supabaseToken) {
         this.websocket = null;
         this.listeners = {};
-        this.isConnecting = false;
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = Infinity; // Never stop trying
         this.reconnectDelay = 1000; // 1 second base
         this.maxReconnectDelay = 300000; // 5 minutes max
+        this.reconnectTimer = null;
+        this.manuallyDisconnected = false;
+        this.connectPromise = null;
+        this.connectReject = null;
+        this.connectTimeoutTimer = null;
+        this.connectTimeout = 15000; // 15 second connect handshake timeout
+        this.heartbeatTimer = null;
+        this.pongTimer = null;
+        this.heartbeatIntervalMs = 30000; // Send ping after 30s silence
+        this.pongTimeoutMs = 10000; // Expect response within 10s
         this.userId = userId;
         this.url = url.replace(/\/+$/, ''); // Remove trailing slashes
         this.endpointType = endpointType;
@@ -15,29 +24,40 @@ class SkiKrumbRealtimeClient {
         this.supabaseToken = supabaseToken;
     }
     async connect() {
-        if (this.isConnecting) {
-            return Promise.resolve();
+        this.manuallyDisconnected = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
         }
-        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
-            return Promise.resolve();
+        if (this.connectPromise) {
+            return this.connectPromise;
         }
-        // Additional guard: check if we're already connecting or connected
         if (this.websocket &&
             (this.websocket.readyState === WebSocket.CONNECTING ||
                 this.websocket.readyState === WebSocket.OPEN)) {
-            return Promise.resolve();
+            return;
         }
         // Clean up any stale websocket before creating new one
+        // Don't use disconnect() here — it sets manuallyDisconnected = true,
+        // which would prevent auto-reconnect if the subsequent connection fails.
         if (this.websocket && this.websocket.readyState >= WebSocket.CLOSING) {
-            this.disconnect();
+            this.clearHeartbeat();
+            this.websocket.onopen = null;
+            this.websocket.onmessage = null;
+            this.websocket.onerror = null;
+            this.websocket.onclose = null;
+            this.websocket = null;
         }
-        this.isConnecting = true;
+        const promise = this.connectToWebSocket();
+        this.connectPromise = promise;
         try {
-            await this.connectToWebSocket();
+            await promise;
         }
-        catch (error) {
-            this.isConnecting = false;
-            throw error;
+        finally {
+            // Only null if this is still OUR promise (not a newer connect's)
+            if (this.connectPromise === promise) {
+                this.connectPromise = null;
+            }
         }
     }
     connectToWebSocket() {
@@ -55,6 +75,18 @@ class SkiKrumbRealtimeClient {
                     return reject(new Error('Session token is required for user endpoint.'));
                 }
                 wsUrl = `${baseWsUrl}${endpointPath}?token=${encodeURIComponent(this.sessionToken)}&supabaseToken=${encodeURIComponent(this.supabaseToken)}`;
+                this.connectReject = reject;
+                // Start connect timeout — safety net if server never sends auth_success
+                this.connectTimeoutTimer = setTimeout(() => {
+                    var _a;
+                    this.connectTimeoutTimer = null;
+                    if (this.connectReject) {
+                        const pendingReject = this.connectReject;
+                        this.connectReject = null;
+                        (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close();
+                        pendingReject(new Error('connect_timeout'));
+                    }
+                }, this.connectTimeout);
                 this.websocket = new WebSocket(wsUrl);
                 this.websocket.onopen = () => {
                     // Authentication is handled automatically via query parameters
@@ -63,15 +95,25 @@ class SkiKrumbRealtimeClient {
                 this.websocket.onmessage = (event) => {
                     var _a, _b, _c, _d, _e, _f;
                     try {
+                        this.resetHeartbeat();
                         const message = JSON.parse(event.data);
                         if (message.type === 'auth_success') {
-                            this.isConnecting = false;
                             this.reconnectAttempts = 0;
+                            this.connectReject = null;
+                            if (this.connectTimeoutTimer) {
+                                clearTimeout(this.connectTimeoutTimer);
+                                this.connectTimeoutTimer = null;
+                            }
                             this.emit('connected', message);
                             resolve();
                         }
                         else if (message.type === 'auth_error' ||
                             message.type === 'error') {
+                            this.connectReject = null;
+                            if (this.connectTimeoutTimer) {
+                                clearTimeout(this.connectTimeoutTimer);
+                                this.connectTimeoutTimer = null;
+                            }
                             (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close();
                             reject(new Error(`Connection failed: ${message.message || message.error}`));
                         }
@@ -123,50 +165,112 @@ class SkiKrumbRealtimeClient {
                     }
                 };
                 this.websocket.onerror = (error) => {
-                    this.isConnecting = false;
+                    this.connectReject = null;
+                    if (this.connectTimeoutTimer) {
+                        clearTimeout(this.connectTimeoutTimer);
+                        this.connectTimeoutTimer = null;
+                    }
                     this.emit('error', error);
                     reject(error);
                 };
                 this.websocket.onclose = (event) => {
+                    this.clearHeartbeat();
                     this.websocket = null;
-                    this.isConnecting = false;
-                    // Don't auto-reconnect if it's a session replacement or normal close
-                    if (event.code === 4000) {
-                        this.emit('disconnected', { reason: 'Session replaced' });
+                    const pendingReject = this.connectReject;
+                    this.connectReject = null;
+                    if (this.connectTimeoutTimer) {
+                        clearTimeout(this.connectTimeoutTimer);
+                        this.connectTimeoutTimer = null;
                     }
-                    else if (event.code === 1000) {
-                        this.emit('disconnected', { reason: 'Manual disconnect' });
+                    if (event.code === 4000 || event.reason === 'New connection established') {
+                        this.emit('session_replaced', {
+                            reason: event.reason || 'Session replaced',
+                        });
+                        this.emit('disconnected', { reason: 'Session replaced' });
                     }
                     else {
-                        // Only reconnect for unexpected disconnections
                         this.emit('disconnected', {
                             reason: event.reason || 'Connection closed',
                         });
-                        // Always try to reconnect with smart backoff
-                        this.scheduleReconnect();
+                        if (event.code !== 1000) {
+                            this.scheduleReconnect();
+                        }
                     }
+                    // Reject pending connect promise if onclose fired before auth_success
+                    pendingReject === null || pendingReject === void 0 ? void 0 : pendingReject(new Error(event.reason || 'Connection closed before auth'));
                 };
             }
             catch (error) {
-                this.isConnecting = false;
+                this.connectReject = null;
+                if (this.connectTimeoutTimer) {
+                    clearTimeout(this.connectTimeoutTimer);
+                    this.connectTimeoutTimer = null;
+                }
                 reject(error);
             }
         });
     }
     scheduleReconnect() {
+        if (this.manuallyDisconnected)
+            return;
         this.reconnectAttempts++;
-        // Exponential backoff with 5-minute cap
-        const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
-        setTimeout(() => {
-            this.connect().catch((error) => {
+        // Exponential backoff with 5-minute cap and jitter to prevent thundering herd
+        const base = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+        const delay = Math.round(base * (0.5 + Math.random() * 0.5));
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch(() => {
                 // Errors are expected during reconnection, will keep trying
-                // No max attempts check - keeps trying indefinitely with smart backoff
             });
         }, delay);
     }
+    resetHeartbeat() {
+        var _a;
+        this.clearHeartbeat();
+        if (((_a = this.websocket) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            this.heartbeatTimer = setTimeout(() => {
+                this.heartbeatTimer = null;
+                // No messages received for 30s — probe the connection
+                if (this.ping()) {
+                    this.pongTimer = setTimeout(() => {
+                        var _a;
+                        this.pongTimer = null;
+                        // No response to probe — connection is dead
+                        (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close(4001, 'Heartbeat timeout');
+                    }, this.pongTimeoutMs);
+                }
+            }, this.heartbeatIntervalMs);
+        }
+    }
+    clearHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.pongTimer) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
     disconnect() {
-        this.isConnecting = false;
+        this.manuallyDisconnected = true;
+        this.connectPromise = null;
         this.reconnectAttempts = 0;
+        this.clearHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Reject pending connect promise so await connect() throws
+        if (this.connectReject) {
+            const pendingReject = this.connectReject;
+            this.connectReject = null;
+            if (this.connectTimeoutTimer) {
+                clearTimeout(this.connectTimeoutTimer);
+                this.connectTimeoutTimer = null;
+            }
+            pendingReject(new Error('disconnect() called'));
+        }
         if (this.websocket) {
             // Remove all listeners to prevent events during cleanup
             this.websocket.onopen = null;
@@ -181,15 +285,23 @@ class SkiKrumbRealtimeClient {
             this.websocket = null;
         }
     }
+    destroy() {
+        this.disconnect();
+        this.removeAllListeners();
+    }
     ping() {
         if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
             this.websocket.send(JSON.stringify({ type: 'ping', timestamp: new Date().toISOString() }));
+            return true;
         }
+        return false;
     }
     sendPong() {
         if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
             this.websocket.send(JSON.stringify({ type: 'pong', timestamp: new Date().toISOString() }));
+            return true;
         }
+        return false;
     }
     requestRefresh() {
         if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
@@ -197,7 +309,9 @@ class SkiKrumbRealtimeClient {
                 type: 'request_refresh',
                 timestamp: new Date().toISOString(),
             }));
+            return true;
         }
+        return false;
     }
     on(event, callback) {
         if (!this.listeners[event]) {
@@ -215,13 +329,18 @@ class SkiKrumbRealtimeClient {
             this.listeners[event] = [];
         }
     }
+    removeAllListeners() {
+        this.listeners = {};
+    }
     emit(event, data) {
         const callbacks = this.listeners[event] || [];
         callbacks.forEach((callback) => {
             try {
                 callback(data);
             }
-            catch (error) { }
+            catch (error) {
+                console.warn(`[SkiKrumbRealtime] Error in "${event}" listener:`, error);
+            }
         });
     }
     isConnected() {
@@ -353,6 +472,12 @@ export const skiKrumb = (options = {
             throw error;
         }
     };
+    const sendLogs = async (payload) => {
+        const response = await request
+            .post('devices/logs', { json: payload })
+            .json();
+        return response;
+    };
     const sendMobileLocation = async (payload) => {
         const response = await request
             .post('devices/location/mobile', { json: payload })
@@ -680,6 +805,7 @@ export const skiKrumb = (options = {
         readOrganizationData,
         readGateways,
         readShippingRates,
+        sendLogs,
         sendMobileLocation,
         authenticateExternalUser,
         refreshSessionToken,

package/dist/models.d.ts

@@ -109,6 +109,7 @@ export interface ExternalUserResponse {
     success: boolean;
     accountId?: string;
     sessionToken?: string;
+    supabaseToken?: string;
     isNewUser?: boolean;
     error?: string;
     accessibleSerials?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skikrumb-api",
-  "version": "2.1.20",
+  "version": "2.2.0",
   "description": "Wrapper for the skiKrumb API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,5 +20,6 @@
   },
   "dependencies": {
     "ky": "^1.7.5"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610"
 }

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//Users/michael/.config/nvim/**)",
-      "Read(//Users/michael/.config/**)",
-      "Read(//Users/michael/Code/skikrumb-api/**)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}