@symbo.ls/sdk 2.32.6 → 2.32.8

package/dist/node/utils/CollabClient.js

@@ -15,8 +15,8 @@ class CollabClient {
   _buffer = [];
   _flushTimer = null;
   _clientId = nanoid();
-  _outboxStore = null;
-  // Dexie table
+  _outboxStore = createMemoryOutbox();
+  // Dexie table fallback
   _readyResolve;
   ready = new Promise((res) => this._readyResolve = res);
   constructor({ jwt, projectId, branch = "main", live = false }) {
@@ -32,14 +32,11 @@ class CollabClient {
         console.warn("[CollabClient] Failed to load IndexeddbPersistence:", err);
       });
     }
-    if (typeof window === "undefined" || !hasIndexedDB) {
-      this._outboxStore = createMemoryOutbox();
-    } else {
+    if (typeof window !== "undefined" && hasIndexedDB) {
       createDexieOutbox(`${projectId}:${branch}`).then((outboxStore) => {
         this._outboxStore = outboxStore;
       }).catch((err) => {
         console.warn("[CollabClient] Failed to load Dexie:", err);
-        this._outboxStore = createMemoryOutbox();
       });
     }
     this.socket = io(environment.socketUrl, {
@@ -49,9 +46,7 @@ class CollabClient {
       reconnectionAttempts: Infinity,
       reconnectionDelayMax: 4e3
     });
-    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", (flag) => {
-      this.live = flag;
-    }).on("connect", this._onConnect).on("error", (e) => console.warn("[collab] socket error", e));
+    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", this._onLiveMode).on("connect", this._onConnect).on("error", this._onError);
     this._prevJson = this.ydoc.getMap("root").toJSON();
     this.ydoc.on("afterTransaction", (tr) => {
       if (tr.origin === "remote") {
@@ -137,6 +132,48 @@ class CollabClient {
     });
     this._buffer.length = 0;
   }
+  dispose() {
+    var _a;
+    clearTimeout(this._flushTimer);
+    this._flushTimer = null;
+    this._buffer.length = 0;
+    if ((_a = this._outboxStore) == null ? void 0 : _a.clear) {
+      try {
+        const result = this._outboxStore.clear();
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch (error) {
+        console.warn("[CollabClient] Failed to clear outbox store during dispose:", error);
+      }
+    }
+    if (this.socket) {
+      this.socket.off("snapshot", this._onSnapshot);
+      this.socket.off("ops", this._onOps);
+      this.socket.off("commit", this._onCommit);
+      this.socket.off("liveMode", this._onLiveMode);
+      this.socket.off("connect", this._onConnect);
+      this.socket.off("error", this._onError);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    if (this.ydoc) {
+      this.ydoc.destroy();
+      this.ydoc = null;
+    }
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  }
+  _onLiveMode = (flag) => {
+    this.live = flag;
+  };
+  _onError = (e) => {
+    console.warn("[collab] socket error", e);
+  };
 }
 function createMemoryOutbox() {
   const store = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.32.6",
+  "version": "2.32.8",
   "type": "module",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",
@@ -46,10 +46,10 @@
     "test:user": "cross-env NODE_ENV=$NODE_ENV npx tape integration-tests/index.js integration-tests/user/*.test.js | tap-spec"
   },
   "dependencies": {
-    "@domql/element": "^2.32.6",
-    "@domql/utils": "^2.32.6",
-    "@symbo.ls/router": "^2.32.6",
-    "@symbo.ls/socket": "^2.32.6",
+    "@domql/element": "^2.32.8",
+    "@domql/utils": "^2.32.8",
+    "@symbo.ls/router": "^2.32.8",
+    "@symbo.ls/socket": "^2.32.8",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -71,5 +71,5 @@
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "8bffb49783c4aa5bd7d18933ccee296b92810f7e"
+  "gitHead": "f7531cb41b391a1357d31a03fbdd33ad93e0a29d"
 }

package/src/config/environment.js

@@ -24,6 +24,9 @@ const CONFIG = {
     basedProject: 'platform-v2-sm', // For based api
     basedOrg: 'symbols', // For based api
     githubClientId: 'Ov23liAFrsR0StbAO6PO', // For github api
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/aef64330db80bdfeaac084317bf72f99', // For grafana tracing
+    grafanaAppName: 'Localhost Symbols',
     // Environment-specific feature toggles (override common)
     features: {
       betaFeatures: true // Enable beta features in local dev
@@ -38,6 +41,9 @@ const CONFIG = {
     socketUrl: 'https://dev.api.symbols.app',
     apiUrl: 'https://dev.api.symbols.app',
     githubClientId: 'Ov23liHxyWFBxS8f1gnF',
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8', // For grafana tracing
+    grafanaAppName: 'Symbols Dev',
     typesenseCollectionName: 'docs',
     typesenseApiKey: 'awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA',
     typesenseHost: 'tl2qpnwxev4cjm36p-1.a1.typesense.net',
@@ -51,6 +57,9 @@ const CONFIG = {
     basedProject: 'platform-v2-sm',
     basedOrg: 'symbols',
     githubClientId: 'Ov23liHxyWFBxS8f1gnF',
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8', // For grafana tracing
+    grafanaAppName: 'Symbols Test',
     typesenseCollectionName: 'docs',
     typesenseApiKey: 'awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA',
     typesenseHost: 'tl2qpnwxev4cjm36p-1.a1.typesense.net',
@@ -61,6 +70,9 @@ const CONFIG = {
     socketUrl: 'https://upcoming.api.symbols.app',
     apiUrl: 'https://upcoming.api.symbols.app',
     githubClientId: 'Ov23liWF7NvdZ056RV5J',
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8', // For grafana tracing
+    grafanaAppName: 'Symbols Upcoming',
     typesenseCollectionName: 'docs',
     typesenseApiKey: 'awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA',
     typesenseHost: 'tl2qpnwxev4cjm36p-1.a1.typesense.net',
@@ -74,6 +86,9 @@ const CONFIG = {
     basedProject: 'platform-v2-sm',
     basedOrg: 'symbols',
     githubClientId: 'Ov23ligwZDQVD0VfuWNa',
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8', // For grafana tracing
+    grafanaAppName: 'Symbols Staging',
     typesenseCollectionName: 'docs',
     typesenseApiKey: 'awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA',
     typesenseHost: 'tl2qpnwxev4cjm36p-1.a1.typesense.net',
@@ -87,6 +102,9 @@ const CONFIG = {
     basedProject: 'platform-v2-sm',
     basedOrg: 'symbols',
     githubClientId: 'Ov23liFAlOEIXtX3dBtR',
+    grafanaUrl:
+      'https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae', // For grafana tracing
+    grafanaAppName: 'Symbols',
     typesenseCollectionName: 'docs',
     typesenseApiKey: 'awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA',
     typesenseHost: 'tl2qpnwxev4cjm36p-1.a1.typesense.net',
@@ -125,6 +143,7 @@ export const getConfig = () => {
       basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
       githubClientId:
         process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
+      grafanaUrl: process.env.SYMBOLS_APP_GRAFANA_URL || envConfig.grafanaUrl,
       typesenseCollectionName:
         process.env.TYPESENSE_COLLECTION_NAME ||
         envConfig.typesenseCollectionName,
@@ -149,7 +168,7 @@ export const getConfig = () => {
       'googleClientId'
     ]
 
-    const missingFields = requiredFields.filter((field) => !finalConfig[field])
+    const missingFields = requiredFields.filter(field => !finalConfig[field])
 
     if (missingFields.length > 0) {
       console.error(

package/src/services/AuthService.js

@@ -349,10 +349,15 @@ export class AuthService extends BaseService {
     }
   }
 
-  async getMe() {
+  async getMe(options = {}) {
     this._requireReady('getMe')
     try {
-      const response = await this._request('/auth/me', {
+      const session = this._resolvePluginSession(options.session)
+      const endpoint = session
+        ? `/auth/me?session=${encodeURIComponent(session)}`
+        : '/auth/me'
+
+      const response = await this._request(endpoint, {
         method: 'GET',
         methodName: 'getMe'
       })

package/src/services/CollabService.js

@@ -12,15 +12,24 @@ export class CollabService extends BaseService {
     this._client = null
     this._stateManager = null
     this._connected = false
+    this._connecting = false
+    this._connectPromise = null
+    this._connectionMeta = null
+    this._pendingConnectReject = null
     this._undoStack = []
     this._redoStack = []
     this._isUndoRedo = false
     // Store operations made while offline so they can be flushed once the
     // socket reconnects.
     this._pendingOps = []
+
+    this._onSocketConnect = this._onSocketConnect.bind(this)
+    this._onSocketDisconnect = this._onSocketDisconnect.bind(this)
+    this._onSocketError = this._onSocketError.bind(this)
   }
 
   init({ context }) {
+    super.init({ context })
     // console.log('CollabService init')
     // console.log(context)
 
@@ -105,109 +114,243 @@ export class CollabService extends BaseService {
 
   /* ---------- Connection Management ---------- */
   async connect(options = {}) {
-    // Make sure we have the state manager ready now that the context should
-    // contain the root state (after updateSDKContext()).
-    this._ensureStateManager()
-
-    const {
-      authToken: jwt,
-      projectId,
-      branch = 'main',
-      pro
-    } = {
-      ...this._context,
-      ...options
+    if (this._connectPromise) {
+      return this._connectPromise
     }
-    // console.log(jwt, projectId, branch, pro)
 
-    if (!projectId) {
-      const state = this._stateManager?.root
-      const el = state.__element
-      el.call('openNotification', {
-        type: 'error',
-        title: 'projectId is required',
-        message: 'projectId is required for CollabService connection'
-      })
-      throw new Error('projectId is required for CollabService connection')
-    }
+    this._connectPromise = (async () => {
+      this._connecting = true
+      this._connected = false
 
-    // Disconnect existing connection if any
-    if (this._client) {
-      await this.disconnect()
-    }
+      // Make sure we have the state manager ready now that the context should
+      // contain the root state (after updateSDKContext()).
+      this._ensureStateManager()
 
-    this._client = new CollabClient({
-      jwt,
-      projectId,
-      branch,
-      live: Boolean(pro)
-    })
+      const mergedOptions = {
+        ...this._context,
+        ...options
+      }
 
-    // Mark as connected once the socket establishes a connection. This prevents
-    // the SDK from being stuck waiting for an initial snapshot that may never
-    // arrive (e.g. for new/empty documents).
-    await new Promise((resolve) => {
-      if (this._client.socket?.connected) {
-        resolve()
-      } else {
-        this._client.socket?.once('connect', resolve)
+      let { authToken: jwt } = mergedOptions
+      const {
+        projectId,
+        branch = 'main',
+        pro
+      } = mergedOptions
+
+      if (!jwt && this._tokenManager) {
+        try {
+          jwt = await this._tokenManager.ensureValidToken()
+        } catch (error) {
+          console.warn('[CollabService] Failed to obtain auth token from token manager', error)
+        }
+
+        if (!jwt && typeof this._tokenManager.getAccessToken === 'function') {
+          jwt = this._tokenManager.getAccessToken()
+        }
       }
-    })
 
-    // Set up event listeners
-    this._client.socket?.on('ops', ({ changes }) => {
-      console.log(`ops event`)
-      this._stateManager.applyChanges(changes, { fromSocket: true })
-    })
+      if (!jwt) {
+        throw new Error('[CollabService] Cannot connect without auth token')
+      }
 
-    this._client.socket?.on('commit', ({ version }) => {
-      if (version) {
-        this._stateManager.setVersion(version)
+      this._context = {
+        ...this._context,
+        authToken: jwt,
+        projectId,
+        branch,
+        pro
       }
 
-      // Inform UI about automatic commit
-      rootBus.emit('checkpoint:done', { version, origin: 'auto' })
-    })
+      if (!projectId) {
+        const state = this._stateManager?.root
+        const el = state.__element
+        el.call('openNotification', {
+          type: 'error',
+          title: 'projectId is required',
+          message: 'projectId is required for CollabService connection'
+        })
+        throw new Error('projectId is required for CollabService connection')
+      }
+
+      // Disconnect existing connection if any
+      if (this._client) {
+        await this.disconnect()
+      }
 
-    // 🔄  Presence / members / cursor updates
-    this._client.socket?.on('clients', this._handleClientsEvent.bind(this))
+      this._client = new CollabClient({
+        jwt,
+        projectId,
+        branch,
+        live: Boolean(pro)
+      })
 
-    // 🗜️  Bundle events – emitted by the dependency bundler service
-    this._client.socket?.on(
-      'bundle:done',
-      this._handleBundleDoneEvent.bind(this)
-    )
-    this._client.socket?.on(
-      'bundle:error',
-      this._handleBundleErrorEvent.bind(this)
-    )
+      // Mark as connected once the socket establishes a connection. This prevents
+      // the SDK from being stuck waiting for an initial snapshot that may never
+      // arrive (e.g. for new/empty documents).
+      const {socket} = this._client
 
-    // Flush any operations that were queued while we were offline.
-    if (this._pendingOps.length) {
-      console.log(
-        `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
-      )
-      this._pendingOps.forEach(({ changes, granularChanges, orders }) => {
-        this.socket.emit('ops', { changes, granularChanges, orders, ts: Date.now() })
+      try {
+        await new Promise((resolve, reject) => {
+          if (!socket) {
+            reject(new Error('[CollabService] Socket instance missing'))
+            return
+          }
+
+          if (socket.connected) {
+            resolve()
+            return
+          }
+
+          /* eslint-disable no-use-before-define */
+          const cleanup = () => {
+            socket.off('connect', handleConnect)
+            socket.off('connect_error', handleError)
+            socket.off('error', handleError)
+            socket.off('disconnect', handleDisconnect)
+            if (this._pendingConnectReject === handleError) {
+              this._pendingConnectReject = null
+            }
+          }
+
+          const handleConnect = () => {
+            cleanup()
+            resolve()
+          }
+
+          const handleError = (error) => {
+            cleanup()
+            reject(
+              error instanceof Error
+                ? error
+                : new Error(String(error || 'Unknown connection error'))
+            )
+          }
+
+          const handleDisconnect = (reason) => {
+            handleError(
+              reason instanceof Error
+                ? reason
+                : new Error(
+                    `[CollabService] Socket disconnected before connect: ${reason || 'unknown'}`
+                  )
+            )
+          }
+
+          this._pendingConnectReject = handleError
+
+          socket.once('connect', handleConnect)
+          socket.once('connect_error', handleError)
+          socket.once('error', handleError)
+          socket.once('disconnect', handleDisconnect)
+          /* eslint-enable no-use-before-define */
+        })
+      } catch (error) {
+        socket?.disconnect()
+        this._client = null
+        this._connectionMeta = null
+        throw error
+      }
+
+      this._attachSocketLifecycleListeners()
+      if (socket?.connected) {
+        this._onSocketConnect()
+      }
+
+      // Set up event listeners
+      socket?.on('ops', ({ changes }) => {
+        console.log(`ops event`)
+        this._stateManager.applyChanges(changes, { fromSocket: true })
       })
-      this._pendingOps.length = 0
-    }
 
-    this._connected = true
-    // console.log('[CollabService] Connected to project:', projectId)
+      socket?.on('commit', ({ version }) => {
+        if (version) {
+          this._stateManager.setVersion(version)
+        }
+
+        // Inform UI about automatic commit
+        rootBus.emit('checkpoint:done', { version, origin: 'auto' })
+      })
+
+      // 🔄  Presence / members / cursor updates
+      socket?.on('clients', this._handleClientsEvent.bind(this))
+
+      // 🗜️  Bundle events – emitted by the dependency bundler service
+      socket?.on(
+        'bundle:done',
+        this._handleBundleDoneEvent.bind(this)
+      )
+      socket?.on(
+        'bundle:error',
+        this._handleBundleErrorEvent.bind(this)
+      )
+
+      // Flush any operations that were queued while we were offline.
+      if (this._pendingOps.length) {
+        console.log(
+          `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
+        )
+        this._pendingOps.forEach(({ changes, granularChanges, orders }) => {
+          this.socket.emit('ops', { changes, granularChanges, orders, ts: Date.now() })
+        })
+        this._pendingOps.length = 0
+      }
+
+      await this._client.ready
+
+      this._connectionMeta = {
+        projectId,
+        branch,
+        live: Boolean(pro)
+      }
+
+      return this.getConnectionInfo()
+    })()
+
+    try {
+      return await this._connectPromise
+    } finally {
+      this._connecting = false
+      this._connectPromise = null
+    }
   }
 
   disconnect() {
     if (this._client?.socket) {
-      this._client.socket.disconnect()
+      if (this._pendingConnectReject) {
+        this._pendingConnectReject(new Error('[CollabService] Connection attempt aborted'))
+        this._pendingConnectReject = null
+      }
+      this._detachSocketLifecycleListeners()
+      if (typeof this._client.dispose === 'function') {
+        this._client.dispose()
+      } else {
+        this._client.socket.disconnect()
+      }
     }
     this._client = null
     this._connected = false
+    this._connecting = false
+    this._connectionMeta = null
+    this._pendingConnectReject = null
     console.log('[CollabService] Disconnected')
   }
 
   isConnected() {
-    return this._connected && this._client?.socket?.connected
+    return Boolean(this._connected && this._client?.socket?.connected)
+  }
+
+  getConnectionInfo() {
+    return {
+      connected: this.isConnected(),
+      connecting: this._connecting,
+      projectId: this._connectionMeta?.projectId ?? null,
+      branch: this._connectionMeta?.branch ?? null,
+      live: this._connectionMeta?.live ?? null,
+      pendingOps: this._pendingOps.length,
+      undoStackSize: this.getUndoStackSize(),
+      redoStackSize: this.getRedoStackSize()
+    }
   }
 
   /* convenient shortcuts */
@@ -660,6 +803,44 @@ export class CollabService extends BaseService {
   }
 
   /* ---------- Manual checkpoint ---------- */
+  _attachSocketLifecycleListeners() {
+    const socket = this._client?.socket
+    if (!socket) {
+      return
+    }
+
+    socket.on('connect', this._onSocketConnect)
+    socket.on('disconnect', this._onSocketDisconnect)
+    socket.on('connect_error', this._onSocketError)
+  }
+
+  _detachSocketLifecycleListeners() {
+    const socket = this._client?.socket
+    if (!socket) {
+      return
+    }
+
+    socket.off('connect', this._onSocketConnect)
+    socket.off('disconnect', this._onSocketDisconnect)
+    socket.off('connect_error', this._onSocketError)
+  }
+
+  _onSocketConnect() {
+    this._connected = true
+  }
+
+  _onSocketDisconnect(reason) {
+    this._connected = false
+
+    if (reason && reason !== 'io client disconnect') {
+      console.warn('[CollabService] Socket disconnected', reason)
+    }
+  }
+
+  _onSocketError(error) {
+    console.warn('[CollabService] Socket connection error', error)
+  }
+
   /**
    * Manually request a checkpoint / commit of buffered operations on the server.
    * Resolves with the new version number once the backend confirms via the