gloomberb 0.10.1 → 0.10.2

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "gloomberb",
-  "version": "0.10.1",
+  "version": "0.10.2",
+  "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",
@@ -23,6 +24,11 @@
     "desktop:release": "electrobun build --env=stable",
     "desktop:release:windows": "electrobun build --env=stable --targets=win-x64",
     "i18n:audit": "bun run scripts/i18n-audit.ts",
+    "typecheck": "bun run typecheck:opentui && bun run typecheck:electrobun-bun && bun run typecheck:electrobun-view && bun run typecheck:scripts",
+    "typecheck:opentui": "tsc --project tsconfig.opentui.json",
+    "typecheck:electrobun-bun": "tsc --project tsconfig.electrobun-bun.json",
+    "typecheck:electrobun-view": "tsc --project tsconfig.electrobun-view.json",
+    "typecheck:scripts": "tsc --project tsconfig.scripts.json",
     "test": "bun test",
     "release": "./scripts/release.sh"
   },
@@ -41,6 +47,7 @@
   "devDependencies": {
     "@types/bun": "^1.3.14",
     "@types/react-dom": "^19.2.3",
+    "@types/three": "0.165.0",
     "electrobun": "^1.18.1",
     "png-to-ico": "^2.1.8",
     "rcedit": "^4.0.1"

package/src/api-client/auth.ts

@@ -38,6 +38,7 @@ export class CloudAuthApi {
       username: typeof user.username === "string" ? user.username : null,
       emailVerified: user.emailVerified === true,
       image: typeof user.image === "string" ? user.image : null,
+      plan: user.plan,
       syncEnabled: user.syncEnabled === false ? false : true,
       weeklyRoundupEnabled: user.weeklyRoundupEnabled === false ? false : true,
       positionAlertsEnabled: user.positionAlertsEnabled === false ? false : true,

package/src/api-client/index.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, jest, test } from "bun:test";
 import type { AuthUser } from "./index";
 import { apiClient, setCloudApiFetchTransport } from "./index";
 
@@ -37,6 +37,66 @@ function mockFetch(handler: (input: Request | string | URL, init?: RequestInit)
   return handler as unknown as typeof fetch;
 }
 
+class TestWebSocket {
+  readyState: number;
+  onopen: ((event: unknown) => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onclose: ((event: unknown) => void) | null = null;
+  onerror: ((event: unknown) => void) | null = null;
+  readonly sent: unknown[] = [];
+  closeCalls = 0;
+
+  constructor(
+    readonly url: string,
+    initialReadyState: number,
+  ) {
+    this.readyState = initialReadyState;
+  }
+
+  send(payload: string): void {
+    this.sent.push(JSON.parse(payload));
+  }
+
+  close(): void {
+    this.closeCalls += 1;
+    this.readyState = 3;
+  }
+
+  open(): void {
+    this.readyState = 1;
+    this.onopen?.({});
+  }
+
+  receive(payload: unknown): void {
+    this.onmessage?.({ data: JSON.stringify(payload) });
+  }
+
+  closeWith(event: { code: number; reason: string }): void {
+    this.readyState = 3;
+    this.onclose?.(event);
+  }
+}
+
+function installTestWebSocket(initialReadyState = 1): TestWebSocket[] {
+  const sockets: TestWebSocket[] = [];
+
+  class InstalledTestWebSocket extends TestWebSocket {
+    static readonly OPEN = 1;
+
+    constructor(url: string) {
+      super(url, initialReadyState);
+      sockets.push(this);
+    }
+  }
+
+  globalThis.WebSocket = InstalledTestWebSocket as unknown as typeof WebSocket;
+  return sockets;
+}
+
+function flushQuoteSubscriptionUpdates(): void {
+  jest.runAllTimers();
+}
+
 afterEach(() => {
   apiClient.dispose();
   globalThis.fetch = originalFetch;
@@ -44,6 +104,7 @@ afterEach(() => {
   setCloudApiFetchTransport(null);
   apiClient.setSessionToken(null);
   apiClient.setWebSocketToken(null);
+  jest.useRealTimers();
 });
 
 describe("apiClient auth cookies", () => {
@@ -164,36 +225,11 @@ describe("apiClient auth cookies", () => {
     expect(apiClient.getWebSocketToken()).toBeNull();
     expect(apiClient.getCurrentUser()).toBeNull();
   });
+});
 
+describe("apiClient quote socket", () => {
   test("drops a stale websocket token after socket close so reconnect can use the session token", () => {
-    const sockets: Array<{
-      url: string;
-      readyState: number;
-      onclose: ((event: unknown) => void) | null;
-      close: () => void;
-    }> = [];
-
-    class FakeWebSocket {
-      static OPEN = 1;
-      readyState = 0;
-      onopen: ((event: unknown) => void) | null = null;
-      onmessage: ((event: { data: string }) => void) | null = null;
-      onclose: ((event: unknown) => void) | null = null;
-      onerror: ((event: unknown) => void) | null = null;
-
-      constructor(readonly url: string) {
-        sockets.push(this);
-      }
-
-      send(): void {}
-
-      close(): void {
-        this.readyState = 3;
-        this.onclose?.({ code: 1000, reason: "closed" });
-      }
-    }
-
-    globalThis.WebSocket = FakeWebSocket as any;
+    const sockets = installTestWebSocket(0);
     apiClient.setSessionToken("session-token");
     apiClient.setWebSocketToken("stale-ws-token");
     apiClient.restoreCachedUser(verifiedUser);
@@ -203,7 +239,7 @@ describe("apiClient auth cookies", () => {
     expect(sockets).toHaveLength(1);
     expect(sockets[0]!.url).toContain("token=stale-ws-token");
 
-    sockets[0]!.onclose?.({ code: 1008, reason: "Unauthorized" });
+    sockets[0]!.closeWith({ code: 1008, reason: "Unauthorized" });
 
     expect(apiClient.getWebSocketToken()).toBeNull();
     expect(apiClient.getSessionToken()).toBe("session-token");
@@ -212,36 +248,7 @@ describe("apiClient auth cookies", () => {
   });
 
   test("opens an anonymous market websocket and sends quote priority hints", () => {
-    const sent: unknown[] = [];
-    const sockets: Array<{
-      url: string;
-      readyState: number;
-      onopen: ((event: unknown) => void) | null;
-      close: () => void;
-    }> = [];
-
-    class FakeWebSocket {
-      static OPEN = 1;
-      readyState = 1;
-      onopen: ((event: unknown) => void) | null = null;
-      onmessage: ((event: { data: string }) => void) | null = null;
-      onclose: ((event: unknown) => void) | null = null;
-      onerror: ((event: unknown) => void) | null = null;
-
-      constructor(readonly url: string) {
-        sockets.push(this);
-      }
-
-      send(payload: string): void {
-        sent.push(JSON.parse(payload));
-      }
-
-      close(): void {
-        this.readyState = 3;
-      }
-    }
-
-    globalThis.WebSocket = FakeWebSocket as any;
+    const sockets = installTestWebSocket();
 
     const unsubscribe = apiClient.subscribeQuotes([{
       symbol: "AAPL",
@@ -251,11 +258,11 @@ describe("apiClient auth cookies", () => {
       selected: true,
       weight: 100,
     }], () => {});
-    sockets[0]!.onopen?.({});
+    sockets[0]!.open();
 
     expect(sockets).toHaveLength(1);
     expect(sockets[0]!.url).toBe("wss://api.gloom.sh/cloud/ws");
-    expect(sent).toContainEqual({
+    expect(sockets[0]!.sent).toContainEqual({
       type: "market.subscribe",
       symbols: [{
         symbol: "AAPL",
@@ -270,62 +277,306 @@ describe("apiClient auth cookies", () => {
     unsubscribe();
   });
 
-  test("keeps an anonymous market websocket open after auth rejection", () => {
-    const seenPrices: number[] = [];
-    let closeCalls = 0;
-    const sockets: Array<{
-      readyState: number;
-      onopen: ((event: unknown) => void) | null;
-      onmessage: ((event: { data: string }) => void) | null;
-      close: () => void;
-    }> = [];
-
-    class FakeWebSocket {
-      static OPEN = 1;
-      readyState = 1;
-      onopen: ((event: unknown) => void) | null = null;
-      onmessage: ((event: { data: string }) => void) | null = null;
-      onclose: ((event: unknown) => void) | null = null;
-      onerror: ((event: unknown) => void) | null = null;
-
-      constructor(readonly _url: string) {
-        sockets.push(this);
-      }
+  test("reconnects and replays quote targets when market entitlement changes", () => {
+    const sockets = installTestWebSocket();
+    apiClient.setSessionToken("session-token");
+    apiClient.restoreCachedUser({ ...verifiedUser, plan: "free" });
+    const target = {
+      symbol: "AAPL260731C00110000",
+      exchange: "OPTIONS",
+      surface: "options" as const,
+      visible: true,
+    };
+    const unsubscribe = apiClient.subscribeQuotes([target], () => {});
+    sockets[0]!.open();
 
-      send(): void {}
+    apiClient.restoreCachedUser({ ...verifiedUser, plan: "pro" });
 
-      close(): void {
-        closeCalls += 1;
-        this.readyState = 3;
-      }
-    }
+    expect(sockets).toHaveLength(2);
+    expect(sockets[0]!.closeCalls).toBe(1);
+    expect(sockets[1]!.url).toContain("token=session-token");
+    sockets[1]!.open();
+    expect(sockets[1]!.sent).toContainEqual({
+      type: "market.subscribe",
+      symbols: [target],
+    });
+    unsubscribe();
+  });
+
+  test("serializes and dispatches compact OCC option quote targets", () => {
+    const sockets = installTestWebSocket();
+    const seen: Array<{ symbol: string; dataSource: string | undefined }> = [];
+    const unsubscribe = apiClient.subscribeQuotes(
+      [
+        {
+          symbol: "AAPL260731C00110000",
+          exchange: "OPTIONS",
+          surface: "options",
+          visible: true,
+          selected: true,
+          weight: 100,
+        },
+      ],
+      (target, quote) => {
+        seen.push({ symbol: target.symbol, dataSource: quote.dataSource });
+      },
+    );
+    const socket = sockets[0]!;
+    socket.open();
+
+    expect(socket.sent).toContainEqual({
+      type: "market.subscribe",
+      symbols: [
+        {
+          symbol: "AAPL260731C00110000",
+          exchange: "OPTIONS",
+          surface: "options",
+          visible: true,
+          selected: true,
+          weight: 100,
+        },
+      ],
+    });
+
+    socket.receive({
+      type: "market.quote",
+      symbol: "AAPL260731C00110000",
+      exchange: "OPTIONS",
+      quote: {
+        symbol: "AAPL260731C00110000",
+        providerId: "gloomberb-cloud",
+        price: 2.5,
+        currency: "USD",
+        change: 0,
+        changePercent: 0,
+        lastUpdated: 1_800_000_000_000,
+        dataSource: "live",
+      },
+    });
+
+    expect(seen).toEqual([
+      {
+        symbol: "AAPL260731C00110000",
+        dataSource: "live",
+      },
+    ]);
+    unsubscribe();
+  });
+
+  test("preserves quote delivery and stale metadata from websocket messages", () => {
+    const sockets = installTestWebSocket();
+    const seen: Array<{ delivery?: string; stale?: boolean }> = [];
+    const unsubscribe = apiClient.subscribeQuotes(
+      [{ symbol: "AAPL260731C00110000", exchange: "OPTIONS" }],
+      (_target, quote) => {
+        seen.push({ delivery: quote.delivery, stale: quote.stale });
+      },
+    );
+    const socket = sockets[0]!;
+    socket.open();
+
+    socket.receive({
+      type: "market.quote",
+      symbol: "AAPL260731C00110000",
+      exchange: "OPTIONS",
+      delivery: "poll",
+      stale: true,
+      quote: {
+        symbol: "AAPL260731C00110000",
+        providerId: "gloomberb-cloud",
+        price: 2.5,
+        currency: "USD",
+        change: 0,
+        changePercent: 0,
+        lastUpdated: 1_800_000_000_000,
+        dataSource: "live",
+      },
+    });
+
+    expect(seen).toEqual([{ delivery: "poll", stale: true }]);
+    unsubscribe();
+  });
+
+  test("does not invent quote priority hints when opening a socket", () => {
+    const sockets = installTestWebSocket();
+
+    const unsubscribe = apiClient.subscribeQuotes([{ symbol: "AAPL", exchange: "NASDAQ" }], () => {});
+    sockets[0]!.open();
+
+    expect(sockets[0]!.sent).toContainEqual({
+      type: "market.subscribe",
+      symbols: [{ symbol: "AAPL", exchange: "NASDAQ" }],
+    });
 
-    globalThis.WebSocket = FakeWebSocket as any;
+    unsubscribe();
+  });
+
+  test("recomputes quote priority when overlapping subscriptions are removed", () => {
+    jest.useFakeTimers();
+    const sockets = installTestWebSocket();
+    const deliveredSurfaces: string[] = [];
+    const unsubscribeInline = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "inline",
+      weight: 1,
+    }], (target) => {
+      deliveredSurfaces.push(target.surface ?? "unknown");
+    });
+    const socket = sockets[0]!;
+    socket.open();
+    flushQuoteSubscriptionUpdates();
+    socket.sent.length = 0;
+
+    const unsubscribeDetail = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "detail",
+      visible: true,
+      selected: true,
+      weight: 50,
+    }], (target) => {
+      deliveredSurfaces.push(target.surface ?? "unknown");
+    });
+    flushQuoteSubscriptionUpdates();
+
+    expect(socket.sent.at(-1)).toEqual({
+      type: "market.subscribe",
+      symbols: [{
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        surface: "detail",
+        visible: true,
+        selected: true,
+        weight: 50,
+      }],
+    });
+
+    socket.receive({
+      type: "market.quote",
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      quote: { symbol: "AAPL", price: 123 },
+    });
+    expect(deliveredSurfaces).toEqual(["inline", "detail"]);
+
+    unsubscribeDetail();
+    flushQuoteSubscriptionUpdates();
+    expect(socket.sent.at(-1)).toEqual({
+      type: "market.subscribe",
+      symbols: [{
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        surface: "inline",
+        weight: 1,
+      }],
+    });
+
+    unsubscribeInline();
+  });
+
+  test("unsubscribes a server-side quote when queued priority updates are removed", () => {
+    jest.useFakeTimers();
+    const sockets = installTestWebSocket();
+    const unsubscribeMsft = apiClient.subscribeQuotes([{ symbol: "MSFT", exchange: "NASDAQ" }], () => {});
+    const socket = sockets[0]!;
+    socket.open();
+    flushQuoteSubscriptionUpdates();
+
+    const unsubscribeInline = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "inline",
+      weight: 1,
+    }], () => {});
+    flushQuoteSubscriptionUpdates();
+    expect(socket.sent.at(-1)).toEqual({
+      type: "market.subscribe",
+      symbols: [{ symbol: "AAPL", exchange: "NASDAQ", surface: "inline", weight: 1 }],
+    });
+
+    socket.sent.length = 0;
+    const unsubscribeDetail = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "detail",
+      visible: true,
+      selected: true,
+      weight: 50,
+    }], () => {});
+    unsubscribeDetail();
+    unsubscribeInline();
+    flushQuoteSubscriptionUpdates();
+
+    expect(socket.sent).toEqual([{
+      type: "market.unsubscribe",
+      symbols: [{ symbol: "AAPL", exchange: "NASDAQ", surface: "inline", weight: 1 }],
+    }]);
+    unsubscribeMsft();
+  });
+
+  test("unsubscribes removed quote targets before subscribing replacements", () => {
+    jest.useFakeTimers();
+    const sockets = installTestWebSocket();
+    const oldTargets = Array.from({ length: 16 }, (_, index) => ({
+      symbol: `OPT${index}`,
+      exchange: "OPTIONS",
+    }));
+    const newTargets = Array.from({ length: 16 }, (_, index) => ({
+      symbol: `OPT${index + 2}`,
+      exchange: "OPTIONS",
+    }));
+    const unsubscribeOld = apiClient.subscribeQuotes(oldTargets, () => {});
+    const socket = sockets[0]!;
+    socket.open();
+    flushQuoteSubscriptionUpdates();
+    socket.sent.length = 0;
+
+    const unsubscribeNew = apiClient.subscribeQuotes(newTargets, () => {});
+    unsubscribeOld();
+    flushQuoteSubscriptionUpdates();
+
+    expect(socket.sent.map((message) => (message as { type: string }).type)).toEqual([
+      "market.unsubscribe",
+      "market.subscribe",
+    ]);
+    expect(socket.sent[0]).toMatchObject({
+      symbols: [{ symbol: "OPT0" }, { symbol: "OPT1" }],
+    });
+    expect(socket.sent[1]).toMatchObject({
+      symbols: [{ symbol: "OPT16" }, { symbol: "OPT17" }],
+    });
+
+    unsubscribeNew();
+  });
+
+  test("keeps an anonymous market websocket open after auth rejection", () => {
+    const seenPrices: number[] = [];
+    const sockets = installTestWebSocket();
 
     const unsubscribe = apiClient.subscribeQuotes([{ symbol: "AAPL" }], (_target, quote) => {
       seenPrices.push(quote.price);
     });
-    sockets[0]!.onopen?.({});
-    sockets[0]!.onmessage?.({ data: JSON.stringify({ type: "auth.unverified" }) });
-    sockets[0]!.onmessage?.({
-      data: JSON.stringify({
-        type: "market.quote",
+    const socket = sockets[0]!;
+    socket.open();
+    socket.receive({ type: "auth.unverified" });
+    socket.receive({
+      type: "market.quote",
+      symbol: "AAPL",
+      exchange: "",
+      quote: {
         symbol: "AAPL",
-        exchange: "",
-        quote: {
-          symbol: "AAPL",
-          price: 123,
-          currency: "USD",
-          change: 0,
-          changePercent: 0,
-          lastUpdated: 1,
-          providerId: "gloomberb-cloud",
-          dataSource: "live",
-        },
-      }),
+        price: 123,
+        currency: "USD",
+        change: 0,
+        changePercent: 0,
+        lastUpdated: 1,
+        providerId: "gloomberb-cloud",
+        dataSource: "live",
+      },
     });
 
-    expect(closeCalls).toBe(0);
+    expect(socket.closeCalls).toBe(0);
     expect(seenPrices).toEqual([123]);
 
     unsubscribe();

package/src/api-client/index.ts

@@ -70,11 +70,7 @@ class GloomApiClient {
       requireCapturedSession: (message) => this.requireCapturedSession(message),
       setCurrentUser: (user) => this.setCurrentUser(user),
       setSessionToken: (token) => this.setSessionToken(token),
-      updateCurrentUser: (updater) => {
-        if (this.currentUser) {
-          this.currentUser = updater(this.currentUser);
-        }
-      },
+      updateCurrentUser: (updater) => this.updateCurrentUser(updater),
     });
     this.socket = new CloudApiSocket({
       getBaseUrl: () => this.transport.baseUrl,
@@ -88,10 +84,10 @@ class GloomApiClient {
         }
       },
       updateCurrentUserFromSocket: (user) => {
-        this.currentUser = {
-          ...(this.currentUser ?? {}),
+        this.updateCurrentUser((currentUser) => ({
+          ...currentUser,
           ...user,
-        } as AuthUser;
+        }));
       },
     });
     this.chat = new CloudChatApi({
@@ -110,18 +106,18 @@ class GloomApiClient {
   }
 
   setSessionToken(token: string | null): void {
+    const changed = this.transport.getSessionToken() !== token;
     this.transport.setSessionToken(token);
     if (!token) {
       this.currentUser = null;
-      this.socket.teardown();
     }
+    this.socket.syncAuthState({ reconnect: changed });
   }
 
   setWebSocketToken(token: string | null): void {
+    const changed = this.transport.getWebSocketToken() !== token;
     this.transport.setWebSocketToken(token);
-    if (!token) {
-      this.socket.teardown();
-    }
+    this.socket.syncAuthState({ reconnect: changed });
   }
 
   getCurrentUser(): AuthUser | null {
@@ -137,8 +133,23 @@ class GloomApiClient {
   }
 
   private setCurrentUser(user: AuthUser | null): void {
+    const changed = this.socketEntitlementKey(this.currentUser) !== this.socketEntitlementKey(user);
     this.currentUser = user;
-    this.socket.syncAuthState();
+    this.socket.syncAuthState({ reconnect: changed });
+  }
+
+  private updateCurrentUser(updater: (user: AuthUser) => AuthUser): void {
+    if (!this.currentUser) return;
+    this.setCurrentUser(updater(this.currentUser));
+  }
+
+  private socketEntitlementKey(user: AuthUser | null): string {
+    if (!user) return "anonymous";
+    return [
+      user.id,
+      user.emailVerified === true ? "verified" : "unverified",
+      user.plan,
+    ].join(":");
   }
 
   private requireCapturedSession(message: string): void {