@webex/plugin-meetings 3.12.0-next.50 → 3.12.0-next.51

package/dist/types/hashTree/hashTreeParser.d.ts

@@ -43,14 +43,21 @@ type WebexRequestMethod = (options: Record<string, any>) => Promise<any>;
 export declare const LocusInfoUpdateType: {
     readonly OBJECTS_UPDATED: "OBJECTS_UPDATED";
     readonly MEETING_ENDED: "MEETING_ENDED";
+    readonly LOCUS_NOT_FOUND: "LOCUS_NOT_FOUND";
 };
 export type LocusInfoUpdateType = Enum<typeof LocusInfoUpdateType>;
+interface LocusUpdatePayloads {
+    [LocusInfoUpdateType.OBJECTS_UPDATED]: {
+        updatedObjects: HashTreeObject[];
+    };
+    [LocusInfoUpdateType.MEETING_ENDED]: unknown;
+    [LocusInfoUpdateType.LOCUS_NOT_FOUND]: unknown;
+}
 export type LocusInfoUpdate = {
-    updateType: typeof LocusInfoUpdateType.OBJECTS_UPDATED;
-    updatedObjects: HashTreeObject[];
-} | {
-    updateType: typeof LocusInfoUpdateType.MEETING_ENDED;
-};
+    [K in keyof LocusUpdatePayloads]: {
+        updateType: K;
+    } & LocusUpdatePayloads[K];
+}[keyof LocusUpdatePayloads];
 export type LocusInfoUpdateCallback = (update: LocusInfoUpdate) => void;
 /**
  * This error is thrown if we receive information that the meeting has ended while we're processing some hash messages.
@@ -58,6 +65,13 @@ export type LocusInfoUpdateCallback = (update: LocusInfoUpdate) => void;
  */
 export declare class MeetingEndedError extends Error {
 }
+/**
+ * This error is thrown when a 404 is received from Locus hash tree endpoints, indicating that the locus URL
+ * is no longer valid (e.g. participant moved to a breakout room, or meeting ended).
+ * It's handled internally by HashTreeParser and results in LOCUS_NOT_FOUND being sent up.
+ */
+export declare class LocusNotFoundError extends Error {
+}
 /**
  * Parses hash tree eventing locus data
  */
