gloomberb 0.13.2 → 0.14.0

package/src/api-client/socket.ts

@@ -6,10 +6,12 @@ import type {
   QuoteStreamTarget,
   ScannerFeedEvent,
   ScannerKind,
+  TeamNotification,
 } from "./types";
 import {
   normalizeChatMessage,
   normalizeChatNotification,
+  normalizeTeamNotification,
 } from "./normalizers";
 import { debugLog } from "../utils/debug-log";
 import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
@@ -26,7 +28,12 @@ const cloudApiLog = debugLog.createLogger("cloud-api");
 type ChannelListener = (message: ChatMessage) => void;
 type ChatNotificationListener = (notification: ChatNotification) => void;
 type ChatPresenceListener = (onlineCount: number) => void;
-type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
+type TeamNotificationListener = (notification: TeamNotification) => void;
+type CloudEventListener = (data: unknown) => void;
+type QuoteListener = (
+  target: QuoteStreamTarget,
+  quote: CloudQuotePayload,
+) => void;
 type QuoteSubscription = {
   target: QuoteStreamTarget;
   listener: QuoteListener;
@@ -58,14 +65,20 @@ type CloudApiSocketDelegate = {
 };
 
 type ChatChannelConnection = {
-  send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>;
+  send: (
+    content: string,
+    replyToId?: string,
+    clientMessageId?: string,
+  ) => Promise<ChatMessage>;
   close: () => void;
 };
 
 function marketKey(symbol: string, exchange?: string): string {
   const normalizedSymbolValue = normalizeSymbol(symbol);
   const normalizedExchangeValue = canonicalExchange(exchange);
-  return normalizedExchangeValue ? `${normalizedSymbolValue}:${normalizedExchangeValue}` : normalizedSymbolValue;
+  return normalizedExchangeValue
+    ? `${normalizedSymbolValue}:${normalizedExchangeValue}`
+    : normalizedSymbolValue;
 }
 
 export class CloudApiSocket {
@@ -74,15 +87,35 @@ export class CloudApiSocket {
   private reconnectDelayMs = 1000;
 
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
-  private readonly chatNotificationListeners = new Set<ChatNotificationListener>();
+  private readonly chatNotificationListeners =
+    new Set<ChatNotificationListener>();
   private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
+  private readonly teamNotificationListeners =
+    new Set<TeamNotificationListener>();
+  private readonly cloudEventListeners = new Map<
+    string,
+    Set<CloudEventListener>
+  >();
   private nextQuoteSubscriptionId = 1;
-  private readonly quoteSubscriptions = new Map<string, Map<number, QuoteSubscription>>();
+  private readonly quoteSubscriptions = new Map<
+    string,
+    Map<number, QuoteSubscription>
+  >();
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
-  private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
-  private readonly pendingQuoteUnsubscribes = new Map<string, QuoteStreamTarget>();
-  private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly scannerListeners = new Map<ScannerKind, Set<ScannerListener>>();
+  private readonly pendingQuoteSubscribes = new Map<
+    string,
+    QuoteStreamTarget
+  >();
+  private readonly pendingQuoteUnsubscribes = new Map<
+    string,
+    QuoteStreamTarget
+  >();
+  private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null =
+    null;
+  private readonly scannerListeners = new Map<
+    ScannerKind,
+    Set<ScannerListener>
+  >();
   /** Latest fan-out payload, so a pane opened mid-stream does not wait for the next tick. */
   private readonly scannerSnapshots = new Map<ScannerKind, ScannerFeedEvent>();
 
@@ -111,7 +144,11 @@ export class CloudApiSocket {
     this.ws = null;
     if (ws) {
       cloudApiLog.info("teardown websocket");
-      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "idle", "Socket closed locally");
+      this.health.reportSocketState(
+        GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+        "idle",
+        "Socket closed locally",
+      );
     }
     try {
       ws?.close();
@@ -124,7 +161,11 @@ export class CloudApiSocket {
     channelId: string,
     onMessage: (msg: ChatMessage) => void,
     onError: ((err: string) => void) | undefined,
-    sendMessage: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>,
+    sendMessage: (
+      content: string,
+      replyToId?: string,
+      clientMessageId?: string,
+    ) => Promise<ChatMessage>,
   ): ChatChannelConnection {
     if (!channelId) {
       return {
@@ -135,7 +176,8 @@ export class CloudApiSocket {
       };
     }
 
-    const listeners = this.channelListeners.get(channelId) ?? new Set<ChannelListener>();
+    const listeners =
+      this.channelListeners.get(channelId) ?? new Set<ChannelListener>();
     const firstListener = listeners.size === 0;
     listeners.add(onMessage);
     this.channelListeners.set(channelId, listeners);
@@ -145,9 +187,17 @@ export class CloudApiSocket {
     }
 
     return {
-      send: async (content: string, replyToId?: string, clientMessageId?: string) => {
+      send: async (
+        content: string,
+        replyToId?: string,
+        clientMessageId?: string,
+      ) => {
         try {
-          const message = await sendMessage(content, replyToId, clientMessageId);
+          const message = await sendMessage(
+            content,
+            replyToId,
+            clientMessageId,
+          );
           onMessage(message);
           return message;
         } catch (error) {
@@ -184,12 +234,48 @@ export class CloudApiSocket {
     };
   }
 
+  subscribeTeamNotifications(listener: TeamNotificationListener): () => void {
+    this.teamNotificationListeners.add(listener);
+    this.syncAuthState();
+    return () => {
+      this.teamNotificationListeners.delete(listener);
+      if (!this.shouldKeepSocketOpen()) {
+        this.teardown();
+      }
+    };
+  }
+
+  /** Subscribes to a server push frame by type, e.g. a team layout update. */
+  subscribeCloudEvent(type: string, listener: CloudEventListener): () => void {
+    const listeners =
+      this.cloudEventListeners.get(type) ?? new Set<CloudEventListener>();
+    listeners.add(listener);
+    this.cloudEventListeners.set(type, listeners);
+    this.syncAuthState();
+    return () => {
+      const current = this.cloudEventListeners.get(type);
+      if (current) {
+        current.delete(listener);
+        if (current.size === 0) {
+          this.cloudEventListeners.delete(type);
+        }
+      }
+      if (!this.shouldKeepSocketOpen()) {
+        this.teardown();
+      }
+    };
+  }
+
   /**
    * Subscribes to a shared server-computed scanner. Every open pane of the same
    * kind shares one upstream subscription; the socket fans the payload out.
    */
-  subscribeScanner(scanner: ScannerKind, listener: ScannerListener): () => void {
-    const listeners = this.scannerListeners.get(scanner) ?? new Set<ScannerListener>();
+  subscribeScanner(
+    scanner: ScannerKind,
+    listener: ScannerListener,
+  ): () => void {
+    const listeners =
+      this.scannerListeners.get(scanner) ?? new Set<ScannerListener>();
     const firstListener = listeners.size === 0;
     listeners.add(listener);
     this.scannerListeners.set(scanner, listeners);
@@ -220,34 +306,48 @@ export class CloudApiSocket {
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
   ): () => void {
     const subscriptionId = this.nextQuoteSubscriptionId++;
-    const uniqueTargets = [...new Map(
-      targets
-        .filter((target) => typeof target.symbol === "string" && target.symbol.trim().length > 0)
-        .map((target) => {
-          const normalized = {
-            symbol: normalizeSymbol(target.symbol),
-            exchange: canonicalExchange(target.exchange),
-            surface: target.surface,
-            visible: target.visible,
-            selected: target.selected,
-            weight: target.weight,
-          } satisfies QuoteStreamTarget;
-          return [marketKey(normalized.symbol, normalized.exchange), normalized] as const;
-        }),
-    ).values()];
+    const uniqueTargets = [
+      ...new Map(
+        targets
+          .filter(
+            (target) =>
+              typeof target.symbol === "string" &&
+              target.symbol.trim().length > 0,
+          )
+          .map((target) => {
+            const normalized = {
+              symbol: normalizeSymbol(target.symbol),
+              exchange: canonicalExchange(target.exchange),
+              surface: target.surface,
+              visible: target.visible,
+              selected: target.selected,
+              weight: target.weight,
+            } satisfies QuoteStreamTarget;
+            return [
+              marketKey(normalized.symbol, normalized.exchange),
+              normalized,
+            ] as const;
+          }),
+      ).values(),
+    ];
 
     const newSubscriptions: QuoteStreamTarget[] = [];
     const updatedSubscriptions: QuoteStreamTarget[] = [];
     for (const target of uniqueTargets) {
       const key = marketKey(target.symbol, target.exchange);
-      const subscriptions = this.quoteSubscriptions.get(key) ?? new Map<number, QuoteSubscription>();
+      const subscriptions =
+        this.quoteSubscriptions.get(key) ??
+        new Map<number, QuoteSubscription>();
       const previousTarget = this.quoteTargets.get(key);
       subscriptions.set(subscriptionId, { target, listener: onQuote });
       this.quoteSubscriptions.set(key, subscriptions);
-      const mergedTarget = mergeQuoteStreamSubscriptions(subscriptions.values()) ?? target;
+      const mergedTarget =
+        mergeQuoteStreamSubscriptions(subscriptions.values()) ?? target;
       if (!previousTarget) {
         newSubscriptions.push(target);
-      } else if (!this.areQuoteStreamTargetsEquivalent(previousTarget, mergedTarget)) {
+      } else if (
+        !this.areQuoteStreamTargetsEquivalent(previousTarget, mergedTarget)
+      ) {
         updatedSubscriptions.push(mergedTarget);
       }
       this.quoteTargets.set(key, mergedTarget);
@@ -258,7 +358,9 @@ export class CloudApiSocket {
     if (subscriptionsToSend.length > 0) {
       cloudApiLog.info("register quote listeners", {
         count: subscriptionsToSend.length,
-        symbols: subscriptionsToSend.map((target) => marketKey(target.symbol, target.exchange)),
+        symbols: subscriptionsToSend.map((target) =>
+          marketKey(target.symbol, target.exchange),
+        ),
       });
       this.queueQuoteSubscribes(subscriptionsToSend);
     }
@@ -278,10 +380,15 @@ export class CloudApiSocket {
           this.quoteTargets.delete(key);
           continue;
         }
-        const mergedTarget = mergeQuoteStreamSubscriptions(subscriptions.values());
+        const mergedTarget = mergeQuoteStreamSubscriptions(
+          subscriptions.values(),
+        );
         if (!mergedTarget) continue;
         this.quoteTargets.set(key, mergedTarget);
-        if (previousTarget && !this.areQuoteStreamTargetsEquivalent(previousTarget, mergedTarget)) {
+        if (
+          previousTarget &&
+          !this.areQuoteStreamTargetsEquivalent(previousTarget, mergedTarget)
+        ) {
           updatedTargets.push(mergedTarget);
         }
       }
@@ -293,7 +400,9 @@ export class CloudApiSocket {
       if (removedTargets.length > 0) {
         cloudApiLog.info("remove quote listeners", {
           count: removedTargets.length,
-          symbols: removedTargets.map((target) => marketKey(target.symbol, target.exchange)),
+          symbols: removedTargets.map((target) =>
+            marketKey(target.symbol, target.exchange),
+          ),
         });
         this.queueQuoteUnsubscribes(removedTargets);
       }
@@ -312,6 +421,8 @@ export class CloudApiSocket {
     this.channelListeners.clear();
     this.chatNotificationListeners.clear();
     this.chatPresenceListeners.clear();
+    this.teamNotificationListeners.clear();
+    this.cloudEventListeners.clear();
     this.quoteSubscriptions.clear();
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();
@@ -335,16 +446,25 @@ export class CloudApiSocket {
     }
 
     if (parsed?.type === "ready" && parsed.user) {
-      cloudApiLog.info("websocket ready", { emailVerified: parsed.user.emailVerified === true });
-      this.delegate.updateCurrentUserFromSocket(parsed.user as Partial<AuthUser>);
+      cloudApiLog.info("websocket ready", {
+        emailVerified: parsed.user.emailVerified === true,
+      });
+      this.delegate.updateCurrentUserFromSocket(
+        parsed.user as Partial<AuthUser>,
+      );
       return;
     }
 
     if (parsed?.type === "auth.unverified") {
       cloudApiLog.warn("websocket marked unverified");
-      if (this.delegate.isUsingWebSocketToken() && this.delegate.clearWebSocketTokenForFallback()) {
+      if (
+        this.delegate.isUsingWebSocketToken() &&
+        this.delegate.clearWebSocketTokenForFallback()
+      ) {
         this.reconnectDelayMs = 1000;
-        cloudApiLog.warn("cleared websocket token after auth rejection; falling back to session token");
+        cloudApiLog.warn(
+          "cleared websocket token after auth rejection; falling back to session token",
+        );
         this.teardown();
         this.scheduleReconnect();
         return;
@@ -357,30 +477,53 @@ export class CloudApiSocket {
       return;
     }
 
-    if (parsed?.type === "chat.message" && typeof parsed.channelId === "string" && parsed.data) {
+    if (
+      parsed?.type === "chat.message" &&
+      typeof parsed.channelId === "string" &&
+      parsed.data
+    ) {
       const message = normalizeChatMessage(parsed.data as ChatMessage);
-      for (const listener of this.channelListeners.get(parsed.channelId) ?? []) {
+      for (const listener of this.channelListeners.get(parsed.channelId) ??
+        []) {
         listener(message);
       }
       return;
     }
 
     if (parsed?.type === "chat.notification" && parsed.data) {
-      const notification = normalizeChatNotification(parsed.data as ChatNotification);
+      const notification = normalizeChatNotification(
+        parsed.data as ChatNotification,
+      );
       for (const listener of this.chatNotificationListeners) {
         listener(notification);
       }
       return;
     }
 
-    if (parsed?.type === "chat.presence" && typeof parsed.onlineCount === "number") {
+    if (parsed?.type === "team.notification" && parsed.data) {
+      const notification = normalizeTeamNotification(
+        parsed.data as TeamNotification,
+      );
+      for (const listener of this.teamNotificationListeners) {
+        listener(notification);
+      }
+      return;
+    }
+
+    if (
+      parsed?.type === "chat.presence" &&
+      typeof parsed.onlineCount === "number"
+    ) {
       for (const listener of this.chatPresenceListeners) {
         listener(parsed.onlineCount);
       }
       return;
     }
 
-    const scannerKind = typeof parsed?.type === "string" ? SCANNER_MESSAGE_KINDS[parsed.type] : undefined;
+    const scannerKind =
+      typeof parsed?.type === "string"
+        ? SCANNER_MESSAGE_KINDS[parsed.type]
+        : undefined;
     if (scannerKind) {
       const { type: _type, ...payload } = parsed;
       this.emitScannerEvent(scannerKind, { type: "data", payload });
@@ -392,13 +535,18 @@ export class CloudApiSocket {
       if (denied) {
         this.emitScannerEvent(denied, {
           type: "denied",
-          reason: typeof parsed.reason === "string" ? parsed.reason : "pro_required",
+          reason:
+            typeof parsed.reason === "string" ? parsed.reason : "pro_required",
         });
       }
       return;
     }
 
-    if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
+    if (
+      parsed?.type === "market.quote" &&
+      parsed.quote &&
+      typeof parsed.symbol === "string"
+    ) {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const quote: CloudQuotePayload = {
         ...(parsed.quote as CloudQuotePayload),
@@ -407,9 +555,21 @@ export class CloudApiSocket {
           : {}),
         ...(typeof parsed.stale === "boolean" ? { stale: parsed.stale } : {}),
       };
-      for (const subscription of this.quoteSubscriptions.get(key)?.values() ?? []) {
+      for (const subscription of this.quoteSubscriptions.get(key)?.values() ??
+        []) {
         subscription.listener(subscription.target, quote);
       }
+      return;
+    }
+
+    if (typeof parsed?.type === "string") {
+      const listeners = this.cloudEventListeners.get(parsed.type);
+      if (listeners && listeners.size > 0) {
+        for (const listener of listeners) {
+          listener(parsed.data);
+        }
+        return;
+      }
     }
   }
 
@@ -419,7 +579,10 @@ export class CloudApiSocket {
     return baseUrl.replace(/^https?/, wsProtocol);
   }
 
-  private emitScannerEvent(scanner: ScannerKind, event: ScannerFeedEvent): void {
+  private emitScannerEvent(
+    scanner: ScannerKind,
+    event: ScannerFeedEvent,
+  ): void {
     this.scannerSnapshots.set(scanner, event);
     for (const listener of this.scannerListeners.get(scanner) ?? []) {
       listener(event);
@@ -427,10 +590,15 @@ export class CloudApiSocket {
   }
 
   private shouldKeepSocketOpen(): boolean {
-    if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0) return true;
-    return this.delegate.hasSessionCredential()
-      && this.delegate.hasVerifiedUser()
-      && this.channelListeners.size > 0;
+    if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0)
+      return true;
+    return (
+      this.delegate.hasSessionCredential() &&
+      this.delegate.hasVerifiedUser() &&
+      (this.channelListeners.size > 0 ||
+        this.teamNotificationListeners.size > 0 ||
+        this.cloudEventListeners.size > 0)
+    );
   }
 
   private ensureSocket(): void {
@@ -447,7 +615,11 @@ export class CloudApiSocket {
       quoteTargets: this.quoteTargets.size,
       channelTargets: this.channelListeners.size,
     });
-    this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "connecting", this.getWebSocketBaseUrl());
+    this.health.reportSocketState(
+      GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+      "connecting",
+      this.getWebSocketBaseUrl(),
+    );
     let ws: WebSocket;
     try {
       ws = new WebSocket(url);
@@ -464,12 +636,17 @@ export class CloudApiSocket {
     ws.onopen = () => {
       if (this.ws !== ws) return;
       cloudApiLog.info("websocket open");
-      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "open", this.getWebSocketBaseUrl());
+      this.health.reportSocketState(
+        GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+        "open",
+        this.getWebSocketBaseUrl(),
+      );
       this.reconnectDelayMs = 1000;
       this.flushSubscriptions();
     };
 
     ws.onmessage = (event) => {
+      if (this.ws !== ws) return;
       void this.handleSocketMessage(String(event.data));
     };
 
@@ -490,11 +667,17 @@ export class CloudApiSocket {
       this.health.reportSocketState(
         GLOOM_CLOUD_SOCKET_CONNECTION_ID,
         "closed",
-        closeEvent?.reason || (closeEvent?.code ? `Closed (${closeEvent.code})` : "Socket closed"),
+        closeEvent?.reason ||
+          (closeEvent?.code ? `Closed (${closeEvent.code})` : "Socket closed"),
       );
-      if (usingWebSocketToken && this.delegate.clearWebSocketTokenForFallback()) {
+      if (
+        usingWebSocketToken &&
+        this.delegate.clearWebSocketTokenForFallback()
+      ) {
         this.reconnectDelayMs = 1000;
-        cloudApiLog.warn("cleared websocket token after socket close; falling back to session token");
+        cloudApiLog.warn(
+          "cleared websocket token after socket close; falling back to session token",
+        );
       }
       if (!this.shouldKeepSocketOpen()) return;
       this.scheduleReconnect();
@@ -502,7 +685,11 @@ export class CloudApiSocket {
 
     ws.onerror = () => {
       if (this.ws !== ws) return;
-      this.health.reportSocketState(GLOOM_CLOUD_SOCKET_CONNECTION_ID, "error", "WebSocket error");
+      this.health.reportSocketState(
+        GLOOM_CLOUD_SOCKET_CONNECTION_ID,
+        "error",
+        "WebSocket error",
+      );
       // Reconnect is handled by onclose.
     };
   }
@@ -519,15 +706,19 @@ export class CloudApiSocket {
 
   private sendSocketMessage(payload: unknown): void {
     if (this.ws?.readyState !== WebSocket.OPEN) return;
-    if (payload && typeof payload === "object" && "type" in (payload as Record<string, unknown>)) {
+    if (
+      payload &&
+      typeof payload === "object" &&
+      "type" in (payload as Record<string, unknown>)
+    ) {
       const type = (payload as Record<string, unknown>).type;
       if (
-        type === "market.subscribe"
-        || type === "market.unsubscribe"
-        || type === "chat.subscribe"
-        || type === "chat.unsubscribe"
-        || type === "scanner.subscribe"
-        || type === "scanner.unsubscribe"
+        type === "market.subscribe" ||
+        type === "market.unsubscribe" ||
+        type === "chat.subscribe" ||
+        type === "chat.unsubscribe" ||
+        type === "scanner.subscribe" ||
+        type === "scanner.unsubscribe"
       ) {
         cloudApiLog.info("send websocket message", payload);
       }
@@ -549,7 +740,9 @@ export class CloudApiSocket {
     if (this.quoteTargets.size > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: [...this.quoteTargets.values()].map((target) => this.serializeQuoteStreamTarget(target)),
+        symbols: [...this.quoteTargets.values()].map((target) =>
+          this.serializeQuoteStreamTarget(target),
+        ),
       });
     }
   }
@@ -593,18 +786,24 @@ export class CloudApiSocket {
     if (unsubscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.unsubscribe",
-        symbols: unsubscribes.map((target) => this.serializeQuoteStreamTarget(target)),
+        symbols: unsubscribes.map((target) =>
+          this.serializeQuoteStreamTarget(target),
+        ),
       });
     }
     if (subscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: subscribes.map((target) => this.serializeQuoteStreamTarget(target)),
+        symbols: subscribes.map((target) =>
+          this.serializeQuoteStreamTarget(target),
+        ),
       });
     }
   }
 
-  private serializeQuoteStreamTarget(target: QuoteStreamTarget): QuoteStreamTarget {
+  private serializeQuoteStreamTarget(
+    target: QuoteStreamTarget,
+  ): QuoteStreamTarget {
     return {
       symbol: target.symbol,
       exchange: target.exchange ?? "",
@@ -615,8 +814,13 @@ export class CloudApiSocket {
     };
   }
 
-  private areQuoteStreamTargetsEquivalent(left: QuoteStreamTarget, right: QuoteStreamTarget): boolean {
-    return JSON.stringify(this.serializeQuoteStreamTarget(left))
-      === JSON.stringify(this.serializeQuoteStreamTarget(right));
+  private areQuoteStreamTargetsEquivalent(
+    left: QuoteStreamTarget,
+    right: QuoteStreamTarget,
+  ): boolean {
+    return (
+      JSON.stringify(this.serializeQuoteStreamTarget(left)) ===
+      JSON.stringify(this.serializeQuoteStreamTarget(right))
+    );
   }
 }