gloomberb 0.9.7 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/api-client/auth.ts

@@ -38,6 +38,11 @@ export class CloudAuthApi {
       username: typeof user.username === "string" ? user.username : null,
       emailVerified: user.emailVerified === true,
       image: typeof user.image === "string" ? user.image : null,
+      syncEnabled: user.syncEnabled === false ? false : true,
+      weeklyRoundupEnabled: user.weeklyRoundupEnabled === false ? false : true,
+      positionAlertsEnabled: user.positionAlertsEnabled === false ? false : true,
+      lastSyncAt: typeof user.lastSyncAt === "string" ? user.lastSyncAt : null,
+      lastRoundupEmailAt: typeof user.lastRoundupEmailAt === "string" ? user.lastRoundupEmailAt : null,
       createdAt: typeof user.createdAt === "string" ? user.createdAt : "",
       updatedAt: typeof user.updatedAt === "string" ? user.updatedAt : "",
     });
@@ -148,6 +153,12 @@ export class CloudAuthApi {
         xAccount: profile.xAccount,
         sharedPortfolioId: profile.sharedPortfolioId,
         acceptUnknownDms: profile.acceptUnknownDms,
+        portfolioAnalytics: profile.portfolioAnalytics,
+        syncEnabled: profile.syncEnabled,
+        weeklyRoundupEnabled: profile.weeklyRoundupEnabled,
+        positionAlertsEnabled: profile.positionAlertsEnabled,
+        lastSyncAt: profile.lastSyncAt,
+        lastRoundupEmailAt: profile.lastRoundupEmailAt,
         updatedAt: profile.updatedAt ?? currentUser.updatedAt,
       }));
     }
@@ -164,4 +175,13 @@ export class CloudAuthApi {
       }),
     });
   }
+
+  async deleteAccount(): Promise<void> {
+    await this.options.request("/account", {
+      method: "DELETE",
+      body: JSON.stringify({}),
+    });
+    this.options.setSessionToken(null);
+    this.options.setCurrentUser(null);
+  }
 }

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