@@ -193,6 +207,13 @@ declare class HashTreeParser {
      * @returns {void}
      */
     private handleRootHashHeartBeatMessage;
+    /**
+     * Handles known errors that can happen during syncs
+     *
+     * @param {any} error - The error to handle
+     * @returns {boolean} true if the error was recognized and handled, false otherwise
+     */
+    private handleSyncErrors;
     /**
      * Asynchronously initializes new visible data sets
      *

package/dist/types/locus-info/types.d.ts

@@ -75,3 +75,7 @@ export type ReplacesInfo = {
     replacedAt: string;
     sessionId: string;
 };
+export declare const LocusErrorCodes: {
+    readonly LOCUS_INACTIVE: 2403004;
+};
+export type LocusErrorCodes = Enum<typeof LocusErrorCodes>;

package/dist/types/meetings/index.d.ts

@@ -494,8 +494,9 @@ export default class Meetings extends WebexPlugin {
      * @public
      * @memberof Meetings
      */
-    syncMeetings({ keepOnlyLocusMeetings }?: {
+    syncMeetings({ keepOnlyLocusMeetings, skipHashTreeSync, }?: {
         keepOnlyLocusMeetings?: boolean;
+        skipHashTreeSync?: boolean;
     }): Promise<void>;
     /**
      * sort out locus array for initial creating

package/dist/webinar/index.js

@@ -774,7 +774,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee1);
     }))();
   },
-  version: "3.12.0-next.50"
+  version: "3.12.0-next.51"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -94,5 +94,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.12.0-next.50"
+  "version": "3.12.0-next.51"
 }

package/src/hashTree/hashTreeParser.ts

@@ -6,7 +6,7 @@ import BEHAVIORAL_METRICS from '../metrics/constants';
 import {Enum, HTTP_VERBS} from '../constants';
 import {DataSetNames, DATA_SET_INIT_PRIORITY, EMPTY_HASH} from './constants';
 import {ObjectType, HtMeta, HashTreeObject} from './types';
-import {LocusDTO} from '../locus-info/types';
+import {LocusDTO, LocusErrorCodes} from '../locus-info/types';
 import {deleteNestedObjectsWithHtMeta, isMetadata, sortByInitPriority} from './utils';
 
 export interface DataSet {
@@ -56,17 +56,23 @@ type WebexRequestMethod = (options: Record<string, any>) => Promise<any>;
 export const LocusInfoUpdateType = {
   OBJECTS_UPDATED: 'OBJECTS_UPDATED',
   MEETING_ENDED: 'MEETING_ENDED',
+  LOCUS_NOT_FOUND: 'LOCUS_NOT_FOUND',
 } as const;
 
 export type LocusInfoUpdateType = Enum<typeof LocusInfoUpdateType>;
-export type LocusInfoUpdate =
-  | {
-      updateType: typeof LocusInfoUpdateType.OBJECTS_UPDATED;
-      updatedObjects: HashTreeObject[];
-    }
-  | {
-      updateType: typeof LocusInfoUpdateType.MEETING_ENDED;
-    };
+
+interface LocusUpdatePayloads {
+  [LocusInfoUpdateType.OBJECTS_UPDATED]: {updatedObjects: HashTreeObject[]};
+  [LocusInfoUpdateType.MEETING_ENDED]: unknown; // No extra data
+  [LocusInfoUpdateType.LOCUS_NOT_FOUND]: unknown; // No extra data
+}
+
+export type LocusInfoUpdate = {
+  [K in keyof LocusUpdatePayloads]: {
+    updateType: K;
+  } & LocusUpdatePayloads[K];
+}[keyof LocusUpdatePayloads];
+
 export type LocusInfoUpdateCallback = (update: LocusInfoUpdate) => void;
 
 interface LeafInfo {
@@ -82,6 +88,13 @@ interface LeafInfo {
  */
 export class MeetingEndedError extends Error {}
 
+/**
+ * This error is thrown when a 404 is received from Locus hash tree endpoints, indicating that the locus URL
+ * is no longer valid (e.g. participant moved to a breakout room, or meeting ended).
+ * It's handled internally by HashTreeParser and results in LOCUS_NOT_FOUND being sent up.
+ */
+export class LocusNotFoundError extends Error {}
+
 /* Currently Locus always sends Metadata objects only in the "self" dataset.
  * If this ever changes, update all the code that relies on this constant.
  */
@@ -552,6 +565,32 @@ class HashTreeParser {
     });
   }
 
+  /**
+   * Handles known errors that can happen during syncs
+   *
+   * @param {any} error - The error to handle
+   * @returns {boolean} true if the error was recognized and handled, false otherwise
+   */
+  private handleSyncErrors(error: any) {
+    if (error instanceof MeetingEndedError) {
+      this.callLocusInfoUpdateCallback({
+        updateType: LocusInfoUpdateType.MEETING_ENDED,
+      });
+
+      return true;
+    }
+    if (error instanceof LocusNotFoundError) {
+      this.callLocusInfoUpdateCallback({
+        updateType: LocusInfoUpdateType.LOCUS_NOT_FOUND,
+      });
+      this.stop();
+
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Asynchronously initializes new visible data sets
    *
@@ -568,11 +607,7 @@ class HashTreeParser {
     );
     queueMicrotask(() => {
       this.initializeNewVisibleDataSets(dataSetsRequiringInitialization).catch((error) => {
-        if (error instanceof MeetingEndedError) {
-          this.callLocusInfoUpdateCallback({
-            updateType: LocusInfoUpdateType.MEETING_ENDED,
-          });
-        } else {
+        if (!this.handleSyncErrors(error)) {
           LoggerProxy.logger.warn(
             `HashTreeParser#queueInitForNewVisibleDataSets --> ${
               this.debugId
@@ -1271,11 +1306,7 @@ class HashTreeParser {
         this.handleMessage(syncResponse, 'via sync API');
       }
     } catch (error) {
-      if (error instanceof MeetingEndedError) {
-        this.callLocusInfoUpdateCallback({
-          updateType: LocusInfoUpdateType.MEETING_ENDED,
-        });
-      } else {
+      if (!this.handleSyncErrors(error)) {
         LoggerProxy.logger.warn(
           `HashTreeParser#performSync --> ${this.debugId} error during sync for data set "${dataSet.name}":`,
           error
@@ -1603,17 +1634,28 @@ class HashTreeParser {
   }
 
   private checkForSentinelHttpResponse(error: any, dataSetName?: string) {
+    // 404 for any dataset means the locus is no longer available at this URL - could be replaced or ended
+    // if a dataset is just not visible, we would get a 400
+    if (error.statusCode === 404) {
+      LoggerProxy.logger.info(
+        `HashTreeParser#checkForSentinelHttpResponse --> ${this.debugId} Received 404 for data set "${dataSetName}", locus not found`
+      );
+      this.stopAllTimers();
+
+      throw new LocusNotFoundError();
+    }
+
     const isValidDataSetForSentinel =
       dataSetName === undefined ||
       PossibleSentinelMessageDataSetNames.includes(dataSetName.toLowerCase());
 
     if (
-      ((error.statusCode === 409 && error.body?.errorCode === 2403004) ||
-        error.statusCode === 404) &&
+      error.statusCode === 409 &&
+      error.body?.errorCode === LocusErrorCodes.LOCUS_INACTIVE &&
       isValidDataSetForSentinel
     ) {
       LoggerProxy.logger.info(
-        `HashTreeParser#checkForSentinelHttpResponse --> ${this.debugId} Received ${error.statusCode} for data set "${dataSetName}", indicating that the meeting has ended`
+        `HashTreeParser#checkForSentinelHttpResponse --> ${this.debugId} Received ${error.statusCode}/${error.body?.errorCode} for data set "${dataSetName}", indicating that the meeting has ended`
       );
       this.stopAllTimers();
 

package/src/locus-info/index.ts

@@ -1344,6 +1344,21 @@ export default class LocusInfo extends EventsScope {
           );
           this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.SELF_REMOVED);
         }
+        break;
+      }
+
+      case LocusInfoUpdateType.LOCUS_NOT_FOUND: {
+        LoggerProxy.logger.info(
+          `Locus-info:index#updateFromHashTree --> received LOCUS_NOT_FOUND for ${locusUrl}, triggering syncMeetings`
+        );
+        this.webex.meetings
+          .syncMeetings({keepOnlyLocusMeetings: false, skipHashTreeSync: true})
+          .catch((syncError) => {
+            LoggerProxy.logger.error(
+              `Locus-info:index#updateFromHashTree --> syncMeetings failed after LOCUS_NOT_FOUND: ${syncError}`
+            );
+          });
+        break;
       }
     }
   }

package/src/locus-info/types.ts

@@ -77,3 +77,9 @@ export type ReplacesInfo = {
   replacedAt: string;
   sessionId: string;
 };
+
+export const LocusErrorCodes = {
+  LOCUS_INACTIVE: 2403004,
+} as const;
+
+export type LocusErrorCodes = Enum<typeof LocusErrorCodes>;

package/src/meetings/index.ts

@@ -1924,7 +1924,10 @@ export default class Meetings extends WebexPlugin {
    * @public
    * @memberof Meetings
    */
-  public async syncMeetings({keepOnlyLocusMeetings = true} = {}): Promise<void> {
+  public async syncMeetings({
+    keepOnlyLocusMeetings = true,
+    skipHashTreeSync = false,
+  } = {}): Promise<void> {
     // @ts-ignore
     if (this.webex.credentials.isUnverifiedGuest) {
       LoggerProxy.logger.info(
@@ -1984,18 +1987,20 @@ export default class Meetings extends WebexPlugin {
       }
     }
 
-    // Trigger hash tree syncs for all remaining meetings
-    const remainingMeetings = this.meetingCollection.getAll();
-    const syncPromises = [];
+    if (!skipHashTreeSync) {
+      // Trigger hash tree syncs for all remaining meetings
+      const remainingMeetings = this.meetingCollection.getAll();
+      const syncPromises = [];
 
-    for (const meeting of Object.values(remainingMeetings) as any[]) {
-      if (meeting.locusInfo) {
-        syncPromises.push(meeting.locusInfo.syncAllHashTreeDatasets());
+      for (const meeting of Object.values(remainingMeetings) as any[]) {
+        if (meeting.locusInfo) {
+          syncPromises.push(meeting.locusInfo.syncAllHashTreeDatasets());
+        }
       }
-    }
 
-    if (syncPromises.length > 0) {
-      await Promise.all(syncPromises);
+      if (syncPromises.length > 0) {
+        await Promise.all(syncPromises);
+      }
     }
   }
 

package/test/unit/spec/hashTree/hashTreeParser.ts

@@ -1,6 +1,7 @@
 import HashTreeParser, {
   LocusInfoUpdateType,
   MeetingEndedError,
+  LocusNotFoundError,
 } from '@webex/plugin-meetings/src/hashTree/hashTreeParser';
 import HashTree from '@webex/plugin-meetings/src/hashTree/hashTree';
 import {expect} from '@webex/test-helper-chai';
@@ -708,8 +709,11 @@ describe('HashTreeParser', () => {
       assert.notCalled(callback);
     });
 
-    [404, 409].forEach((errorCode) => {
-      it(`emits MeetingEndedError if getting visible datasets returns ${errorCode}`, async () => {
+    [
+      {errorCode: 404, expectedError: LocusNotFoundError},
+      {errorCode: 409, expectedError: MeetingEndedError},
+    ].forEach(({errorCode, expectedError}) => {
+      it(`throws ${expectedError.name} if getting visible datasets returns ${errorCode}`, async () => {
         const minimalInitialLocus = {
           dataSets: [],
           locus: null,
@@ -732,7 +736,6 @@ describe('HashTreeParser', () => {
           )
           .rejects(error);
 
-        // initializeFromMessage should throw MeetingEndedError
         let thrownError;
         try {
           await parser.initializeFromMessage({
@@ -744,7 +747,7 @@ describe('HashTreeParser', () => {
           thrownError = e;
         }
 
-        expect(thrownError).to.be.instanceOf(MeetingEndedError);
+        expect(thrownError).to.be.instanceOf(expectedError);
       });
     });
   });
@@ -1766,12 +1769,10 @@ describe('HashTreeParser', () => {
         });
       });
 
-      describe('emits MEETING_ENDED', () => {
-        [404, 409].forEach((statusCode) => {
-          it(`when /hashtree returns ${statusCode}`, async () => {
+      describe('emits MEETING_ENDED when 409/2403004 is returned', () => {
+          it('when /hashtree returns 409', async () => {
             const parser = createHashTreeParser();
 
-            // Send a message to trigger sync algorithm
             const message = {
               dataSets: [createDataSet('main', 16, 1100)],
               visibleDataSetsUrl,
@@ -1796,12 +1797,9 @@ describe('HashTreeParser', () => {
 
             const mainDataSetUrl = parser.dataSets.main.url;
 
-            // Mock getHashesFromLocus to reject with the sentinel error
-            const error: any = new Error(`Request failed with status ${statusCode}`);
-            error.statusCode = statusCode;
-            if (statusCode === 409) {
-              error.body = {errorCode: 2403004};
-            }
+            const error: any = new Error('Request failed with status 409');
+            error.statusCode = 409;
+            error.body = {errorCode: 2403004};
             webexRequest
               .withArgs(
                 sinon.match({
@@ -1811,13 +1809,10 @@ describe('HashTreeParser', () => {
               )
               .rejects(error);
 
-            // Trigger sync by advancing time
             await clock.tickAsync(1000);
 
-            // Verify callback was called with MEETING_ENDED
             assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.MEETING_ENDED});
 
-            // Verify all timers are stopped
             Object.values(parser.dataSets).forEach((ds: any) => {
               assert.isUndefined(ds.timer);
               assert.isUndefined(ds.heartbeatWatchdogTimer);
@@ -1827,10 +1822,9 @@ describe('HashTreeParser', () => {
             assert.notCalled(metricsStub);
           });
 
-          it(`when /sync returns ${statusCode}`, async () => {
+          it('when /sync returns 409', async () => {
             const parser = createHashTreeParser();
 
-            // Send a message to trigger sync algorithm
             const message = {
               dataSets: [createDataSet('main', 16, 1100)],
               visibleDataSetsUrl,
@@ -1855,19 +1849,15 @@ describe('HashTreeParser', () => {
 
             const mainDataSetUrl = parser.dataSets.main.url;
 
-            // Mock getHashesFromLocus to succeed
             mockGetHashesFromLocusResponse(
               mainDataSetUrl,
               new Array(16).fill('00000000000000000000000000000000'),
               createDataSet('main', 16, 1101)
             );
 
-            // Mock sendSyncRequestToLocus to reject with the sentinel error
-            const error: any = new Error(`Request failed with status ${statusCode}`);
-            error.statusCode = statusCode;
-            if (statusCode === 409) {
-              error.body = {errorCode: 2403004};
-            }
+            const error: any = new Error('Request failed with status 409');
+            error.statusCode = 409;
+            error.body = {errorCode: 2403004};
             webexRequest
               .withArgs(
                 sinon.match({
@@ -1877,12 +1867,121 @@ describe('HashTreeParser', () => {
               )
               .rejects(error);
 
-            // Trigger sync by advancing time
             await clock.tickAsync(1000);
 
-            // Verify callback was called with MEETING_ENDED
             assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.MEETING_ENDED});
 
+            Object.values(parser.dataSets).forEach((ds: any) => {
+              assert.isUndefined(ds.timer);
+              assert.isUndefined(ds.heartbeatWatchdogTimer);
+            });
+          });
+      });
+
+      describe('emits LOCUS_NOT_FOUND and stops parser when 404 is returned', () => {
+          it('when /hashtree returns 404', async () => {
+            const parser = createHashTreeParser();
+
+            const message = {
+              dataSets: [createDataSet('main', 16, 1100)],
+              visibleDataSetsUrl,
+              locusUrl,
+              locusStateElements: [
+                {
+                  htMeta: {
+                    elementId: {
+                      type: 'locus' as const,
+                      id: 0,
+                      version: 201,
+                    },
+                    dataSetNames: ['main'],
+                  },
+                  data: {info: {id: 'initial-update'}},
+                },
+              ],
+            };
+
+            parser.handleMessage(message, 'initial message');
+            callback.resetHistory();
+
+            const mainDataSetUrl = parser.dataSets.main.url;
+
+            const error: any = new Error('Request failed with status 404');
+            error.statusCode = 404;
+            webexRequest
+              .withArgs(
+                sinon.match({
+                  method: 'GET',
+                  uri: `${mainDataSetUrl}/hashtree`,
+                })
+              )
+              .rejects(error);
+
+            await clock.tickAsync(1000);
+
+            assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.LOCUS_NOT_FOUND});
+
+            // Verify parser is stopped
+            expect(parser.state).to.equal('stopped');
+
+            // Verify all timers are stopped
+            Object.values(parser.dataSets).forEach((ds: any) => {
+              assert.isUndefined(ds.timer);
+              assert.isUndefined(ds.heartbeatWatchdogTimer);
+            });
+          });
+
+          it('when /sync returns 404', async () => {
+            const parser = createHashTreeParser();
+
+            const message = {
+              dataSets: [createDataSet('main', 16, 1100)],
+              visibleDataSetsUrl,
+              locusUrl,
+              locusStateElements: [
+                {
+                  htMeta: {
+                    elementId: {
+                      type: 'locus' as const,
+                      id: 0,
+                      version: 201,
+                    },
+                    dataSetNames: ['main'],
+                  },
+                  data: {info: {id: 'initial-update'}},
+                },
+              ],
+            };
+
+            parser.handleMessage(message, 'initial message');
+            callback.resetHistory();
+
+            const mainDataSetUrl = parser.dataSets.main.url;
+
+            mockGetHashesFromLocusResponse(
+              mainDataSetUrl,
+              new Array(16).fill('00000000000000000000000000000000'),
+              createDataSet('main', 16, 1101)
+            );
+
+            const error: any = new Error('Request failed with status 404');
+            error.statusCode = 404;
+            webexRequest
+              .withArgs(
+                sinon.match({
+                  method: 'POST',
+                  uri: `${mainDataSetUrl}/sync`,
+                })
+              )
+              .rejects(error);
+
+            await clock.tickAsync(1000);
+
+            assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.LOCUS_NOT_FOUND});
+
+            // Verify parser is stopped
+            expect(parser.state).to.equal('stopped');
+
             // Verify all timers are stopped
             Object.values(parser.dataSets).forEach((ds: any) => {
               assert.isUndefined(ds.timer);
@@ -1892,7 +1991,6 @@ describe('HashTreeParser', () => {
             // Verify no sync failure metric was sent for end-meeting sentinel
             assert.notCalled(metricsStub);
           });
-        });
       });
 
       it('requests only mismatched hashes during sync', async () => {
@@ -2554,7 +2652,7 @@ describe('HashTreeParser', () => {
         expect(syncCalls[1].args[0].uri).to.equal(`${newAtdActiveDataSet.url}/sync`);
       });
 
-      it('emits MEETING_ENDED if async init of a new visible dataset fails with 404', async () => {
+      it('emits LOCUS_NOT_FOUND if async init of a new visible dataset fails with 404', async () => {
         const parser = createHashTreeParser();
 
         // Stub updateItems on self hash tree to return true
@@ -2619,8 +2717,8 @@ describe('HashTreeParser', () => {
         // Wait for the async initialization (queueMicrotask) to complete
         await clock.tickAsync(0);
 
-        // Verify callback was called with MEETING_ENDED
-        assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.MEETING_ENDED});
+        // Verify callback was called with LOCUS_NOT_FOUND (404 means locus URL is stale, not necessarily meeting ended)
+        assert.calledOnceWithExactly(callback, {updateType: LocusInfoUpdateType.LOCUS_NOT_FOUND});
       });
 
       it('handles removal of visible data set', async () => {

package/test/unit/spec/locus-info/index.js

@@ -332,6 +332,7 @@ describe('plugin-meetings', () => {
       describe('should setup correct locusInfoUpdateCallback when creating HashTreeParser', () => {
         const OBJECTS_UPDATED = HashTreeParserModule.LocusInfoUpdateType.OBJECTS_UPDATED;
         const MEETING_ENDED = HashTreeParserModule.LocusInfoUpdateType.MEETING_ENDED;
+        const LOCUS_NOT_FOUND = HashTreeParserModule.LocusInfoUpdateType.LOCUS_NOT_FOUND;
 
         let locusInfoUpdateCallback;
         let onDeltaLocusStub;
@@ -1001,6 +1002,37 @@ describe('plugin-meetings', () => {
           assert.notCalled(destroyStub);
         });
 
+        it('should handle LOCUS_NOT_FOUND by calling syncMeetings with skipHashTreeSync', () => {
+          const syncMeetingsStub = sinon.stub(locusInfo.webex.meetings, 'syncMeetings').resolves();
+
+          locusInfoUpdateCallback({updateType: LOCUS_NOT_FOUND});
+
+          assert.calledOnceWithExactly(syncMeetingsStub, {keepOnlyLocusMeetings: false, skipHashTreeSync: true});
+        });
+
+        it('should handle LOCUS_NOT_FOUND and log error if syncMeetings fails', async () => {
+          const syncError = new Error('sync failed');
+          const syncMeetingsStub = sinon.stub(locusInfo.webex.meetings, 'syncMeetings').rejects(syncError);
+          const logErrorStub = LoggerProxy.logger.error?.isSinonProxy
+            ? LoggerProxy.logger.error
+            : sinon.stub(LoggerProxy.logger, 'error');
+
+          logErrorStub.resetHistory();
+
+          locusInfoUpdateCallback({updateType: LOCUS_NOT_FOUND});
+
+          assert.calledOnceWithExactly(syncMeetingsStub, {keepOnlyLocusMeetings: false, skipHashTreeSync: true});
+
+          // wait for the promise rejection to be handled
+          await testUtils.flushPromises();
+
+          assert.calledOnce(logErrorStub);
+          assert.match(
+            logErrorStub.firstCall.args[0],
+            /syncMeetings failed after LOCUS_NOT_FOUND/
+          );
+        });
+
         it('should set forceReplaceMembers to true on the first update for a locusUrl (initializedFromHashTree is false)', () => {
           const createdHashTreeParser = locusInfo.hashTreeParsers.get('fake-locus-url');
           createdHashTreeParser.initializedFromHashTree = false;

package/test/unit/spec/meetings/index.js

@@ -1714,6 +1714,40 @@ describe('plugin-meetings', () => {
           });
         });
 
+        describe('skipHashTreeSync parameter', () => {
+          it('should skip syncAllHashTreeDatasets when skipHashTreeSync is true', async () => {
+            const mockLocusInfo = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+            };
+
+            webex.meetings.request.getActiveMeetings = sinon.stub().resolves({loci: []});
+            webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+              meeting1: {locusInfo: mockLocusInfo},
+            });
+
+            await webex.meetings.syncMeetings({keepOnlyLocusMeetings: false, skipHashTreeSync: true});
+
+            assert.calledOnce(webex.meetings.request.getActiveMeetings);
+            assert.notCalled(mockLocusInfo.syncAllHashTreeDatasets);
+          });
+
+          it('should call syncAllHashTreeDatasets when skipHashTreeSync is false (default)', async () => {
+            const mockLocusInfo = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+            };
+
+            webex.meetings.request.getActiveMeetings = sinon.stub().resolves({loci: []});
+            webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+              meeting1: {locusInfo: mockLocusInfo},
+            });
+
+            await webex.meetings.syncMeetings({keepOnlyLocusMeetings: false, skipHashTreeSync: false});
+
+            assert.calledOnce(webex.meetings.request.getActiveMeetings);
+            assert.calledOnce(mockLocusInfo.syncAllHashTreeDatasets);
+          });
+        });
+
         describe('syncAllHashTreeDatasets in syncMeetings', () => {
           it('should call syncAllHashTreeDatasets for multiple meetings, skipping those without locusInfo', async () => {
             const mockLocusInfo1 = {