gloomberb 0.3.2 → 0.3.7

package/src/plugins/prediction-markets/pane.test.tsx

@@ -90,7 +90,8 @@ describe("prediction markets pane interactions", () => {
     await flushFrames(testSetup);
 
     let frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Prediction Markets");
+    expect(frame).toContain("All venues");
+    expect(frame).not.toContain("VOL = native venue units");
     expect(frame).toContain("Will inflation fall?");
     expect(frame).toContain("Kalshi");
 
@@ -117,6 +118,45 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("Kalshi primary rule");
   });
 
+  test("loads selected detail once instead of refetching in a render loop", async () => {
+    const { fetchUrls } = installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const kalshiRow = lines.findIndex((line) =>
+      line.includes("Will the Fed cut rates?"),
+    );
+    const kalshiCol = lines[kalshiRow]?.indexOf("Will the Fed cut rates?") ?? -1;
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 8);
+
+    const eventFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/events/FED-1"),
+    );
+    const orderbookFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/KAL-1/orderbook"),
+    );
+    const tradeFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/trades?ticker=KAL-1"),
+    );
+    const historyFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/series/FED/markets/KAL-1/candlesticks"),
+    );
+
+    expect(eventFetches).toHaveLength(2);
+    expect(orderbookFetches).toHaveLength(1);
+    expect(tradeFetches).toHaveLength(1);
+    expect(historyFetches).toHaveLength(1);
+    expect(testSetup.captureCharFrame()).not.toContain("Loading market detail...");
+  });
+
   test("moves selection through the list with keyboard navigation", async () => {
     installPredictionMarketMocks();
 

package/src/plugins/prediction-markets/pane.tsx

@@ -1,16 +1,14 @@
 import { useRef } from "react";
 import { TextAttributes, type BoxRenderable } from "@opentui/core";
-import { Spinner, TabBar } from "../../components";
+import { TabBar } from "../../components";
 import { usePredictionMarketsController } from "./controller";
 import { PredictionMarketDetailPane } from "./detail/pane";
 import { BROWSE_TABS, VENUE_TABS } from "./navigation";
 import { PredictionMarketsTable } from "./table";
-import { formatPredictionTransportBadge } from "./status";
 import { PREDICTION_CATEGORY_OPTIONS } from "./categories";
 import type { PredictionBrowseTab, PredictionCategoryId } from "./types";
 import type { PaneProps } from "../../types/plugin";
 import { colors } from "../../theme/colors";
-import { formatTimeAgo } from "../../utils/format";
 
 function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
@@ -22,12 +20,6 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
   const splitDragRef = useRef<{ startX: number; startRatio: number } | null>(
     null,
   );
-  const statusBadge = formatPredictionTransportBadge(
-    controller.catalogLoadCount > 0 || controller.detailLoadCount > 0
-      ? "loading"
-      : controller.transportState,
-  );
-  const showSummaryUnitsHint = controller.effectiveVenueScope === "all";
   const minTableWidth = 44;
   const minDetailWidth = 36;
   const effectiveMinTableWidth = controller.selectedSummary
@@ -108,28 +100,6 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
       backgroundColor={colors.panel}
       onMouse={handlePaneMouse}
     >
-      {!controller.paneSettings.hideHeader && (
-        <box flexDirection="row" height={1} paddingX={1}>
-          <text fg={colors.textBright} attributes={TextAttributes.BOLD}>
-            Prediction Markets
-          </text>
-          <box flexGrow={1} />
-          {showSummaryUnitsHint && (
-            <text fg={colors.textDim}>VOL = native venue units</text>
-          )}
-          <box width={1} />
-          {controller.searchLoading && <Spinner />}
-          {controller.searchLoading && <box width={1} />}
-          <text fg={statusBadge.color}>{statusBadge.label}</text>
-          <box width={1} />
-          <text fg={colors.textDim}>
-            {controller.lastRefreshAt
-              ? `refresh ${formatTimeAgo(new Date(controller.lastRefreshAt))}`
-              : "waiting"}
-          </text>
-        </box>
-      )}
-
       {!controller.paneSettings.hideTabs && (
         <TabBar
           tabs={VENUE_TABS.map((tab) => ({

package/src/sources/provider-router.test.ts

@@ -1355,6 +1355,49 @@ describe("ProviderRouter", () => {
     expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
   });
 
+  test("ignores poisoned cached chart history and refetches clean data", async () => {
+    const dbPath = createTempDbPath("poisoned-chart-cache");
+    const persistence = new AppPersistence(dbPath);
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "price-history",
+        entityKey: "AAPL",
+        variantKey: "exchange=NASDAQ;range=1Y",
+        sourceKey: "provider:yahoo",
+      },
+      [
+        { date: null as any, close: 101 },
+        { date: null as any, close: 102 },
+      ],
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+      },
+    );
+
+    let providerCalls = 0;
+    const router = new ProviderRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getPriceHistory() {
+        providerCalls += 1;
+        return [
+          { date: new Date("2026-03-27T00:00:00Z"), close: 201 },
+          { date: new Date("2026-03-28T00:00:00Z"), close: 202 },
+        ];
+      },
+    }, [], persistence.resources);
+
+    const history = await router.getPriceHistory("AAPL", "NASDAQ", "1Y");
+
+    expect(providerCalls).toBe(1);
+    expect(history.map((point) => point.close)).toEqual([201, 202]);
+
+    persistence.close();
+  });
+
   test("bypasses cached financials on explicit refresh requests", async () => {
     const dbPath = createTempDbPath("forced-financial-refresh");
     const persistence = new AppPersistence(dbPath);

package/src/sources/provider-router.ts

@@ -483,9 +483,10 @@ export class ProviderRouter implements DataProvider {
       ...this.getProviderSourceKeys(),
     ];
     const cached = this.selectCachedArrayResource<PricePoint>("price-history", entityKey, variantKeys, sourceKeys, false);
+    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale) {
+      return cachedValue;
     }
 
     const brokerHistory = await withBrokerTimeout(this.fetchBrokerPriceHistory(ticker, exchange, range, context));
@@ -495,7 +496,7 @@ export class ProviderRouter implements DataProvider {
     if (providerHistory && providerHistory.value.length > 0) {
       return providerHistory.value;
     }
-    if (cached) return cached.value;
+    if (cachedValue.length > 0) return cachedValue;
     if (!providerHistory) {
       throw new Error(`No history provider available for ${ticker}`);
     }
@@ -520,9 +521,10 @@ export class ProviderRouter implements DataProvider {
       ...this.getProviderSourceKeys(),
     ];
     const cached = this.selectCachedArrayResource<PricePoint>("detailed-price-history", entityKey, variantKeys, sourceKeys, false);
+    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale) {
+      return cachedValue;
     }
 
     const brokerResult = await withBrokerTimeout(this.fetchBrokerDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context));
@@ -532,7 +534,7 @@ export class ProviderRouter implements DataProvider {
     if (providerResult && providerResult.value.length > 0) {
       return providerResult.value;
     }
-    return cached?.value ?? providerResult?.value ?? [];
+    return cachedValue.length > 0 ? cachedValue : (providerResult?.value ?? []);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {

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

@@ -0,0 +1,86 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { AuthUser } from "./api-client";
+import { apiClient } from "./api-client";
+
+const originalFetch = globalThis.fetch;
+
+const verifiedUser: AuthUser = {
+  id: "user-1",
+  name: "Test User",
+  email: "test@example.com",
+  username: "test",
+  emailVerified: true,
+  image: null,
+  createdAt: "2026-03-30T00:00:00.000Z",
+  updatedAt: "2026-03-30T00:00:00.000Z",
+};
+
+function createResponse(body: unknown, options: { status?: number; cookies?: string[] } = {}): Response {
+  const headers = {
+    getSetCookie: () => options.cookies ?? [],
+    get: (name: string) => {
+      if (name.toLowerCase() !== "set-cookie") return null;
+      return options.cookies?.[0] ?? null;
+    },
+  } as Headers;
+
+  return {
+    ok: (options.status ?? 200) >= 200 && (options.status ?? 200) < 300,
+    status: options.status ?? 200,
+    headers,
+    text: async () => JSON.stringify(body),
+  } as Response;
+}
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  apiClient.setSessionToken(null);
+  apiClient.setWebSocketToken(null);
+});
+
+describe("apiClient auth cookies", () => {
+  test("captures secure session cookies after login and reuses them on session refresh", async () => {
+    const seenCookies: Array<string | null> = [];
+
+    globalThis.fetch = (async (_input: Request | string | URL, init?: RequestInit) => {
+      const headers = new Headers(init?.headers);
+      seenCookies.push(headers.get("Cookie"));
+
+      if (seenCookies.length === 1) {
+        return createResponse(
+          { token: "ws-token", user: verifiedUser },
+          { cookies: ["__Secure-gloomberb.session_token=signed-token.value; Path=/; HttpOnly; Secure; SameSite=Lax"] },
+        );
+      }
+
+      return createResponse({ user: verifiedUser });
+    }) as typeof fetch;
+
+    await apiClient.signIn("test@example.com", "password");
+    await apiClient.getSession();
+
+    expect(apiClient.getSessionToken()).toBe("signed-token.value");
+    expect(apiClient.getWebSocketToken()).toBe("ws-token");
+    expect(seenCookies).toEqual([
+      null,
+      "__Secure-gloomberb.session_token=signed-token.value",
+    ]);
+  });
+
+  test("replays both supported cookie names when restoring a saved session token", async () => {
+    const seenCookies: Array<string | null> = [];
+    apiClient.setSessionToken("persisted-token.value");
+
+    globalThis.fetch = (async (_input: Request | string | URL, init?: RequestInit) => {
+      const headers = new Headers(init?.headers);
+      seenCookies.push(headers.get("Cookie"));
+      return createResponse({ user: verifiedUser });
+    }) as typeof fetch;
+
+    await apiClient.getSession();
+
+    expect(seenCookies).toEqual([
+      "__Secure-gloomberb.session_token=persisted-token.value; gloomberb.session_token=persisted-token.value",
+    ]);
+  });
+});

package/src/utils/api-client.ts

@@ -3,6 +3,7 @@ import type { InstrumentSearchResult } from "../types/instrument";
 import { debugLog } from "./debug-log";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
+const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
 const cloudApiLog = debugLog.createLogger("cloud-api");
 
 export interface ChatMessage {
@@ -107,6 +108,7 @@ function marketKey(symbol: string, exchange?: string): string {
 
 type ChannelListener = (message: ChatMessage) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
+type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
 
 class ApiRequestError extends Error {
   constructor(message: string, readonly status?: number) {
@@ -117,6 +119,7 @@ class ApiRequestError extends Error {
 
 class GloomApiClient {
   private sessionToken: string | null = null;
+  private sessionCookieName: SessionCookieName | null = null;
   private websocketToken: string | null = null;
   private currentUser: AuthUser | null = null;
   private readonly baseUrl: string;
@@ -142,6 +145,9 @@ class GloomApiClient {
   }
 
   setSessionToken(token: string | null): void {
+    if (this.sessionToken !== token) {
+      this.sessionCookieName = null;
+    }
     this.sessionToken = token;
     if (!token) {
       this.websocketToken = null;
@@ -195,22 +201,41 @@ class GloomApiClient {
 
   private extractSessionCookie(res: Response): void {
     const setCookie = res.headers.getSetCookie?.() ?? [];
+    const fallbackHeader = res.headers.get("set-cookie");
+    if (fallbackHeader) {
+      setCookie.push(fallbackHeader);
+    }
     for (const cookie of setCookie) {
-      const match = cookie.match(/gloomberb\.session_token=([^;]+)/);
-      if (match) {
+      for (const cookieName of SESSION_COOKIE_NAMES) {
+        const escapedCookieName = cookieName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const match = cookie.match(new RegExp(`${escapedCookieName}=([^;]+)`));
+        if (!match) continue;
         this.sessionToken = match[1] ?? null;
+        this.sessionCookieName = cookieName;
+        return;
       }
     }
   }
 
+  private buildSessionCookieHeader(): string | null {
+    if (!this.sessionToken) return null;
+    const cookieNames = this.sessionCookieName ? [this.sessionCookieName] : SESSION_COOKIE_NAMES;
+    return cookieNames.map((cookieName) => `${cookieName}=${this.sessionToken}`).join("; ");
+  }
+
+  private setSessionCookieHeader(headers: Headers): void {
+    const cookieHeader = this.buildSessionCookieHeader();
+    if (cookieHeader) {
+      headers.set("Cookie", cookieHeader);
+    }
+  }
+
   private async request<T>(path: string, options?: RequestInit): Promise<T> {
     const headers = new Headers(options?.headers);
     if (!headers.has("Content-Type") && options?.method && options.method !== "GET") {
       headers.set("Content-Type", "application/json");
     }
-    if (this.sessionToken) {
-      headers.set("Cookie", `gloomberb.session_token=${this.sessionToken}`);
-    }
+    this.setSessionCookieHeader(headers);
     headers.set("Origin", this.baseUrl);
 
     const res = await fetch(`${this.baseUrl}${path}`, {

package/src/utils/price-history.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { normalizePriceHistory } from "./price-history";
+
+describe("normalizePriceHistory", () => {
+  test("drops poisoned cached history when every timestamp collapses to the same value", () => {
+    const history = normalizePriceHistory([
+      { date: null as any, close: 101 },
+      { date: null as any, close: 102 },
+      { date: null as any, close: 103 },
+    ]);
+
+    expect(history).toEqual([]);
+  });
+
+  test("filters invalid dates and keeps the remaining points in chronological order", () => {
+    const history = normalizePriceHistory([
+      { date: new Date("2026-03-29T00:00:00Z"), close: 103 },
+      { date: null as any, close: 999 },
+      { date: new Date("2026-03-27T00:00:00Z"), close: 101 },
+      { date: new Date("2026-03-28T00:00:00Z"), close: 102 },
+    ]);
+
+    expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
+  });
+});

package/src/utils/price-history.ts

@@ -1,7 +1,10 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
 
 function getPointTimestamp(point: PricePoint): number {
-  return point.date instanceof Date ? point.date.getTime() : new Date(point.date).getTime();
+  const value = point.date as Date | string | number | null | undefined;
+  if (value instanceof Date) return value.getTime();
+  if (value == null) return Number.NaN;
+  return new Date(value).getTime();
 }
 
 function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
@@ -17,18 +20,39 @@ function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
 }
 
 export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
-  if (points.length <= 1) return points;
+  if (points.length === 0) return points;
 
+  const validPoints: PricePoint[] = [];
+  let sawDistinctTimestamp = false;
+  let firstTimestamp: number | null = null;
   let previousTime = Number.NEGATIVE_INFINITY;
+  let requiresSort = false;
+
   for (const point of points) {
     const time = getPointTimestamp(point);
-    if (!Number.isFinite(time) || time < previousTime) {
-      return [...points].sort(comparePricePointsByDate);
+    if (!Number.isFinite(time)) continue;
+
+    if (firstTimestamp === null) {
+      firstTimestamp = time;
+    } else if (time !== firstTimestamp) {
+      sawDistinctTimestamp = true;
+    }
+
+    if (time < previousTime) {
+      requiresSort = true;
     }
     previousTime = time;
+    validPoints.push(point);
   }
 
-  return points;
+  if (validPoints.length === 0) return [];
+  if (validPoints.length === 1) return validPoints;
+  if (!sawDistinctTimestamp) return [];
+
+  if (requiresSort) {
+    return [...validPoints].sort(comparePricePointsByDate);
+  }
+  return validPoints.length === points.length ? points : validPoints;
 }
 
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.3.2";
+export const VERSION = "0.3.4";