@ceylonitsolutions/pushstream-js 1.0.1 → 2.0.0

package/README.md

@@ -1,149 +1,104 @@
-# PushStream JavaScript SDK
+# PushStream JavaScript SDK (`sdks` Edition)
 
-Real-time messaging SDK for JavaScript/Node.js applications.
+JavaScript SDK for PushStream realtime connections and server-side event publishing.
 
-## Installation
+## Source
 
-```bash
-npm install @ceylonitsolutions/pushstream-js
-```
+- File: `sdks/pushstream-js/pushstream-sdk.js`
+- Class: `PushStream`
 
-## Quick Start
+## Compatibility
+
+This SDK matches current PushStream protocol:
+
+- WebSocket connect with `app_id` + `app_key`
+- Channel subscribe via `pusher:subscribe`
+- Event publish endpoint: `POST /api/apps/{app_id}/events`
+- Publish auth header: `Authorization: {app_id}:{signature}`
+- Publish `data` field is sent as JSON string
+
+## Installation
+
+This `sdks` version is distributed as source file.
 
 ### Browser
 
 ```html
-<script src="pushstream.js"></script>
-<script>
-  const client = new PushStream('your-app-key');
-  
-  client.connect().then(socketId => {
-    console.log('Connected:', socketId);
-    
-    const channel = client.subscribe('my-channel');
-    channel.bind('my-event', (data) => {
-      console.log('Received:', data);
-    });
-  });
-</script>
+<script src="/path/to/pushstream-sdk.js"></script>
 ```
 
 ### Node.js
 