@@ -415,7 +415,7 @@ describe("apiClient chat timestamps", () => {
       seenCreatedAts.push(message.createdAt);
     });
 
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.message",
       channelId: "everyone",
       data: {
@@ -531,11 +531,11 @@ describe("apiClient chat timestamps", () => {
       seenNotifications.push(`${notification.id}:${notification.message.createdAt}`);
     });
 
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.presence",
       onlineCount: 5,
     }));
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.notification",
       data: {
         id: "n1",

package/src/api-client/index.ts

@@ -39,15 +39,17 @@ import type {
   CloudCongressHousePayload,
   CloudNewsPayload,
   CloudNewsListResponse,
-  CloudTweetPayload,
-  CloudTweetQueryType,
   CloudTweetSearchResponse,
   CloudMarketResponse,
   CloudMarketBatchTarget,
   CloudMarketBatchPayload,
   CloudVerificationResponse,
+  CloudRoundupPreviewResponse,
+  CloudSyncPushResponse,
+  CloudSyncSnapshotResponse,
   QuoteStreamTarget,
 } from "./types";
+import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
 export type * from "./types";
 export { setCloudApiFetchTransport } from "./request";
@@ -154,10 +156,6 @@ class GloomApiClient {
     return this.transport.getSocketAuthToken();
   }
 
-  private async handleSocketMessage(raw: string): Promise<void> {
-    await this.socket.handleSocketMessage(raw);
-  }
-
   async ensureVerifiedSession(): Promise<AuthUser | null> {
     return this.auth.ensureVerifiedSession();
   }
@@ -198,10 +196,54 @@ class GloomApiClient {
     return this.auth.updateAccountProfile(update);
   }
 
+  async getSyncSnapshot(): Promise<CloudSyncSnapshotResponse> {
+    return this.request<CloudSyncSnapshotResponse>("/sync/snapshot", { method: "GET" });
+  }
+
+  async putSyncSnapshot(snapshot: SyncSnapshot, options?: { baseRevision?: number | null }): Promise<CloudSyncPushResponse> {
+    return this.request<CloudSyncPushResponse>("/sync/snapshot", {
+      method: "PUT",
+      body: JSON.stringify({
+        snapshot,
+        baseRevision: options?.baseRevision ?? null,
+      }),
+    });
+  }
+
+  async updateSyncSettings(update: Partial<SyncSettings>): Promise<SyncSettings> {
+    const result = await this.request<{ settings: SyncSettings }>("/sync/settings", {
+      method: "PATCH",
+      body: JSON.stringify(update),
+    });
+    if (this.currentUser) {
+      this.currentUser = {
+        ...this.currentUser,
+        syncEnabled: result.settings.syncEnabled,
+        weeklyRoundupEnabled: result.settings.weeklyRoundupEnabled,
+        positionAlertsEnabled: result.settings.positionAlertsEnabled,
+        lastSyncAt: result.settings.lastSyncAt ?? this.currentUser.lastSyncAt,
+        lastRoundupEmailAt: result.settings.lastRoundupEmailAt ?? this.currentUser.lastRoundupEmailAt,
+      };
+    }
+    return result.settings;
+  }
+
+  async getRoundupPreview(): Promise<CloudRoundupPreviewResponse> {
+    return this.request<CloudRoundupPreviewResponse>("/sync/roundup/preview", { method: "POST", body: JSON.stringify({}) });
+  }
+
+  async sendRoundupTestEmail(): Promise<CloudRoundupPreviewResponse> {
+    return this.request<CloudRoundupPreviewResponse>("/sync/roundup/test-email", { method: "POST", body: JSON.stringify({}) });
+  }
+
   async changePassword(currentPassword: string, newPassword: string): Promise<void> {
     return this.auth.changePassword(currentPassword, newPassword);
   }
 
+  async deleteAccount(): Promise<void> {
+    return this.auth.deleteAccount();
+  }
+
   async getChannels(): Promise<ChatChannel[]> {
     return this.chat.getChannels();
   }

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

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { CloudApiRequestTransport } from "./request";
+
+function responseWithBody(body: () => Promise<string>): Response {
+  return {
+    ok: true,
+    status: 200,
+    headers: new Headers(),
+    text: body,
+  } as Response;
+}
+
+describe("CloudApiRequestTransport market deadlines", () => {
+  test("aborts when response headers never arrive", async () => {
+    let signal: AbortSignal | null | undefined;
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 10,
+      fetchTransport: async (_url, init) => {
+        signal = init?.signal;
+        return new Promise<Response>(() => {});
+      },
+    });
+
+    await expect(transport.request("/market/quote?symbol=AAPL")).rejects.toThrow(
+      "Cloud market request timed out after 10ms",
+    );
+    expect(signal?.aborted).toBe(true);
+  });
+
+  test("keeps the deadline active while reading the response body", async () => {
+    let signal: AbortSignal | null | undefined;
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 10,
+      fetchTransport: async (_url, init) => {
+        signal = init?.signal;
+        return responseWithBody(async () => new Promise<string>(() => {}));
+      },
+    });
+
+    await expect(transport.request("/market/history?symbol=AAPL")).rejects.toThrow(
+      "Cloud market request timed out after 10ms",
+    );
+    expect(signal?.aborted).toBe(true);
+  });
+
+  test("preserves a caller abort instead of replacing it with the market deadline", async () => {
+    let fetchCalls = 0;
+    const controller = new AbortController();
+    controller.abort(new Error("cancelled by caller"));
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 100,
+      fetchTransport: async () => {
+        fetchCalls += 1;
+        return responseWithBody(async () => "{}");
+      },
+    });
+
+    await expect(transport.request("/market/quote?symbol=AAPL", {
+      signal: controller.signal,
+    })).rejects.toThrow("cancelled by caller");
+    expect(fetchCalls).toBe(0);
+  });
+});

package/src/api-client/request.ts

@@ -1,7 +1,9 @@
 import { httpFetch } from "../utils/http-transport";
+import { withDeadline } from "../utils/async-deadline";
 import { ApiRequestError, parseApiErrorMessage } from "./errors";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
+const DEFAULT_MARKET_REQUEST_TIMEOUT_MS = 10_000;
 const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
 
 type CloudApiResponse = Pick<Response, "ok" | "status" | "headers" | "text">;
@@ -21,13 +23,28 @@ function getCloudApiBaseUrl(): string {
   return process.env.GLOOMBERB_API_URL ?? DEFAULT_API_URL;
 }
 
