@prsm/realtime 1.0.0

package/src/client/subscriptions/channels.js

@@ -0,0 +1,79 @@
+import { clientLogger } from "../../shared/index.js"
+
+export function createChannelSubscriptions(client) {
+  const subscriptions = client.channelSubscriptions
+
+  async function handleMessage(payload) {
+    const { channel, message } = payload
+    const subscription = subscriptions.get(channel)
+    if (subscription) {
+      try {
+        await subscription.callback(message)
+      } catch (error) {
+        clientLogger.error(`Error in channel callback for ${channel}:`, error)
+      }
+    }
+  }
+
+  /**
+   * @param {string} channel
+   * @param {(message: any) => void} callback
+   * @param {{historyLimit?: number, since?: string}} [options]
+   * @returns {Promise<{success: boolean, history: any[]}>}
+   */
+  async function subscribe(channel, callback, options) {
+    subscriptions.set(channel, { callback, historyLimit: options?.historyLimit })
+    const result = await client.command("mesh/subscribe-channel", {
+      channel,
+      historyLimit: options?.historyLimit,
+      since: options?.since,
+    })
+    if (result.success && result.history && result.history.length > 0) {
+      result.history.forEach((message) => callback(message))
+    }
+    return { success: result.success, history: result.history || [] }
+  }
+
+  /**
+   * @param {string} channel
+   * @returns {Promise<any>}
+   */
+  function unsubscribe(channel) {
+    subscriptions.delete(channel)
+    return client.command("mesh/unsubscribe-channel", { channel })
+  }
+
+  /**
+   * @param {string} channel
+   * @param {{limit?: number, since?: string}} [options]
+   * @returns {Promise<{success: boolean, history: any[]}>}
+   */
+  async function getHistory(channel, options) {
+    try {
+      const result = await client.command("mesh/get-channel-history", {
+        channel,
+        limit: options?.limit,
+        since: options?.since,
+      })
+      return { success: result.success, history: result.history || [] }
+    } catch (error) {
+      clientLogger.error(`Failed to get history for channel ${channel}:`, error)
+      return { success: false, history: [] }
+    }
+  }
+
+  async function resubscribe() {
+    const promises = Array.from(subscriptions.entries()).map(async ([channel, { callback, historyLimit }]) => {
+      try {
+        await subscribe(channel, callback, { historyLimit })
+        return true
+      } catch (error) {
+        clientLogger.error(`Failed to resubscribe to channel ${channel}:`, error)
+        return false
+      }
+    })
+    return Promise.allSettled(promises)
+  }
+
+  return { handleMessage, subscribe, unsubscribe, getHistory, resubscribe }
+}

package/src/client/subscriptions/collections.js

@@ -0,0 +1,96 @@
+import { clientLogger } from "../../shared/index.js"
+
+export function createCollectionSubscriptions(client) {
+  const subscriptions = client.collectionSubscriptions
+
+  async function handleDiff(payload) {
+    const { collectionId, added, removed, version } = payload
+    const subscription = subscriptions.get(collectionId)
+    if (!subscription) return
+
+    if (version !== subscription.version + 1) {
+      clientLogger.warn(
+        `Desync detected for collection ${collectionId}. Expected version ${subscription.version + 1}, got ${version}. Resubscribing.`
+      )
+      await unsubscribe(collectionId)
+      await subscribe(collectionId, { onDiff: subscription.onDiff })
+      return
+    }
+
+    subscription.version = version
+    for (const record of added) subscription.ids.add(record.id)
+    for (const record of removed) subscription.ids.delete(record.id)
+
+    if (subscription.onDiff) {
+      try {
+        await subscription.onDiff({
+          added: added.map((record) => ({ id: record.id, record })),
+          removed: removed.map((record) => ({ id: record.id, record })),
+          changed: [],
+          version,
+        })
+      } catch (error) {
+        clientLogger.error(`Error in collection diff callback for ${collectionId}:`, error)
+      }
+    }
+  }
+
+  /**
+   * @param {string} collectionId
+   * @param {{onDiff?: (diff: {added: Array<{id: string, record: any}>, removed: Array<{id: string, record: any}>, changed: Array<{id: string, record: any}>, version: number}) => void}} [options]
+   * @returns {Promise<{success: boolean, ids: string[], records: any[], version: number}>}
+   */
+  async function subscribe(collectionId, options = {}) {
+    try {
+      const result = await client.command("mesh/subscribe-collection", { collectionId })
+      if (result.success) {
+        subscriptions.set(collectionId, {
+          ids: new Set(result.ids),
+          version: result.version,
+          onDiff: options.onDiff,
+        })
+        if (options.onDiff) {
+          try {
+            await options.onDiff({ added: result.records, removed: [], changed: [], version: result.version })
+          } catch (error) {
+            clientLogger.error(`Error in initial collection diff callback for ${collectionId}:`, error)
+          }
+        }
+      }
+      return { success: result.success, ids: result.ids || [], records: result.records || [], version: result.version || 0 }
+    } catch (error) {
+      clientLogger.error(`Failed to subscribe to collection ${collectionId}:`, error)
+      return { success: false, ids: [], records: [], version: 0 }
+    }
+  }
+
+  /**
+   * @param {string} collectionId
+   * @returns {Promise<boolean>}
+   */
+  async function unsubscribe(collectionId) {
+    try {
+      const success = await client.command("mesh/unsubscribe-collection", { collectionId })
+      if (success) subscriptions.delete(collectionId)
+      return success
+    } catch (error) {
+      clientLogger.error(`Failed to unsubscribe from collection ${collectionId}:`, error)
+      return false
+    }
+  }
+
+  async function resubscribe() {
+    const promises = Array.from(subscriptions.entries()).map(async ([collectionId, subscription]) => {
+      try {
+        await subscribe(collectionId, { onDiff: subscription.onDiff })
+        return true
+      } catch (error) {
+        clientLogger.error(`Failed to resubscribe to collection ${collectionId}:`, error)
+        return false
+      }
+    })
+    return Promise.allSettled(promises)
+  }
+
+  return { handleDiff, subscribe, unsubscribe, resubscribe }
+}