-```javascript
-const PushStream = require('@ceylonitsolutions/pushstream-js');
-
-const client = new PushStream('your-app-key');
-
-client.connect().then(socketId => {
-  console.log('Connected:', socketId);
-  
-  const channel = client.subscribe('my-channel');
-  channel.bind('my-event', (data) => {
-    console.log('Received:', data);
-  });
-});
+```js
+const PushStream = require('./pushstream-sdk');
 ```
 
-## Configuration
+## Quick Start
 
-```javascript
-const client = new PushStream('your-app-key', {
+```js
+const client = new PushStream('APP_KEY', {
+  appId: 'APP_ID',
   wsUrl: 'wss://ws.pushstream.ceylonitsolutions.online',
   apiUrl: 'https://api.pushstream.ceylonitsolutions.online'
 });
-```
-
-## API Reference
 
-### Client Methods
+await client.connect();
 
-#### `connect()`
-Establishes WebSocket connection.
-
-```javascript
-client.connect()
-  .then(socketId => console.log('Connected'))
-  .catch(error => console.error('Failed to connect'));
-```
-
-#### `subscribe(channelName)`
-Subscribe to a channel.
-
-```javascript
-const channel = client.subscribe('my-channel');
+const channel = client.subscribe('public-updates');
+channel.bind('announcement', (payload) => {
+  console.log(payload);
+});
 ```
 
-#### `unsubscribe(channelName)`
-Unsubscribe from a channel.
-
-```javascript
-client.unsubscribe('my-channel');
-```
+## Private/Presence Channel Notes
 
-#### `disconnect()`
-Close the connection.
+This SDK sends raw subscribe payload. For protected channels (`private-` / `presence-`), you must provide valid channel auth according to server rules.
 
-```javascript
-client.disconnect();
-```
+Recommended approach: use canonical SDK under `sdk/` for built-in auth flow support.
 
-#### `publish(appId, appSecret, channel, event, data)`
-Publish events via REST API.
+## Publish Events
 
-```javascript
+```js
 await client.publish(
-  'app-id',
-  'app-secret',
-  'my-channel',
-  'my-event',
-  { message: 'Hello' }
+  'APP_ID',
+  'APP_SECRET',
+  'orders',
+  'order.created',
+  { id: 101 }
 );
 ```
 
-### Channel Methods
+## Core API
 
-#### `bind(event, callback)`
-Listen for events on the channel.
+### `new PushStream(appKey, options)`
 
-```javascript
-channel.bind('my-event', (data) => {
-  console.log(data);
-});
-```
+Options:
 
-#### `unbind(event, callback)`
-Remove event listener.
+- `appId` (required for WebSocket connect)
+- `wsUrl` (default `wss://ws.pushstream.ceylonitsolutions.online`)
+- `apiUrl` (default `https://api.pushstream.ceylonitsolutions.online`)
 
-```javascript
-channel.unbind('my-event', callback);
-```
-
-#### `unsubscribe()`
-Unsubscribe from the channel.
-
-```javascript
-channel.unsubscribe();
-```
+### Methods
 
-## Features
+- `connect()`
+- `subscribe(channelName)`
+- `unsubscribe(channelName)`
+- `disconnect()`
+- `publish(appId, appSecret, channel, event, data)`
 
-- WebSocket real-time messaging
-- Automatic reconnection with exponential backoff
-- Channel subscriptions
-- Event binding
-- REST API publishing
-- Browser and Node.js support
+## Reconnect Behavior
 
-## Requirements
+- Automatic exponential backoff reconnect
+- Maximum attempts: 5
 
-- Node.js >= 14.0.0 (for Node.js usage)
-- Modern browser with WebSocket support
+## Security Guidance
 
-## License
+- Keep `APP_SECRET` in trusted backend environments only.
+- Use HTTPS/WSS in production.
+- Rotate secrets if compromised.
 
-MIT
+## Migration Recommendation
 
-## Author
+For active maintenance and better channel auth support, migrate to:
 
-Ceylon IT Solutions
+- `sdk/pushstream-js/README.md`

package/dist/pushstream.min.js

@@ -1,225 +1,258 @@
-class PushStream {
-  constructor(appKey, options = {}) {
-    this.appKey = appKey;
-    this.wsUrl = options.wsUrl || 'wss://ws.pushstream.ceylonitsolutions.online';
-    this.apiUrl = options.apiUrl || 'https://api.pushstream.ceylonitsolutions.online';
-    this.ws = null;
-    this.socketId = null;
-    this.channels = new Map();
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-  }
-
-  connect() {
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.wsUrl);
-      } catch (error) {
-        reject(error);
-        this.attemptReconnect();
-        return;
-      }
-
-      const timeout = setTimeout(() => {
-        if (!this.socketId) {
-          reject(new Error('Connection timeout'));
-          this.attemptReconnect();
-        }
-      }, 10000);
-
-      this.ws.onopen = () => {
-        console.log('[PushStream] Connected');
-        this.reconnectAttempts = 0;
-      };
-
-      this.ws.onmessage = (event) => {
-        const message = JSON.parse(event.data);
-        
-        if (message.event === 'pusher:connection_established') {
-          const data = JSON.parse(message.data);
-          this.socketId = data.socket_id;
-          clearTimeout(timeout);
-          resolve(this.socketId);
-        } else if (message.event === 'pusher:error') {
-          console.error('[PushStream] Error:', message.data);
-        } else {
-          this.handleMessage(message);
-        }
-      };
-
-      this.ws.onclose = () => {
-        console.log('[PushStream] Disconnected');
-        clearTimeout(timeout);
-        this.socketId = null;
-        this.attemptReconnect();
-      };
-
-      this.ws.onerror = (error) => {
-        console.error('[PushStream] WebSocket error:', error);
-        clearTimeout(timeout);
-        if (!this.socketId) reject(error);
-      };
-    });
-  }
-
-  attemptReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('[PushStream] Max reconnection attempts reached');
-      return;
-    }
-
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
-    this.reconnectAttempts++;
-
-    console.log(`[PushStream] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    setTimeout(() => this.connect(), delay);
-  }
-
-  subscribe(channelName, callbacks = {}) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error('Not connected');
-    }
-    
-    const channel = new Channel(channelName, this, callbacks);
-    this.channels.set(channelName, channel);
-    
-    this.send({
-      event: 'pusher:subscribe',
-      data: { channel: channelName }
-    });
-
-    return channel;
-  }
-
-  unsubscribe(channelName) {
-    this.send({
-      event: 'pusher:unsubscribe',
-      data: { channel: channelName }
-    });
-    this.channels.delete(channelName);
-  }
-
-  send(data) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(data));
-    }
-  }
-
-  handleMessage(message) {
-    const channel = this.channels.get(message.channel);
-    if (channel) {
-      channel.handleEvent(message.event, JSON.parse(message.data));
-    }
-  }
-
-  disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-
-  // REST API methods
-  async publish(appId, appSecret, channel, event, data) {
-    const timestamp = Math.floor(Date.now() / 1000);
-    const body = JSON.stringify({ name: event, channel, data });
-    const path = `/api/apps/${appId}/events`;
-    const queryString = `auth_timestamp=${timestamp}`;
-    const stringToSign = `POST\n${path}\n${queryString}\n${body}`;
-    
-    const signature = await this.hmacSha256(stringToSign, appSecret);
-    const authHeader = `${appId}:${signature}`;
-
-    const response = await fetch(`${this.apiUrl}${path}?${queryString}`, {
-      method: 'POST',
-      headers: {
-        'Authorization': authHeader,
-        'Content-Type': 'application/json'
-      },
-      body
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
-    }
-
-    return response.json();
-  }
-
-  async hmacSha256(message, secret) {
-    // Node.js
-    if (typeof window === 'undefined') {
-      const crypto = require('crypto');
-      return crypto.createHmac('sha256', secret).update(message).digest('hex');
-    }
-    
-    // Browser
-    const encoder = new TextEncoder();
-    const keyData = encoder.encode(secret);
-    const messageData = encoder.encode(message);
-    
-    const key = await crypto.subtle.importKey(
-      'raw',
-      keyData,
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['sign']
-    );
-    
-    const signature = await crypto.subtle.sign('HMAC', key, messageData);
-    return Array.from(new Uint8Array(signature))
-      .map(b => b.toString(16).padStart(2, '0'))
-      .join('');
-  }
-}
-
-class Channel {
-  constructor(name, client, callbacks = {}) {
-    this.name = name;
-    this.client = client;
-    this.callbacks = callbacks;
-    this.eventHandlers = new Map();
-  }
-
-  bind(event, callback) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, []);
-    }
-    this.eventHandlers.get(event).push(callback);
-    return this;
-  }
-
-  unbind(event, callback) {
-    if (!this.eventHandlers.has(event)) return;
-    
-    if (callback) {
-      const handlers = this.eventHandlers.get(event);
-      const index = handlers.indexOf(callback);
-      if (index > -1) handlers.splice(index, 1);
-    } else {
-      this.eventHandlers.delete(event);
-    }
-    return this;
-  }
-
-  handleEvent(event, data) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      handlers.forEach(handler => handler(data));
-    }
-  }
-
-  unsubscribe() {
-    this.client.unsubscribe(this.name);
-  }
-}
-
-// Node.js support
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = PushStream;
-}
-
-// Browser support
-if (typeof window !== 'undefined') {
-  window.PushStream = PushStream;
-}
+class PushStream {
+  constructor(appKey, options = {}) {
+    this.appKey = appKey;
+    this.appId = options.appId;
+    this.wsUrl = options.wsUrl || 'wss://ws.pushstream.ceylonitsolutions.online';
+    this.apiUrl = options.apiUrl || 'https://api.pushstream.ceylonitsolutions.online';
+    this.ws = null;
+    this.socketId = null;
+    this.channels = new Map();
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (!this.appId || !this.appKey) {
+        reject(new Error('appId and appKey are required'));
+        return;
+      }
+
+      try {
+        this.ws = new WebSocket(`${this.wsUrl}?app_id=${this.appId}&app_key=${this.appKey}`);
+      } catch (error) {
+        reject(error);
+        this.attemptReconnect();
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        if (!this.socketId) {
+          reject(new Error('Connection timeout'));
+          this.attemptReconnect();
+        }
+      }, 10000);
+
+      this.ws.onopen = () => {
+        console.log('[PushStream] Connected');
+        console.log('[PushStream] Waiting for connection_established event...');
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+      };
+
+      this.ws.onmessage = (event) => {
+        console.log('[PushStream] Received message:', event.data);
+        const message = JSON.parse(event.data);
+        
+        if (message.event === 'pusher:connection_established') {
+          const data = JSON.parse(message.data);
+          this.socketId = data.socket_id;
+          clearTimeout(timeout);
+          resolve(this.socketId);
+        } else if (message.event === 'pusher:error') {
+          console.error('[PushStream] Error:', message.data);
+        } else {
+          this.handleMessage(message);
+        }
+      };
+
+      this.ws.onclose = (event) => {
+        console.log('[PushStream] Disconnected', { code: event.code, reason: event.reason });
+        clearTimeout(timeout);
+        this.stopPingInterval();
+        this.socketId = null;
+        this.attemptReconnect();
+      };
+
+      this.ws.onerror = (error) => {
+        console.error('[PushStream] WebSocket error:', error);
+        clearTimeout(timeout);
+        if (!this.socketId) reject(error);
+      };
+    });
+  }
+
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('[PushStream] Max reconnection attempts reached');
+      return;
+    }
+
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+
+    console.log(`[PushStream] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => this.connect(), delay);
+  }
+
+  subscribe(channelName, callbacks = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected');
+    }
+    
+    const channel = new Channel(channelName, this, callbacks);
+    this.channels.set(channelName, channel);
+    
+    this.send({
+      event: 'pusher:subscribe',
+      data: { channel: channelName }
+    });
+
+    return channel;
+  }
+
+  unsubscribe(channelName) {
+    this.send({
+      event: 'pusher:unsubscribe',
+      data: { channel: channelName }
+    });
+    this.channels.delete(channelName);
+  }
+
+  send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+
+  handleMessage(message) {
+    console.log('[PushStream] Handling message:', message);
+    const channel = this.channels.get(message.channel);
+    if (channel) {
+      // Parse data if it's a string
+      const eventData = typeof message.data === 'string' ? JSON.parse(message.data) : message.data;
+      console.log('[PushStream] Parsed data:', eventData);
+      channel.handleEvent(message.event, eventData);
+    } else {
+      console.warn('[PushStream] No channel found for:', message.channel);
+    }
+  }
+
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.send({ event: 'pusher:ping', data: {} });
+      }
+    }, 30000);
+  }
+
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+
+  disconnect() {
+    this.stopPingInterval();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  // REST API methods
+  async publish(appId, appSecret, channel, event, data) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const body = JSON.stringify({ name: event, channel, data });
+    const path = `/api/apps/${appId}/events`;
+    const queryString = `auth_timestamp=${timestamp}`;
+    const stringToSign = `POST\n${path}\n${queryString}\n${body}`;
+    
+    const signature = await this.hmacSha256(stringToSign, appSecret);
+    const authHeader = `${appId}:${signature}`;
+
+    const response = await fetch(`${this.apiUrl}${path}?${queryString}`, {
+      method: 'POST',
+      headers: {
+        'Authorization': authHeader,
+        'Content-Type': 'application/json'
+      },
+      body
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+
+    return response.json();
+  }
+
+  async hmacSha256(message, secret) {
+    // Node.js
+    if (typeof window === 'undefined') {
+      const crypto = require('crypto');
+      return crypto.createHmac('sha256', secret).update(message).digest('hex');
+    }
+    
+    // Browser
+    const encoder = new TextEncoder();
+    const keyData = encoder.encode(secret);
+    const messageData = encoder.encode(message);
+    
+    const key = await crypto.subtle.importKey(
+      'raw',
+      keyData,
+      { name: 'HMAC', hash: 'SHA-256' },
+      false,
+      ['sign']
+    );
+    
+    const signature = await crypto.subtle.sign('HMAC', key, messageData);
+    return Array.from(new Uint8Array(signature))
+      .map(b => b.toString(16).padStart(2, '0'))
+      .join('');
+  }
+}
+
+class Channel {
+  constructor(name, client, callbacks = {}) {
+    this.name = name;
+    this.client = client;
+    this.callbacks = callbacks;
+    this.eventHandlers = new Map();
+  }
+
+  bind(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(callback);
+    return this;
+  }
+
+  unbind(event, callback) {
+    if (!this.eventHandlers.has(event)) return;
+    
+    if (callback) {
+      const handlers = this.eventHandlers.get(event);
+      const index = handlers.indexOf(callback);
+      if (index > -1) handlers.splice(index, 1);
+    } else {
+      this.eventHandlers.delete(event);
+    }
+    return this;
+  }
+
+  handleEvent(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach(handler => handler(data));
+    }
+  }
+
+  unsubscribe() {
+    this.client.unsubscribe(this.name);
+  }
+}
+
+// Node.js support
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = PushStream;
+}
+
+// Browser support
+if (typeof window !== 'undefined') {
+  window.PushStream = PushStream;
+}