+function throwIfRequestAborted(signal: AbortSignal | null | undefined): void {
+  if (!signal?.aborted) return;
+  throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+
 export class CloudApiRequestTransport {
   private sessionToken: string | null = null;
   private sessionCookieName: SessionCookieName | null = null;
   private websocketToken: string | null = null;
+  private readonly fetchTransport: CloudApiFetchTransport | null;
+  private readonly marketRequestTimeoutMs: number;
 
   readonly baseUrl = getCloudApiBaseUrl();
 
+  constructor(options: {
+    fetchTransport?: CloudApiFetchTransport;
+    marketRequestTimeoutMs?: number;
+  } = {}) {
+    this.fetchTransport = options.fetchTransport ?? null;
+    this.marketRequestTimeoutMs = options.marketRequestTimeoutMs ?? DEFAULT_MARKET_REQUEST_TIMEOUT_MS;
+  }
+
   getSessionToken(): string | null {
     return this.sessionToken;
   }
@@ -61,6 +78,37 @@ export class CloudApiRequestTransport {
   }
 
   async request<T>(path: string, options?: RequestInit): Promise<T> {
+    if (!path.startsWith("/market/")) {
+      return this.performRequest<T>(path, options);
+    }
+
+    const controller = new AbortController();
+    const callerSignal = options?.signal;
+    const abortFromCaller = () => controller.abort(callerSignal?.reason);
+    if (callerSignal?.aborted) {
+      abortFromCaller();
+    } else {
+      callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
+    }
+
+    try {
+      const request = this.performRequest<T>(path, {
+        ...options,
+        signal: controller.signal,
+      });
+      return await withDeadline(
+        request,
+        this.marketRequestTimeoutMs,
+        `Cloud market request timed out after ${this.marketRequestTimeoutMs}ms: ${path}`,
+        (error) => controller.abort(error),
+      );
+    } finally {
+      callerSignal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+
+  private async performRequest<T>(path: string, options?: RequestInit): Promise<T> {
+    throwIfRequestAborted(options?.signal);
     const headers = new Headers(options?.headers);
     if (!headers.has("Content-Type") && options?.method && options.method !== "GET") {
       headers.set("Content-Type", "application/json");
@@ -68,21 +116,21 @@ export class CloudApiRequestTransport {
     this.setSessionCookieHeader(headers);
     headers.set("Origin", this.baseUrl);
 
-    const res = await cloudApiFetchTransport(`${this.baseUrl}${path}`, {
+    const res = await (this.fetchTransport ?? cloudApiFetchTransport)(`${this.baseUrl}${path}`, {
       ...options,
       headers,
       credentials: "include",
     });
-
+    throwIfRequestAborted(options?.signal);
     this.extractSessionCookie(res);
+    const text = await res.text();
+    throwIfRequestAborted(options?.signal);
 
     if (!res.ok) {
-      const body = await res.text();
-      const msg = parseApiErrorMessage(body);
+      const msg = parseApiErrorMessage(text);
       throw new ApiRequestError(msg, res.status);
     }
 
-    const text = await res.text();
     if (!text) return undefined as T;
     const parsed = JSON.parse(text) as T & { token?: string };
     if (typeof parsed?.token === "string" && parsed.token.length > 0) {

package/src/api-client/types.ts

@@ -6,10 +6,9 @@ import type {
   HolderData,
   HolderRecord,
   OptionsChain,
-  PricePoint,
   Quote,
-  TickerFinancials,
 } from "../types/financials";
+import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
 export interface ChatUserSummary {
   id: string;
@@ -20,6 +19,7 @@ export interface ChatUserSummary {
   title?: string | null;
   profilePublic?: boolean;
   acceptUnknownDms?: boolean;
+  portfolioAnalytics?: PublicPortfolioAnalytics | null;
 }
 
 export interface ChatMessage {
@@ -83,6 +83,12 @@ export interface AuthUser {
   xAccount?: string | null;
   sharedPortfolioId?: string | null;
   acceptUnknownDms?: boolean;
+  portfolioAnalytics?: PublicPortfolioAnalytics | null;
+  syncEnabled?: boolean;
+  weeklyRoundupEnabled?: boolean;
+  positionAlertsEnabled?: boolean;
+  lastSyncAt?: string | null;
+  lastRoundupEmailAt?: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -104,9 +110,20 @@ export interface AccountProfile {
   xAccount: string | null;
   sharedPortfolioId: string | null;
   acceptUnknownDms: boolean;
+  portfolioAnalytics?: PublicPortfolioAnalytics | null;
+  syncEnabled: boolean;
+  weeklyRoundupEnabled: boolean;
+  positionAlertsEnabled: boolean;
+  lastSyncAt: string | null;
+  lastRoundupEmailAt: string | null;
   updatedAt: string | null;
 }
 
+export interface PublicPortfolioAnalytics {
+  oneYearReturn?: number | null;
+  spyBeta?: number | null;
+}
+
 export interface BuildoutAccountResponse {
   user: {
     id: string;
@@ -151,8 +168,34 @@ export type AccountProfileUpdate = Partial<{
   xAccount: string | null;
   sharedPortfolioId: string | null;
   acceptUnknownDms: boolean;
+  portfolioAnalytics: PublicPortfolioAnalytics | null;
+  syncEnabled: boolean;
+  weeklyRoundupEnabled: boolean;
+  positionAlertsEnabled: boolean;
 }>;
 
+export interface CloudSyncSnapshotResponse {
+  snapshot: SyncSnapshot | null;
+  revision: number | null;
+  updatedAt: string | null;
+  settings: SyncSettings;
+}
+
+export interface CloudSyncPushResponse {
+  revision: number;
+  updatedAt: string;
+  settings: SyncSettings;
+}
+
+export interface CloudRoundupPreviewResponse {
+  subject: string;
+  text: string;
+  html: string;
+  sender: string;
+  replyTo: string;
+  recipient: string;
+}
+
 export interface CloudQuotePayload extends Quote {
   providerId: "gloomberb-cloud";
   dataSource: "live" | "delayed";

package/src/app/pane-runtime/layout-placement.ts

@@ -1,6 +1,5 @@
 import type { PluginRegistry } from "../../plugins/registry";
 import {
-  findDockLeaf,
   getDockLeafLayouts,
   getLeafRect,
 } from "../../plugins/pane-manager";

package/src/app/runtime/desktop-deeplink.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+import { resolveDesktopDeepLinkAction } from "./desktop-deeplink";
+
+describe("desktop deeplinks", () => {
+  test("routes cloud roundup links to account management", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://cloud/roundup?week=2026-07-03")).toEqual({
+      type: "open-account-management",
+      route: { kind: "cloud-roundup", week: "2026-07-03" },
+      message: "Opened weekly roundup settings for 2026-07-03.",
+    });
+  });
+
+  test("routes cloud alert links to account management", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://cloud/alerts")).toEqual({
+      type: "open-account-management",
+      route: { kind: "cloud-alerts", week: null },
+      message: "Opened portfolio alert settings.",
+    });
+  });
+
+  test("routes ticker links with arbitrary registered tab ids", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://ticker/NVDA?tab=analyst-research")).toEqual({
+      type: "open-ticker",
+      symbol: "NVDA",
+      tabId: "analyst-research",
+      message: "Opened NVDA analyst-research tab.",
+    });
+  });
+
+  test("routes portfolio and watchlist links", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://portfolio/main")).toEqual({
+      type: "open-collection",
+      kind: "portfolio",
+      collectionId: "main",
+      message: "Opened portfolio main.",
+    });
+    expect(resolveDesktopDeepLinkAction("gloomberb://watchlist/favorites")).toEqual({
+      type: "open-collection",
+      kind: "watchlist",
+      collectionId: "favorites",
+      message: "Opened watchlist favorites.",
+    });
+  });
+
+  test("routes alert links with structured values", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://alert/new?symbol=nvda&side=above&price=$200")).toEqual({
+      type: "create-alert",
+      values: { symbol: "NVDA", condition: "above", price: "200" },
+      message: "Created NVDA above 200 alert.",
+    });
+  });
+
+  test("routes chat links", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://chat/channel/everyone")).toEqual({
+      type: "open-chat-channel",
+      channelId: "everyone",
+      message: "Opened chat everyone.",
+    });
+    expect(resolveDesktopDeepLinkAction("gloomberb://chat/dm?users=@vince,@alex")).toEqual({
+      type: "open-chat-dm",
+      participants: "@vince,@alex",
+      message: "Opened DM.",
+    });
+  });
+
+  test("routes news links", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://news?ticker=7203.T")).toEqual({
+      type: "open-news",
+      kind: "ticker",
+      symbol: "7203.T",
+      message: "Opened 7203.T news.",
+    });
+    expect(resolveDesktopDeepLinkAction("gloomberb://news/breaking")).toEqual({
+      type: "open-news",
+      kind: "breaking",
+      symbol: null,
+      message: "Opened breaking news.",
+    });
+  });
+
+  test("rejects command-bar, non-gloomberb, and malformed links", () => {
+    expect(resolveDesktopDeepLinkAction("gloomberb://command?query=profile").type).toBe("unsupported");
+    expect(resolveDesktopDeepLinkAction("gloomberb://search/NVDA").type).toBe("unsupported");
+    expect(resolveDesktopDeepLinkAction("https://gloom.sh/cloud").type).toBe("unsupported");
+    expect(resolveDesktopDeepLinkAction("not a url").type).toBe("unsupported");
+  });
+});