openkbs-pulse 1.0.17 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openkbs-pulse",
-  "version": "1.0.17",
-  "description": "Real-time WebSocket SDK for OpenKBS",
+  "version": "2.0.0",
+  "description": "Real-time WebSocket SDK for OpenKBS (Ably-compatible API)",
   "type": "module",
   "main": "pulse.js",
   "types": "pulse.d.ts",

package/pulse.js

@@ -1,494 +1,650 @@
 /**
- * OpenKBS Pulse v1.0.12 - Real-time WebSocket SDK
+ * OpenKBS Pulse - Client SDK (Ably-compatible API)
  *
  * Usage:
- *   const pulse = new Pulse({ kbId: 'your-kb-id', token: 'user-token' });
+ *   const realtime = new Pulse.Realtime({ kbId: 'xxx', token: 'yyy' });
  *
- *   const channel = pulse.channel('posts');
- *   channel.subscribe('new_post', (data) => console.log('New post:', data));
- *   channel.publish('new_post', { title: 'Hello' });
+ *   const channel = realtime.channels.get('chat');
+ *   channel.subscribe((message) => console.log(message.name, message.data));
+ *   channel.publish('greeting', { text: 'Hello!' });
  *
- *   channel.presence.subscribe((members) => console.log('Online:', members.length));
- *   channel.presence.enter({ name: 'John' });
+ *   channel.presence.subscribe((members) => console.log(members));
+ *   channel.presence.enter({ status: 'online' });
  */
 
 (function(global) {
     'use strict';
 
-    const PULSE_ENDPOINTS = {
+    const ENDPOINTS = {
         'us-east-1': 'wss://pulse.vpc1.us',
         'eu-central-1': 'wss://pulse.vpc1.eu'
     };
 
-    const DEFAULT_REGION = 'us-east-1';
     const RECONNECT_DELAYS = [1000, 2000, 5000, 10000, 30000];
 
-    /**
-     * Main Pulse client
-     */
-    class Pulse {
+    // ========================================================================
+    // Realtime Client (like Ably.Realtime)
+    // ========================================================================
+
+    class Realtime {
         constructor(options = {}) {
-            if (!options.kbId) {
-                throw new Error('Pulse: kbId is required');
-            }
-            if (!options.token) {
-                throw new Error('Pulse: token is required');
-            }
+            if (!options.kbId) throw new Error('kbId is required');
+            if (!options.token) throw new Error('token is required');
 
             this.kbId = options.kbId;
             this.token = options.token;
-            this._defaultChannel = options.channel || 'default';
-            this.region = options.region || DEFAULT_REGION;
-            this.endpoint = options.endpoint || PULSE_ENDPOINTS[this.region] || PULSE_ENDPOINTS[DEFAULT_REGION];
+            this.clientId = options.clientId || null;
+            this.region = options.region || 'us-east-1';
+            this.endpoint = options.endpoint || ENDPOINTS[this.region] || ENDPOINTS['us-east-1'];
             this.debug = options.debug || false;
 
-            this._channels = {};
+            // Connection state
+            this.connection = new Connection(this);
+
+            // Channels manager
+            this.channels = new Channels(this);
+
+            // Internal
             this._ws = null;
             this._reconnectAttempt = 0;
             this._intentionalClose = false;
-            this._connectionState = 'disconnected';
-            this._stateListeners = [];
             this._messageQueue = [];
 
-            // Auto-connect unless disabled
+            // Auto-connect
             if (options.autoConnect !== false) {
                 this.connect();
             }
         }
 
-        /**
-         * Connect to Pulse WebSocket server
-         */
         connect() {
-            if (this._ws && this._ws.readyState === WebSocket.OPEN) {
-                this._log('Already connected');
-                return;
-            }
+            if (this._ws?.readyState === WebSocket.OPEN) return;
 
             this._intentionalClose = false;
-            this._setConnectionState('connecting');
+            this.connection._setState('connecting');
 
-            const url = `${this.endpoint}?kbId=${this.kbId}&token=${this.token}&channel=${this._defaultChannel}`;
-            this._log('Connecting to:', url);
+            const url = `${this.endpoint}?kbId=${this.kbId}&token=${this.token}`;
+            this._log('Connecting:', url);
 
             try {
                 this._ws = new WebSocket(url);
-                this._setupWebSocket();
+                this._ws.onopen = () => this._onOpen();
+                this._ws.onclose = (e) => this._onClose(e);
+                this._ws.onerror = (e) => this._onError(e);
+                this._ws.onmessage = (e) => this._onMessage(e);
             } catch (err) {
                 this._log('Connection error:', err);
-                this._setConnectionState('failed');
+                this.connection._setState('failed');
                 this._scheduleReconnect();
             }
         }
 
-        /**
-         * Disconnect from server
-         */
-        disconnect() {
+        close() {
             this._intentionalClose = true;
-            this._setConnectionState('disconnecting');
-
-            if (this._ws) {
-                this._ws.close(1000, 'Client disconnect');
-                this._ws = null;
-            }
-
-            this._setConnectionState('disconnected');
-        }
-
-        /**
-         * Get or create a channel
-         */
-        channel(name) {
-            if (!this._channels[name]) {
-                this._channels[name] = new PulseChannel(this, name);
-            }
-            return this._channels[name];
-        }
-
-        /**
-         * Subscribe to connection state changes
-         */
-        onStateChange(callback) {
-            this._stateListeners.push(callback);
-            // Immediately call with current state
-            callback(this._connectionState);
-            return () => {
-                this._stateListeners = this._stateListeners.filter(cb => cb !== callback);
-            };
-        }
-
-        /**
-         * Get current connection state
-         */
-        get state() {
-            return this._connectionState;
-        }
-
-        /**
-         * Check if connected
-         */
-        get isConnected() {
-            return this._connectionState === 'connected';
+            this.connection._setState('closing');
+            this._ws?.close(1000, 'Client closed');
+            this._ws = null;
+            this.connection._setState('closed');
         }
 
         // Internal methods
 
-        _setupWebSocket() {
-            this._ws.onopen = () => {
-                this._log('Connected');
-                this._reconnectAttempt = 0;
-                this._setConnectionState('connected');
+        _onOpen() {
+            this._log('Connected');
+            this._reconnectAttempt = 0;
+            this.connection._setState('connected');
 
-                // Resubscribe to all channels
-                Object.values(this._channels).forEach(channel => {
-                    channel._resubscribe();
-                });
+            // Reattach all channels
+            this.channels._reattachAll();
 
-                // Flush message queue
-                this._flushMessageQueue();
-            };
+            // Flush queued messages
+            this._flushQueue();
+        }
 
-            this._ws.onclose = (e) => {
-                this._log('Disconnected:', e.code, e.reason);
-                this._setConnectionState('disconnected');
+        _onClose(e) {
+            this._log('Disconnected:', e.code, e.reason);
+            this.connection._setState('disconnected');
 
-                if (!this._intentionalClose) {
-                    this._scheduleReconnect();
-                }
-            };
-
-            this._ws.onerror = (err) => {
-                this._log('WebSocket error:', err);
-                this._setConnectionState('failed');
-            };
+            if (!this._intentionalClose) {
+                this._scheduleReconnect();
+            }
+        }
 
-            this._ws.onmessage = (e) => {
-                this._handleMessage(e.data);
-            };
+        _onError(err) {
+            this._log('Error:', err);
+            this.connection._setState('failed');
         }
 
-        _handleMessage(data) {
-            this._log('Received:', data);
+        _onMessage(e) {
+            this._log('Received:', e.data);
 
             try {
-                const msg = JSON.parse(data);
-
-                // Handle server message format: {type: 'message', channel: 'x', data: {...}}
-                if (msg.type === 'message' && msg.data) {
-                    // Route to the correct channel based on msg.channel
-                    const channelName = msg.channel || this._defaultChannel;
-                    const channel = this._channels[channelName];
-                    if (channel) {
-                        channel._handleMessage(msg.data);
-                    }
-                }
-
-                // Handle presence response: {type: 'presence', channel: 'x', action: 'sync', members: [...]}
-                if (msg.type === 'presence') {
-                    const channelName = msg.channel || this._defaultChannel;
-                    const channel = this._channels[channelName];
-                    if (channel && channel.presence) {
-                        channel.presence._handleMessage(msg);
-                    }
-                }
-
-                // Handle system messages
-                if (msg.type === 'error') {
-                    this._log('Server error:', msg.error);
-                }
+                const msg = JSON.parse(e.data);
+                this._handleMessage(msg);
             } catch (err) {
                 this._log('Parse error:', err);
             }
         }
 
+        _handleMessage(msg) {
+            const { action, channel } = msg;
+
+            // Route to channel
+            if (channel) {
+                const ch = this.channels._channels[channel];
+                if (ch) ch._handleMessage(msg);
+            }
+
+            // Handle heartbeat response
+            if (action === 'heartbeat') {
+                this.connection._emit('heartbeat', msg.timestamp);
+            }
+        }
+
         _send(data) {
-            if (this._ws && this._ws.readyState === WebSocket.OPEN) {
+            if (this._ws?.readyState === WebSocket.OPEN) {
                 this._ws.send(JSON.stringify(data));
                 return true;
-            } else {
-                // Queue message for when connected
-                this._messageQueue.push(data);
-                return false;
             }
+            this._messageQueue.push(data);
+            return false;
         }
 
-        _flushMessageQueue() {
+        _flushQueue() {
             while (this._messageQueue.length > 0) {
-                const msg = this._messageQueue.shift();
-                this._send(msg);
+                this._send(this._messageQueue.shift());
             }
         }
 
         _scheduleReconnect() {
             const delay = RECONNECT_DELAYS[Math.min(this._reconnectAttempt, RECONNECT_DELAYS.length - 1)];
             this._reconnectAttempt++;
-
             this._log(`Reconnecting in ${delay}ms (attempt ${this._reconnectAttempt})`);
-            this._setConnectionState('reconnecting');
+            this.connection._setState('connecting');
+            setTimeout(() => !this._intentionalClose && this.connect(), delay);
+        }
 
-            setTimeout(() => {
-                if (!this._intentionalClose) {
-                    this.connect();
-                }
-            }, delay);
+        _log(...args) {
+            if (this.debug) console.log('[Pulse]', ...args);
+        }
+    }
+
+    // ========================================================================
+    // Connection (like Ably.Connection)
+    // ========================================================================
+
+    class Connection {
+        constructor(realtime) {
+            this._realtime = realtime;
+            this.state = 'initialized';
+            this._listeners = {};
+        }
+
+        get id() {
+            return this._realtime._ws?.url || null;
         }
 
-        _setConnectionState(state) {
-            if (this._connectionState !== state) {
-                this._connectionState = state;
-                this._stateListeners.forEach(cb => cb(state));
+        on(event, callback) {
+            if (!this._listeners[event]) this._listeners[event] = [];
+            this._listeners[event].push(callback);
+            return () => this.off(event, callback);
+        }
+
+        off(event, callback) {
+            if (this._listeners[event]) {
+                this._listeners[event] = this._listeners[event].filter(cb => cb !== callback);
             }
         }
 
-        _log(...args) {
-            if (this.debug) {
-                console.log('[Pulse]', ...args);
+        once(event, callback) {
+            const wrapper = (...args) => {
+                this.off(event, wrapper);
+                callback(...args);
+            };
+            this.on(event, wrapper);
+        }
+
+        _setState(state) {
+            if (this.state !== state) {
+                const prev = this.state;
+                this.state = state;
+                this._emit('stateChange', { current: state, previous: prev });
+                this._emit(state);
             }
         }
+
+        _emit(event, data) {
+            (this._listeners[event] || []).forEach(cb => cb(data));
+        }
     }
 
-    /**
-     * Channel for pub/sub messaging
-     */
-    class PulseChannel {
-        constructor(pulse, name) {
-            this._pulse = pulse;
+    // ========================================================================
+    // Channels Manager (like Ably.Channels)
+    // ========================================================================
+
+    class Channels {
+        constructor(realtime) {
+            this._realtime = realtime;
+            this._channels = {};
+        }
+
+        get(name) {
+            if (!this._channels[name]) {
+                this._channels[name] = new Channel(this._realtime, name);
+            }
+            return this._channels[name];
+        }
+
+        release(name) {
+            const ch = this._channels[name];
+            if (ch) {
+                ch.detach();
+                delete this._channels[name];
+            }
+        }
+
+        _reattachAll() {
+            Object.values(this._channels).forEach(ch => ch._reattach());
+        }
+    }
+
+    // ========================================================================
+    // Channel (like Ably.Channel)
+    // ========================================================================
+
+    class Channel {
+        constructor(realtime, name) {
+            this._realtime = realtime;
             this.name = name;
-            this._subscribers = {};
-            this._allSubscribers = [];
-            this._subscribed = false;
+            this.state = 'initialized';
+            this._listeners = {};
+            this._messageListeners = [];
+            this._attached = false;
 
             // Presence sub-object
-            this.presence = new PulsePresence(this);
+            this.presence = new Presence(this);
         }
 
         /**
-         * Subscribe to a specific event type
+         * Attach to channel (start receiving messages)
          */
-        subscribe(event, callback) {
-            if (typeof event === 'function') {
-                // Subscribe to all events
-                callback = event;
-                this._allSubscribers.push(callback);
+        attach(callback) {
+            if (this._attached) {
+                callback?.();
+                return Promise.resolve();
+            }
+
+            return new Promise((resolve, reject) => {
+                this._realtime._send({ action: 'attach', channel: this.name });
+                this._attached = true;
+                this.state = 'attaching';
+
+                // Wait for attached confirmation
+                const onAttached = (msg) => {
+                    if (msg.action === 'attached') {
+                        this.off('_internal', onAttached);
+                        this.state = 'attached';
+                        callback?.();
+                        resolve();
+                    }
+                };
+                this.on('_internal', onAttached);
+
+                // Timeout
+                setTimeout(() => {
+                    if (this.state === 'attaching') {
+                        this.state = 'attached';  // Assume success
+                        callback?.();
+                        resolve();
+                    }
+                }, 1000);
+            });
+        }
+
+        /**
+         * Detach from channel
+         */
+        detach(callback) {
+            this._realtime._send({ action: 'detach', channel: this.name });
+            this._attached = false;
+            this.state = 'detached';
+            this.presence._clear();
+            callback?.();
+            return Promise.resolve();
+        }
+
+        /**
+         * Subscribe to messages
+         * subscribe(callback) - all messages
+         * subscribe(event, callback) - specific event
+         */
+        subscribe(eventOrCallback, callback) {
+            // Auto-attach
+            if (!this._attached) this.attach();
+
+            if (typeof eventOrCallback === 'function') {
+                // Subscribe to all messages
+                this._messageListeners.push(eventOrCallback);
+                return () => {
+                    this._messageListeners = this._messageListeners.filter(cb => cb !== eventOrCallback);
+                };
             } else {
                 // Subscribe to specific event
-                if (!this._subscribers[event]) {
-                    this._subscribers[event] = [];
-                }
-                this._subscribers[event].push(callback);
+                const event = eventOrCallback;
+                if (!this._listeners[event]) this._listeners[event] = [];
+                this._listeners[event].push(callback);
+                return () => {
+                    this._listeners[event] = (this._listeners[event] || []).filter(cb => cb !== callback);
+                };
             }
+        }
 
-            // Send subscribe message to server
-            if (!this._subscribed) {
-                this._pulse._send({
-                    action: 'subscribe',
-                    channel: this.name
-                });
-                this._subscribed = true;
+        /**
+         * Unsubscribe from messages
+         */
+        unsubscribe(eventOrCallback, callback) {
+            if (typeof eventOrCallback === 'function') {
+                this._messageListeners = this._messageListeners.filter(cb => cb !== eventOrCallback);
+            } else if (eventOrCallback && callback) {
+                this._listeners[eventOrCallback] = (this._listeners[eventOrCallback] || []).filter(cb => cb !== callback);
+            } else if (eventOrCallback) {
+                delete this._listeners[eventOrCallback];
+            } else {
+                this._listeners = {};
+                this._messageListeners = [];
             }
-
-            // Return unsubscribe function
-            return () => {
-                if (typeof event === 'function') {
-                    this._allSubscribers = this._allSubscribers.filter(cb => cb !== callback);
-                } else {
-                    this._subscribers[event] = (this._subscribers[event] || []).filter(cb => cb !== callback);
-                }
-            };
         }
 
         /**
-         * Publish a message to the channel
+         * Publish message to channel
+         * publish(name, data, callback)
+         * publish({ name, data }, callback)
          */
-        publish(event, data) {
-            return this._pulse._send({
+        publish(nameOrMessage, dataOrCallback, callback) {
+            let name, data, cb;
+
+            if (typeof nameOrMessage === 'object') {
+                name = nameOrMessage.name;
+                data = nameOrMessage.data;
+                cb = dataOrCallback;
+            } else {
+                name = nameOrMessage;
+                data = dataOrCallback;
+                cb = callback;
+            }
+
+            this._realtime._send({
                 action: 'publish',
                 channel: this.name,
-                event: event,
-                data: data
+                name,
+                data
             });
+
+            cb?.();
+            return Promise.resolve();
         }
 
         /**
-         * Unsubscribe from channel
+         * Listen to internal events
          */
-        unsubscribe() {
-            this._subscribers = {};
-            this._allSubscribers = [];
-            this._subscribed = false;
-
-            this._pulse._send({
-                action: 'unsubscribe',
-                channel: this.name
-            });
+        on(event, callback) {
+            if (!this._listeners[event]) this._listeners[event] = [];
+            this._listeners[event].push(callback);
+            return () => this.off(event, callback);
         }
 
-        // Internal methods
+        off(event, callback) {
+            if (callback) {
+                this._listeners[event] = (this._listeners[event] || []).filter(cb => cb !== callback);
+            } else {
+                delete this._listeners[event];
+            }
+        }
+
+        // Internal
 
         _handleMessage(msg) {
-            const event = msg.event || msg.type;
-            // Use msg itself as data if no data field (server sends {type: 'new_post', post: {...}})
-            const data = msg.data !== undefined ? msg.data : msg;
+            const { action, name, data, clientId, connectionId, timestamp } = msg;
 
-            // Call specific event subscribers
-            if (event && this._subscribers[event]) {
-                this._subscribers[event].forEach(cb => cb(data, msg));
-            }
+            // Emit internal event
+            (this._listeners['_internal'] || []).forEach(cb => cb(msg));
 
-            // Call all-event subscribers
-            this._allSubscribers.forEach(cb => cb(data, msg));
+            if (action === 'message') {
+                // Message format (like Ably)
+                const message = { name, data, clientId, connectionId, timestamp };
 
-            // Handle presence events
-            if (msg.type === 'presence') {
+                // Call specific event listeners
+                if (name && this._listeners[name]) {
+                    this._listeners[name].forEach(cb => cb(message));
+                }
+
+                // Call all-message listeners
+                this._messageListeners.forEach(cb => cb(message));
+            }
+
+            // Presence events
+            if (['enter', 'leave', 'update', 'presence.sync'].includes(action)) {
                 this.presence._handleMessage(msg);
             }
         }
 
-        _resubscribe() {
-            if (this._subscribed) {
-                this._pulse._send({
-                    action: 'subscribe',
-                    channel: this.name
-                });
+        _reattach() {
+            if (this._attached) {
+                this._realtime._send({ action: 'attach', channel: this.name });
+                this.presence._reenter();
             }
         }
     }
 
-    /**
-     * Presence tracking for a channel
-     */
-    class PulsePresence {
+    // ========================================================================
+    // Presence (like Ably.Presence)
+    // ========================================================================
+
+    class Presence {
         constructor(channel) {
             this._channel = channel;
-            this._members = [];
-            this._count = 0;
-            this._subscribers = [];
-            this._enterSubscribers = [];
-            this._leaveSubscribers = [];
+            this._members = new Map();  // clientId -> member data
+            this._listeners = [];
+            this._enterListeners = [];
+            this._leaveListeners = [];
+            this._updateListeners = [];
             this._myData = null;
+            this._entered = false;
         }
 
         /**
-         * Subscribe to presence changes
+         * Get current presence members
          */
-        subscribe(callback) {
-            this._subscribers.push(callback);
-
-            // Return current members immediately if we have them
-            if (this._members.length > 0) {
-                callback(this._members);
-            }
-
-            // Request current presence from server
-            this._channel._pulse._send({
-                action: 'presence',
+        get(callback) {
+            // Request sync from server
+            this._channel._realtime._send({
+                action: 'presence.get',
                 channel: this._channel.name
             });
 
-            return () => {
-                this._subscribers = this._subscribers.filter(cb => cb !== callback);
-            };
+            // Return current members
+            const members = Array.from(this._members.values());
+            callback?.(null, members);
+            return Promise.resolve(members);
         }
 
         /**
-         * Subscribe to member enter events
+         * Subscribe to presence changes
+         * subscribe(callback) - all events
+         * subscribe(event, callback) - specific event (enter/leave/update)
          */
-        onEnter(callback) {
-            this._enterSubscribers.push(callback);
-            return () => {
-                this._enterSubscribers = this._enterSubscribers.filter(cb => cb !== callback);
-            };
+        subscribe(eventOrCallback, callback) {
+            // Auto-attach channel
+            if (!this._channel._attached) this._channel.attach();
+
+            if (typeof eventOrCallback === 'function') {
+                this._listeners.push(eventOrCallback);
+                return () => {
+                    this._listeners = this._listeners.filter(cb => cb !== eventOrCallback);
+                };
+            } else {
+                const event = eventOrCallback;
+                const list = event === 'enter' ? this._enterListeners :
+                             event === 'leave' ? this._leaveListeners :
+                             event === 'update' ? this._updateListeners : null;
+                if (list) {
+                    list.push(callback);
+                    return () => {
+                        const idx = list.indexOf(callback);
+                        if (idx >= 0) list.splice(idx, 1);
+                    };
+                }
+            }
         }
 
         /**
-         * Subscribe to member leave events
+         * Unsubscribe from presence
          */
-        onLeave(callback) {
-            this._leaveSubscribers.push(callback);
-            return () => {
-                this._leaveSubscribers = this._leaveSubscribers.filter(cb => cb !== callback);
-            };
+        unsubscribe(eventOrCallback, callback) {
+            if (typeof eventOrCallback === 'function') {
+                this._listeners = this._listeners.filter(cb => cb !== eventOrCallback);
+            } else if (eventOrCallback && callback) {
+                const list = eventOrCallback === 'enter' ? this._enterListeners :
+                             eventOrCallback === 'leave' ? this._leaveListeners :
+                             eventOrCallback === 'update' ? this._updateListeners : null;
+                if (list) {
+                    const idx = list.indexOf(callback);
+                    if (idx >= 0) list.splice(idx, 1);
+                }
+            }
         }
 
         /**
-         * Enter presence with optional data
+         * Enter presence
          */
-        enter(data = {}) {
-            this._myData = data;
-            this._channel._pulse._send({
-                action: 'presence_enter',
+        enter(data, callback) {
+            if (typeof data === 'function') {
+                callback = data;
+                data = {};
+            }
+
+            this._myData = data || {};
+            this._entered = true;
+
+            this._channel._realtime._send({
+                action: 'presence.enter',
                 channel: this._channel.name,
-                data: data
+                data: this._myData,
+                clientId: this._channel._realtime.clientId
             });
+
+            callback?.();
+            return Promise.resolve();
         }
 
         /**
          * Leave presence
          */
-        leave() {
+        leave(data, callback) {
+            if (typeof data === 'function') {
+                callback = data;
+                data = null;
+            }
+
             this._myData = null;
-            this._channel._pulse._send({
-                action: 'presence_leave',
+            this._entered = false;
+
+            this._channel._realtime._send({
+                action: 'presence.leave',
                 channel: this._channel.name
             });
+
+            callback?.();
+            return Promise.resolve();
         }
 
         /**
          * Update presence data
          */
-        update(data) {
-            this._myData = data;
-            this._channel._pulse._send({
-                action: 'presence_update',
+        update(data, callback) {
+            if (typeof data === 'function') {
+                callback = data;
+                data = {};
+            }
+
+            this._myData = data || {};
+
+            this._channel._realtime._send({
+                action: 'presence.update',
                 channel: this._channel.name,
-                data: data
+                data: this._myData
             });
-        }
 
-        /**
-         * Get current members
-         */
-        get members() {
-            return this._members;
-        }
-
-        /**
-         * Get member count (may be higher than members.length if list is limited)
-         */
-        get count() {
-            return this._count || this._members.length;
+            callback?.();
+            return Promise.resolve();
         }
 
-        // Internal methods
+        // Internal
 
         _handleMessage(msg) {
-            // Handle sync (full member list) - can come from action='sync' or just type='presence'
-            if (msg.action === 'sync' || (msg.type === 'presence' && msg.members)) {
-                this._members = msg.members || [];
-                this._count = msg.count !== undefined ? msg.count : this._members.length;
-                this._notifySubscribers();
-            } else if (msg.action === 'enter') {
-                this._members.push(msg.member);
-                this._count = (this._count || 0) + 1;
-                this._notifySubscribers();
-                this._enterSubscribers.forEach(cb => cb(msg.member));
-            } else if (msg.action === 'leave') {
-                this._members = this._members.filter(m => m.connectionId !== msg.member.connectionId);
-                this._count = Math.max(0, (this._count || 1) - 1);
-                this._notifySubscribers();
-                this._leaveSubscribers.forEach(cb => cb(msg.member));
+            const { action, clientId, connectionId, data, timestamp, members } = msg;
+
+            if (action === 'presence.sync' && members) {
+                // Full sync
+                this._members.clear();
+                members.forEach(m => {
+                    this._members.set(m.clientId || m.connectionId, m);
+                });
+                this._notifyListeners();
+                return;
+            }
+
+            const member = { clientId, connectionId, data, timestamp, action };
+
+            if (action === 'enter') {
+                this._members.set(clientId || connectionId, member);
+                this._enterListeners.forEach(cb => cb(member));
+            } else if (action === 'leave') {
+                this._members.delete(clientId || connectionId);
+                this._leaveListeners.forEach(cb => cb(member));
+            } else if (action === 'update') {
+                this._members.set(clientId || connectionId, member);
+                this._updateListeners.forEach(cb => cb(member));
             }
+
+            this._notifyListeners();
+        }
+
+        _notifyListeners() {
+            const members = Array.from(this._members.values());
+            this._listeners.forEach(cb => cb(members));
         }
 
-        _notifySubscribers() {
-            this._subscribers.forEach(cb => cb(this._members));
+        _clear() {
+            this._members.clear();
+            this._myData = null;
+            this._entered = false;
+        }
+
+        _reenter() {
+            if (this._entered && this._myData !== null) {
+                this._channel._realtime._send({
+                    action: 'presence.enter',
+                    channel: this._channel.name,
+                    data: this._myData,
+                    clientId: this._channel._realtime.clientId
+                });
+            }
         }
     }
 
-    // Export for different module systems
+    // ========================================================================
+    // Export
+    // ========================================================================
+
+    const Pulse = { Realtime };
+
+    // Also export Realtime directly for simpler usage
+    Pulse.Realtime.Realtime = Realtime;
+
     if (typeof module !== 'undefined' && module.exports) {
         module.exports = Pulse;
+        module.exports.Realtime = Realtime;
+        module.exports.default = Pulse;
     } else if (typeof define === 'function' && define.amd) {
         define([], function() { return Pulse; });
     } else {

package/server.js

@@ -1,22 +1,140 @@
 /**
- * OpenKBS Pulse - Server SDK
+ * OpenKBS Pulse - Server SDK (Ably-compatible API)
  *
  * Usage:
- *   import pulse from 'openkbs-pulse/server';
+ *   import Pulse from 'openkbs-pulse/server';
  *
- *   await pulse.publish('posts', 'new_post', { post });
- *   const { count, members } = await pulse.presence('posts');
+ *   const rest = new Pulse.Rest({ kbId: 'xxx', apiKey: 'yyy' });
+ *
+ *   // Publish to a channel
+ *   await rest.channels.get('chat').publish('greeting', { text: 'Hello!' });
+ *
+ *   // Get presence
+ *   const members = await rest.channels.get('chat').presence.get();
  */
 
 const PULSE_API = process.env.PULSE_API_URL || 'https://kb.openkbs.com';
 
+// ============================================================================
+// Rest Client (like Ably.Rest)
+// ============================================================================
+
+class Rest {
+    constructor(options = {}) {
+        this.kbId = options.kbId || process.env.OPENKBS_KB_ID;
+        this.apiKey = options.apiKey || process.env.OPENKBS_API_KEY;
+        this.apiUrl = options.apiUrl || PULSE_API;
+
+        if (!this.kbId || !this.apiKey) {
+            console.warn('[Pulse] kbId and apiKey required for server SDK');
+        }
+
+        // Channels manager
+        this.channels = new RestChannels(this);
+    }
+
+    async _request(action, params = {}) {
+        try {
+            const res = await fetch(this.apiUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action,
+                    kbId: this.kbId,
+                    apiKey: this.apiKey,
+                    ...params
+                })
+            });
+            return await res.json();
+        } catch (err) {
+            console.error('[Pulse] Request error:', err.message);
+            return { error: err.message };
+        }
+    }
+}
+
+// ============================================================================
+// RestChannels (like Ably.Rest.Channels)
+// ============================================================================
+
+class RestChannels {
+    constructor(rest) {
+        this._rest = rest;
+        this._channels = {};
+    }
+
+    get(name) {
+        if (!this._channels[name]) {
+            this._channels[name] = new RestChannel(this._rest, name);
+        }
+        return this._channels[name];
+    }
+}
+
+// ============================================================================
+// RestChannel (like Ably.Rest.Channel)
+// ============================================================================
+
+class RestChannel {
+    constructor(rest, name) {
+        this._rest = rest;
+        this.name = name;
+        this.presence = new RestPresence(this);
+    }
+
+    /**
+     * Publish message to channel
+     * publish(name, data) - publish with event name
+     * publish({ name, data }) - publish message object
+     */
+    async publish(nameOrMessage, data) {
+        let name, messageData;
+
+        if (typeof nameOrMessage === 'object') {
+            name = nameOrMessage.name;
+            messageData = nameOrMessage.data;
+        } else {
+            name = nameOrMessage;
+            messageData = data;
+        }
+
+        const result = await this._rest._request('pulsePublish', {
+            channel: this.name,
+            message: { type: name, ...messageData }
+        });
+
+        return result;
+    }
+}
+
+// ============================================================================
+// RestPresence (like Ably.Rest.Presence)
+// ============================================================================
+
+class RestPresence {
+    constructor(channel) {
+        this._channel = channel;
+    }
+
+    /**
+     * Get current presence members
+     */
+    async get() {
+        const result = await this._channel._rest._request('pulsePresence', {
+            channel: this._channel.name
+        });
+
+        return result.members || [];
+    }
+}
+
+// ============================================================================
+// Simple API (backwards compatible)
+// ============================================================================
+
 const pulse = {
     /**
-     * Get a Pulse token for WebSocket authentication
-     * @param {string} kbId - KB ID (optional, uses env var)
-     * @param {string} apiKey - API Key (optional, uses env var)
-     * @param {string} userId - User identifier (default: 'anonymous')
-     * @returns {Promise<{token, endpoint, region, expiresIn}>}
+     * Get a Pulse token for client authentication
      */
     async getToken(kbId, apiKey, userId = 'anonymous') {
         const kb = kbId || process.env.OPENKBS_KB_ID;
@@ -36,22 +154,22 @@ const pulse = {
                 userId
             })
         });
+
         return res.json();
     },
 
     /**
      * Publish a message to a channel
      * @param {string} channel - Channel name
-     * @param {string} event - Event type
+     * @param {string} name - Event name
      * @param {object} data - Event data
-     * @param {object} options - Optional { kbId, apiKey } overrides
      */
-    async publish(channel, event, data, options = {}) {
+    async publish(channel, name, data, options = {}) {
         const kbId = options.kbId || process.env.OPENKBS_KB_ID;
         const apiKey = options.apiKey || process.env.OPENKBS_API_KEY;
 
         if (!kbId || !apiKey) {
-            console.log('[Pulse] Not configured, skipping publish');
+            console.warn('[Pulse] Not configured, skipping publish');
             return { success: false, error: 'not_configured' };
         }
 
@@ -64,21 +182,19 @@ const pulse = {
                     kbId,
                     apiKey,
                     channel,
-                    message: { type: event, ...data }
+                    message: { type: name, ...data }
                 })
             });
             const result = await res.json();
             return { success: true, ...result };
-        } catch (e) {
-            console.error('[Pulse] Publish error:', e.message);
-            return { success: false, error: e.message };
+        } catch (err) {
+            console.error('[Pulse] Publish error:', err.message);
+            return { success: false, error: err.message };
         }
     },
 
     /**
-     * Get presence info for a channel
-     * @param {string} channel - Channel name
-     * @param {object} options - Optional { kbId, apiKey } overrides
+     * Get presence for a channel
      */
     async presence(channel, options = {}) {
         const kbId = options.kbId || process.env.OPENKBS_KB_ID;
@@ -100,11 +216,18 @@ const pulse = {
                 })
             });
             return await res.json();
-        } catch (e) {
-            console.error('[Pulse] Presence error:', e.message);
+        } catch (err) {
+            console.error('[Pulse] Presence error:', err.message);
             return { count: 0, members: [] };
         }
     }
 };
 
-export default pulse;
+// ============================================================================
+// Exports
+// ============================================================================
+
+const Pulse = { Rest };
+
+export default pulse;  // Default export: simple API
+export { Rest, pulse, Pulse };  // Named exports