package/src/client/subscriptions/presence.js

@@ -0,0 +1,98 @@
+import { clientLogger } from "../../shared/index.js"
+
+export function createPresenceSubscriptions(client) {
+  const subscriptions = client.presenceSubscriptions
+
+  async function handleUpdate(payload) {
+    const { roomName } = payload
+    const callback = subscriptions.get(roomName)
+    if (callback) await callback(payload)
+  }
+
+  /**
+   * @param {string} roomName
+   * @param {(update: {roomName: string, present: string[], states: Object<string, any>, joined?: string, left?: string}) => void} callback
+   * @returns {Promise<{success: boolean, present: string[], states?: Object<string, any>}>}
+   */
+  async function subscribe(roomName, callback) {
+    try {
+      const result = await client.command("mesh/subscribe-presence", { roomName })
+      if (result.success) {
+        subscriptions.set(roomName, callback)
+        if (result.present && result.present.length > 0) await callback(result)
+      }
+      return { success: result.success, present: result.present || [], states: result.states || {} }
+    } catch (error) {
+      clientLogger.error(`Failed to subscribe to presence for room ${roomName}:`, error)
+      return { success: false, present: [] }
+    }
+  }
+
+  /**
+   * @param {string} roomName
+   * @returns {Promise<boolean>}
+   */
+  async function unsubscribe(roomName) {
+    try {
+      const success = await client.command("mesh/unsubscribe-presence", { roomName })
+      if (success) subscriptions.delete(roomName)
+      return success
+    } catch (error) {
+      clientLogger.error(`Failed to unsubscribe from presence for room ${roomName}:`, error)
+      return false
+    }
+  }
+
+  /**
+   * @param {string} roomName
+   * @param {{state: any, expireAfter?: number, silent?: boolean}} options
+   * @returns {Promise<any>}
+   */
+  async function publishState(roomName, options) {
+    try {
+      return await client.command("mesh/publish-presence-state", {
+        roomName,
+        state: options.state,
+        expireAfter: options.expireAfter,
+        silent: options.silent,
+      })
+    } catch (error) {
+      clientLogger.error(`Failed to publish presence state for room ${roomName}:`, error)
+      return false
+    }
+  }
+
+  /**
+   * @param {string} roomName
+   * @returns {Promise<any>}
+   */
+  async function clearState(roomName) {
+    try {
+      return await client.command("mesh/clear-presence-state", { roomName })
+    } catch (error) {
+      clientLogger.error(`Failed to clear presence state for room ${roomName}:`, error)
+      return false
+    }
+  }
+
+  async function forceUpdate(roomName) {
+    try {
+      const handler = subscriptions.get(roomName)
+      if (!handler) return false
+      const result = await client.command("mesh/get-presence-state", { roomName }, 5000).catch((err) => {
+        clientLogger.error(`Failed to get presence state for room ${roomName}:`, err)
+        return { success: false }
+      })
+      if (!result.success) return false
+      if (handler.init && typeof handler.init === "function") {
+        handler.init(result.present, result.states || {})
+      }
+      return true
+    } catch (error) {
+      clientLogger.error(`Failed to force presence update for room ${roomName}:`, error)
+      return false
+    }
+  }
+
+  return { handleUpdate, subscribe, unsubscribe, publishState, clearState, forceUpdate }
+}