package/package.json

@@ -1,25 +1,30 @@
-{
-  "name": "@ceylonitsolutions/pushstream-js",
-  "version": "1.0.1",
-  "description": "PushStream JavaScript SDK for real-time messaging",
-  "main": "pushstream.js",
-  "browser": "dist/pushstream.min.js",
-  "files": [
-    "pushstream.js",
-    "dist/pushstream.min.js"
-  ],
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": ["websocket", "realtime", "pusher", "messaging"],
-  "author": "Ceylon IT Solutions",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/bkkalana/pushstream-js.git"
-  },
-  "dependencies": {},
-  "engines": {
-    "node": ">=14.0.0"
-  }
-}
+{
+  "name": "@ceylonitsolutions/pushstream-js",
+  "version": "2.0.0",
+  "description": "PushStream JavaScript SDK for real-time messaging",
+  "main": "pushstream.js",
+  "browser": "dist/pushstream.min.js",
+  "files": [
+    "pushstream.js",
+    "dist/pushstream.min.js"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "websocket",
+    "realtime",
+    "pusher",
+    "messaging"
+  ],
+  "author": "Ceylon IT Solutions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bkkalana/pushstream-js.git"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/pushstream.js

@@ -1,225 +1,258 @@
-class PushStream {
-  constructor(appKey, options = {}) {
-    this.appKey = appKey;
-    this.wsUrl = options.wsUrl || 'wss://ws.pushstream.ceylonitsolutions.online';
-    this.apiUrl = options.apiUrl || 'https://api.pushstream.ceylonitsolutions.online';
-    this.ws = null;
-    this.socketId = null;
-    this.channels = new Map();
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = 5;
-  }
-
-  connect() {
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.wsUrl);
-      } catch (error) {
-        reject(error);
-        this.attemptReconnect();
-        return;
-      }
-
-      const timeout = setTimeout(() => {
-        if (!this.socketId) {
-          reject(new Error('Connection timeout'));
-          this.attemptReconnect();
-        }
-      }, 10000);
-
-      this.ws.onopen = () => {
-        console.log('[PushStream] Connected');
-        this.reconnectAttempts = 0;
-      };
-
-      this.ws.onmessage = (event) => {
-        const message = JSON.parse(event.data);
-        
-        if (message.event === 'pusher:connection_established') {
-          const data = JSON.parse(message.data);
-          this.socketId = data.socket_id;
-          clearTimeout(timeout);
-          resolve(this.socketId);
-        } else if (message.event === 'pusher:error') {
-          console.error('[PushStream] Error:', message.data);
-        } else {
-          this.handleMessage(message);
-        }
-      };
-
-      this.ws.onclose = () => {
-        console.log('[PushStream] Disconnected');
-        clearTimeout(timeout);
-        this.socketId = null;
-        this.attemptReconnect();
-      };
-
-      this.ws.onerror = (error) => {
-        console.error('[PushStream] WebSocket error:', error);
-        clearTimeout(timeout);
-        if (!this.socketId) reject(error);
-      };
-    });
-  }
-
-  attemptReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error('[PushStream] Max reconnection attempts reached');
-      return;
-    }
-
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
-    this.reconnectAttempts++;
-
-    console.log(`[PushStream] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    setTimeout(() => this.connect(), delay);
-  }
-
-  subscribe(channelName, callbacks = {}) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error('Not connected');
-    }
-    
-    const channel = new Channel(channelName, this, callbacks);
-    this.channels.set(channelName, channel);
-    
-    this.send({
-      event: 'pusher:subscribe',
-      data: { channel: channelName }
-    });
-
-    return channel;
-  }
-
-  unsubscribe(channelName) {
-    this.send({
-      event: 'pusher:unsubscribe',
-      data: { channel: channelName }
-    });
-    this.channels.delete(channelName);
-  }
-
-  send(data) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(data));
-    }
-  }
-
-  handleMessage(message) {
-    const channel = this.channels.get(message.channel);
-    if (channel) {
-      channel.handleEvent(message.event, JSON.parse(message.data));
-    }
-  }
-
-  disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-
-  // REST API methods
-  async publish(appId, appSecret, channel, event, data) {
-    const timestamp = Math.floor(Date.now() / 1000);
-    const body = JSON.stringify({ name: event, channel, data });
-    const path = `/api/apps/${appId}/events`;
-    const queryString = `auth_timestamp=${timestamp}`;
-    const stringToSign = `POST\n${path}\n${queryString}\n${body}`;
-    
-    const signature = await this.hmacSha256(stringToSign, appSecret);
-    const authHeader = `${appId}:${signature}`;
-
-    const response = await fetch(`${this.apiUrl}${path}?${queryString}`, {
-      method: 'POST',
-      headers: {
-        'Authorization': authHeader,
-        'Content-Type': 'application/json'
-      },
-      body
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
-    }
-
-    return response.json();
-  }
-
-  async hmacSha256(message, secret) {
-    // Node.js
-    if (typeof window === 'undefined') {
-      const crypto = require('crypto');
-      return crypto.createHmac('sha256', secret).update(message).digest('hex');
-    }
-    
-    // Browser
-    const encoder = new TextEncoder();
-    const keyData = encoder.encode(secret);
-    const messageData = encoder.encode(message);
-    
-    const key = await crypto.subtle.importKey(
-      'raw',
-      keyData,
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['sign']
-    );
-    
-    const signature = await crypto.subtle.sign('HMAC', key, messageData);
-    return Array.from(new Uint8Array(signature))
-      .map(b => b.toString(16).padStart(2, '0'))
-      .join('');
-  }
-}
-
-class Channel {
-  constructor(name, client, callbacks = {}) {
-    this.name = name;
-    this.client = client;
-    this.callbacks = callbacks;
-    this.eventHandlers = new Map();
-  }
-
-  bind(event, callback) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, []);
-    }
-    this.eventHandlers.get(event).push(callback);
-    return this;
-  }
-
-  unbind(event, callback) {
-    if (!this.eventHandlers.has(event)) return;
-    
-    if (callback) {
-      const handlers = this.eventHandlers.get(event);
-      const index = handlers.indexOf(callback);
-      if (index > -1) handlers.splice(index, 1);
-    } else {
-      this.eventHandlers.delete(event);
-    }
-    return this;
-  }
-
-  handleEvent(event, data) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      handlers.forEach(handler => handler(data));
-    }
-  }
-
-  unsubscribe() {
-    this.client.unsubscribe(this.name);
-  }
-}
-
-// Node.js support
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = PushStream;
-}
-
-// Browser support
-if (typeof window !== 'undefined') {
-  window.PushStream = PushStream;
-}
+class PushStream {
+  constructor(appKey, options = {}) {
+    this.appKey = appKey;
+    this.appId = options.appId;
+    this.wsUrl = options.wsUrl || 'wss://ws.pushstream.ceylonitsolutions.online';
+    this.apiUrl = options.apiUrl || 'https://api.pushstream.ceylonitsolutions.online';
+    this.ws = null;
+    this.socketId = null;
+    this.channels = new Map();
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (!this.appId || !this.appKey) {
+        reject(new Error('appId and appKey are required'));
+        return;
+      }
+
+      try {
+        this.ws = new WebSocket(`${this.wsUrl}?app_id=${this.appId}&app_key=${this.appKey}`);
+      } catch (error) {
+        reject(error);
+        this.attemptReconnect();
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        if (!this.socketId) {
+          reject(new Error('Connection timeout'));
+          this.attemptReconnect();
+        }
+      }, 10000);
+
+      this.ws.onopen = () => {
+        console.log('[PushStream] Connected');
+        console.log('[PushStream] Waiting for connection_established event...');
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+      };
+
+      this.ws.onmessage = (event) => {
+        console.log('[PushStream] Received message:', event.data);
+        const message = JSON.parse(event.data);
+        
+        if (message.event === 'pusher:connection_established') {
+          const data = JSON.parse(message.data);
+          this.socketId = data.socket_id;
+          clearTimeout(timeout);
+          resolve(this.socketId);
+        } else if (message.event === 'pusher:error') {
+          console.error('[PushStream] Error:', message.data);
+        } else {
+          this.handleMessage(message);
+        }
+      };
+
+      this.ws.onclose = (event) => {
+        console.log('[PushStream] Disconnected', { code: event.code, reason: event.reason });
+        clearTimeout(timeout);
+        this.stopPingInterval();
+        this.socketId = null;
+        this.attemptReconnect();
+      };
+
+      this.ws.onerror = (error) => {
+        console.error('[PushStream] WebSocket error:', error);
+        clearTimeout(timeout);
+        if (!this.socketId) reject(error);
+      };
+    });
+  }
+
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('[PushStream] Max reconnection attempts reached');
+      return;
+    }
+
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+
+    console.log(`[PushStream] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => this.connect(), delay);
+  }
+
+  subscribe(channelName, callbacks = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected');
+    }
+    
+    const channel = new Channel(channelName, this, callbacks);
+    this.channels.set(channelName, channel);
+    
+    this.send({
+      event: 'pusher:subscribe',
+      data: { channel: channelName }
+    });
+
+    return channel;
+  }
+
+  unsubscribe(channelName) {
+    this.send({
+      event: 'pusher:unsubscribe',
+      data: { channel: channelName }
+    });
+    this.channels.delete(channelName);
+  }
+
+  send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+
+  handleMessage(message) {
+    console.log('[PushStream] Handling message:', message);
+    const channel = this.channels.get(message.channel);
+    if (channel) {
+      // Parse data if it's a string
+      const eventData = typeof message.data === 'string' ? JSON.parse(message.data) : message.data;
+      console.log('[PushStream] Parsed data:', eventData);
+      channel.handleEvent(message.event, eventData);
+    } else {
+      console.warn('[PushStream] No channel found for:', message.channel);
+    }
+  }
+
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.send({ event: 'pusher:ping', data: {} });
+      }
+    }, 30000);
+  }
+
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+
+  disconnect() {
+    this.stopPingInterval();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  // REST API methods
+  async publish(appId, appSecret, channel, event, data) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const body = JSON.stringify({ name: event, channel, data });
+    const path = `/api/apps/${appId}/events`;
+    const queryString = `auth_timestamp=${timestamp}`;
+    const stringToSign = `POST\n${path}\n${queryString}\n${body}`;
+    
+    const signature = await this.hmacSha256(stringToSign, appSecret);
+    const authHeader = `${appId}:${signature}`;
+
+    const response = await fetch(`${this.apiUrl}${path}?${queryString}`, {
+      method: 'POST',
+      headers: {
+        'Authorization': authHeader,
+        'Content-Type': 'application/json'
+      },
+      body
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+
+    return response.json();
+  }
+
+  async hmacSha256(message, secret) {
+    // Node.js
+    if (typeof window === 'undefined') {
+      const crypto = require('crypto');
+      return crypto.createHmac('sha256', secret).update(message).digest('hex');
+    }
+    
+    // Browser
+    const encoder = new TextEncoder();
+    const keyData = encoder.encode(secret);
+    const messageData = encoder.encode(message);
+    
+    const key = await crypto.subtle.importKey(
+      'raw',
+      keyData,
+      { name: 'HMAC', hash: 'SHA-256' },
+      false,
+      ['sign']
+    );
+    
+    const signature = await crypto.subtle.sign('HMAC', key, messageData);
+    return Array.from(new Uint8Array(signature))
+      .map(b => b.toString(16).padStart(2, '0'))
+      .join('');
+  }
+}
+
+class Channel {
+  constructor(name, client, callbacks = {}) {
+    this.name = name;
+    this.client = client;
+    this.callbacks = callbacks;
+    this.eventHandlers = new Map();
+  }
+
+  bind(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(callback);
+    return this;
+  }
+
+  unbind(event, callback) {
+    if (!this.eventHandlers.has(event)) return;
+    
+    if (callback) {
+      const handlers = this.eventHandlers.get(event);
+      const index = handlers.indexOf(callback);
+      if (index > -1) handlers.splice(index, 1);
+    } else {
+      this.eventHandlers.delete(event);
+    }
+    return this;
+  }
+
+  handleEvent(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach(handler => handler(data));
+    }
+  }
+
+  unsubscribe() {
+    this.client.unsubscribe(this.name);
+  }
+}
+
+// Node.js support
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = PushStream;
+}
+
+// Browser support
+if (typeof window !== 'undefined') {
+  window.PushStream = PushStream;
+}