package/src/client/subscriptions/records.js

@@ -0,0 +1,123 @@
+import { clientLogger } from "../../shared/index.js"
+
+export function createRecordSubscriptions(client) {
+  const subscriptions = client.recordSubscriptions
+
+  async function handleUpdate(payload) {
+    const { recordId, full, patch, version } = payload
+
+    for (const [collectionId, collectionSub] of client.collectionSubscriptions.entries()) {
+      if (collectionSub.ids.has(recordId) && collectionSub.onDiff) {
+        try {
+          await collectionSub.onDiff({
+            added: [],
+            removed: [],
+            changed: [{ id: recordId, record: full }],
+            version,
+          })
+        } catch (error) {
+          clientLogger.error(`Error in collection record update callback for ${collectionId}:`, error)
+        }
+      }
+    }
+
+    const subscription = subscriptions.get(recordId)
+    if (!subscription) return
+
+    if (patch) {
+      if (version !== subscription.localVersion + 1) {
+        clientLogger.warn(
+          `Desync detected for record ${recordId}. Expected version ${subscription.localVersion + 1}, got ${version}. Resubscribing to request full record.`
+        )
+        await unsubscribe(recordId)
+        await subscribe(recordId, subscription.callback, { mode: subscription.mode })
+        return
+      }
+      subscription.localVersion = version
+      if (subscription.callback) await subscription.callback({ recordId, patch, version })
+    } else if (full !== undefined) {
+      subscription.localVersion = version
+      if (subscription.callback) await subscription.callback({ recordId, full, version })
+    }
+  }
+
+  async function handleDeleted(payload) {
+    const { recordId, version } = payload
+    const subscription = subscriptions.get(recordId)
+    if (subscription && subscription.callback) {
+      try {
+        await subscription.callback({ recordId, deleted: true, version })
+      } catch (error) {
+        clientLogger.error(`Error in record deletion callback for ${recordId}:`, error)
+      }
+    }
+    subscriptions.delete(recordId)
+  }
+
+  /**
+   * @param {string} recordId
+   * @param {(update: {recordId: string, full?: any, patch?: import('fast-json-patch').Operation[], version: number, deleted?: boolean}) => void} callback
+   * @param {{mode?: 'full' | 'patch'}} [options]
+   * @returns {Promise<{success: boolean, record: any, version: number}>}
+   */
+  async function subscribe(recordId, callback, options) {
+    const mode = options?.mode ?? "full"
+    try {
+      const result = await client.command("mesh/subscribe-record", { recordId, mode })
+      if (result.success) {
+        subscriptions.set(recordId, { callback, localVersion: result.version, mode })
+        if (callback) await callback({ recordId, full: result.record, version: result.version })
+      }
+      return { success: result.success, record: result.record ?? null, version: result.version ?? 0 }
+    } catch (error) {
+      clientLogger.error(`Failed to subscribe to record ${recordId}:`, error)
+      return { success: false, record: null, version: 0 }
+    }
+  }
+
+  /**
+   * @param {string} recordId
+   * @returns {Promise<boolean>}
+   */
+  async function unsubscribe(recordId) {
+    try {
+      const success = await client.command("mesh/unsubscribe-record", { recordId })
+      if (success) subscriptions.delete(recordId)
+      return success
+    } catch (error) {
+      clientLogger.error(`Failed to unsubscribe from record ${recordId}:`, error)
+      return false
+    }
+  }
+
+  /**
+   * @param {string} recordId
+   * @param {any} newValue
+   * @param {Object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async function write(recordId, newValue, options) {
+    try {
+      const result = await client.command("mesh/publish-record-update", { recordId, newValue, options })
+      return result.success === true
+    } catch (error) {
+      clientLogger.error(`Failed to publish update for record ${recordId}:`, error)
+      return false
+    }
+  }
+
+  async function resubscribe() {
+    const promises = Array.from(subscriptions.entries()).map(async ([recordId, { callback, mode }]) => {
+      try {
+        await subscribe(recordId, callback, { mode })
+        return true
+      } catch (error) {
+        clientLogger.error(`Failed to resubscribe to record ${recordId}:`, error)
+        return false
+      }
+    })
+    return Promise.allSettled(promises)
+  }
+
+  return { handleUpdate, handleDeleted, subscribe, unsubscribe, write, resubscribe }
+}

package/src/client/subscriptions/rooms.js

@@ -0,0 +1,69 @@
+import { clientLogger } from "../../shared/index.js"
+
+export function createRoomSubscriptions(client, presence) {
+  const joinedRooms = client.joinedRooms
+
+  /**
+   * @param {string} roomName
+   * @param {(update: {roomName: string, present: string[], states: Object<string, any>, joined?: string, left?: string}) => void} [onPresenceUpdate]
+   * @returns {Promise<{success: boolean, present: string[]}>}
+   */
+  async function join(roomName, onPresenceUpdate) {
+    const joinResult = await client.command("mesh/join-room", { roomName })
+    if (!joinResult.success) return { success: false, present: [] }
+
+    joinedRooms.set(roomName, onPresenceUpdate)
+
+    if (!onPresenceUpdate) return { success: true, present: joinResult.present || [] }
+
+    const { success: subSuccess } = await presence.subscribe(roomName, onPresenceUpdate)
+    return { success: subSuccess, present: joinResult.present || [] }
+  }
+
+  /**
+   * @param {string} roomName
+   * @returns {Promise<{success: boolean}>}
+   */
+  async function leave(roomName) {
+    const result = await client.command("mesh/leave-room", { roomName })
+    if (result.success) {
+      joinedRooms.delete(roomName)
+      if (client.presenceSubscriptions.has(roomName)) {
+        await presence.unsubscribe(roomName)
+      }
+    }
+    return { success: result.success }
+  }
+
+  /**
+   * @param {string} roomName
+   * @returns {Promise<any>}
+   */
+  async function getMetadata(roomName) {
+    try {
+      const result = await client.command("mesh/get-room-metadata", { roomName })
+      return result.metadata
+    } catch (error) {
+      clientLogger.error(`Failed to get metadata for room ${roomName}:`, error)
+      return null
+    }
+  }
+
+  async function resubscribe(presenceModule) {
+    const promises = Array.from(joinedRooms.entries()).map(async ([roomName, presenceCallback]) => {
+      try {
+        await join(roomName, presenceCallback)
+        return { roomName, success: true }
+      } catch (error) {
+        clientLogger.error(`Failed to rejoin room ${roomName}:`, error)
+        return { roomName, success: false }
+      }
+    })
+    const results = await Promise.allSettled(promises)
+    return results
+      .filter((r) => r.status === "fulfilled" && r.value.success)
+      .map((r) => r.value.roomName)
+  }
+
+  return { join, leave, getMetadata, resubscribe }
+}

package/src/devtools/client/dist/assets/index-CGm1NqOQ.css

@@ -0,0 +1 @@
+:root{--bg: #0a0a0a;--bg-surface: #111111;--bg-raised: #1a1a1a;--bg-hover: #222222;--bg-active: #2a2a2a;--border: #2a2a2a;--border-subtle: #1e1e1e;--text: #d4d4d4;--text-bright: #e8e8e8;--text-muted: #555555;--accent: #34d399;--accent-dim: rgba(52, 211, 153, .12);--accent-text: #2dd4a2;--syn-string: #a5d6a7;--syn-number: #4dd0e1;--syn-boolean: #ce93d8;--syn-null: #666666;--syn-key: #b0b0b0;--syn-bracket: #555555}*{box-sizing:border-box;margin:0;padding:0}body{font-family:SF Mono,Fira Code,JetBrains Mono,Cascadia Code,monospace;font-size:12px;line-height:1.5;color:var(--text);background:var(--bg);-webkit-font-smoothing:antialiased}::selection{background:var(--accent-dim);color:var(--accent-text)}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background:var(--border);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:#3a3a3a}.app{display:flex;flex-direction:column;height:100vh;overflow:hidden}.top-bar{display:flex;align-items:center;justify-content:space-between;padding:0 16px;height:40px;border-bottom:1px solid var(--border);background:var(--bg-surface);flex-shrink:0}.top-bar-left{display:flex;align-items:center;gap:12px}.logo{font-size:11px;font-weight:600;letter-spacing:.5px;text-transform:uppercase;color:var(--text-muted)}.logo span{color:var(--accent)}.top-bar-right{display:flex;align-items:center;gap:12px}.pulse{width:6px;height:6px;border-radius:50%;background:var(--accent)}.pulse.disconnected{background:#ef4444}.instance-id{font-size:10px;color:var(--text-muted)}.tab-bar{display:flex;align-items:center;gap:0;border-bottom:1px solid var(--border);background:var(--bg-surface);flex-shrink:0;padding:0 16px}.tab{padding:8px 16px;font-size:11px;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;-webkit-user-select:none;user-select:none}.tab:hover{color:var(--text)}.tab.active{color:var(--accent-text);border-bottom-color:var(--accent)}.tab .count{margin-left:6px;font-size:10px;color:var(--text-muted)}.tab.active .count{color:var(--accent)}.main{display:flex;flex:1;overflow:hidden}.sidebar{width:280px;min-width:280px;border-right:1px solid var(--border);overflow-y:auto;background:var(--bg-surface)}.content{flex:1;overflow-y:auto;padding:16px}.sidebar-section{border-bottom:1px solid var(--border-subtle)}.sidebar-header{padding:8px 12px;font-size:10px;text-transform:uppercase;letter-spacing:.5px;color:var(--text-muted);background:var(--bg)}.sidebar-item{display:flex;align-items:center;justify-content:space-between;padding:6px 12px;cursor:pointer;border-left:2px solid transparent}.sidebar-item:hover{background:var(--bg-hover)}.sidebar-item.active{background:var(--accent-dim);border-left-color:var(--accent)}.sidebar-item .label{font-size:11px;color:var(--text);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sidebar-item.active .label{color:var(--accent-text)}.sidebar-item .meta{font-size:10px;color:var(--text-muted);flex-shrink:0;margin-left:8px}.badge{display:inline-flex;align-items:center;justify-content:center;min-width:18px;height:18px;padding:0 5px;font-size:10px;border-radius:9px;background:#1f1f1f;color:#999}.badge.accent{background:var(--accent-dim);color:var(--accent)}.section{margin-bottom:20px}.section-title{font-size:10px;text-transform:uppercase;letter-spacing:.5px;color:var(--text-muted);margin-bottom:8px}.card{background:var(--bg-surface);border:1px solid var(--border);border-radius:4px;overflow:hidden}.card+.card{margin-top:8px}.card-header{display:flex;align-items:center;justify-content:space-between;padding:8px 12px;background:var(--bg);border-bottom:1px solid var(--border-subtle);font-size:11px}.card-header .name{color:var(--text-bright)}.card-body{padding:8px 12px}.kv-row{display:flex;align-items:baseline;padding:2px 0;font-size:11px}.kv-key{color:var(--text-muted);min-width:100px;flex-shrink:0}.kv-value{color:var(--text);word-break:break-all}.member-row{display:flex;align-items:center;justify-content:space-between;padding:4px 12px;font-size:11px;border-bottom:1px solid var(--border-subtle)}.member-row:last-child{border-bottom:none}.member-id{color:var(--text);font-size:11px}.member-presence{font-size:10px;color:var(--accent)}.tag{display:inline-block;padding:1px 6px;font-size:10px;border-radius:3px;background:#1f1f1f;color:#999;margin:1px 2px}.tag.accent{background:var(--accent-dim);color:var(--accent)}.empty{padding:24px;text-align:center;color:var(--text-muted);font-size:11px}.view-hint{font-size:11px;color:var(--text-muted);margin-bottom:12px;padding-bottom:8px;border-bottom:1px solid var(--border-subtle)}.no-presence{font-size:10px;color:#333}.pattern-list{display:flex;flex-wrap:wrap;gap:4px;margin-top:4px}.json-view{font-size:11px;line-height:1.6;white-space:pre-wrap;word-break:break-all}.json-view .shiki{background:transparent!important;padding:0;margin:0}.json-view .shiki code{font-family:inherit;font-size:inherit}.select{background:var(--bg-raised);border:1px solid var(--border);color:var(--text);font-family:inherit;font-size:11px;padding:4px 8px;border-radius:3px;outline:none;cursor:pointer}.select:focus{border-color:var(--accent)}.conn-link{cursor:pointer;text-decoration:underline;text-decoration-color:var(--border);text-underline-offset:2px}.conn-link:hover{color:var(--accent-text);text-decoration-color:var(--accent)}.exposed-row{display:flex;align-items:center;flex-wrap:wrap;gap:3px;padding:4px 12px;border-bottom:1px solid var(--border-subtle)}.exposed-row:last-child{border-bottom:none}.exposed-label{font-size:10px;color:var(--text-muted);min-width:70px;flex-shrink:0}.inline-json .s{color:var(--syn-string)}.inline-json .n{color:var(--syn-number)}.inline-json .b{color:var(--syn-boolean)}.inline-json .null{color:var(--syn-null)}.inline-json .k{color:var(--syn-key)}.inline-json .p{color:var(--syn-bracket)}