gloomberb 0.4.0 → 0.5.0

package/src/plugins/plugin-runtime.tsx

@@ -10,6 +10,8 @@ import {
 import { useAppState, usePaneInstanceId, type PaneRuntimeState } from "../state/app-context";
 
 export interface PluginRuntimeAccess {
+  pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
+  navigateTicker(symbol: string): void;
   subscribeResumeState(pluginId: string, key: string, listener: () => void): () => void;
   getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null;
   setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void;
@@ -51,6 +53,14 @@ function usePluginRenderContext(): PluginRenderContextValue {
   return context;
 }
 
+export function usePluginTickerActions() {
+  const { runtime } = usePluginRenderContext();
+  return {
+    pinTicker: runtime.pinTicker,
+    navigateTicker: runtime.navigateTicker,
+  };
+}
+
 export function getPluginPaneStateValue<T>(
   paneState: PaneRuntimeState | undefined,
   pluginId: string,

package/src/plugins/prediction-markets/controller-data.ts

@@ -26,6 +26,7 @@ import { subscribePolymarketMarket } from "./services/polymarket-ws";
 import type {
   PredictionBrowseTab,
   PredictionCategoryId,
+  PredictionVenue,
   PredictionListRow,
   PredictionMarketDetail,
   PredictionMarketSummary,
@@ -36,6 +37,56 @@ import type {
 
 const KEYBOARD_DETAIL_LOAD_DELAY_MS = 140;
 
+function formatPredictionVenueLabel(venue: PredictionVenue): string {
+  return venue === "polymarket" ? "Polymarket" : "Kalshi";
+}
+
+function joinPredictionVenueLabels(venues: PredictionVenue[]): string {
+  const labels = [...new Set(venues.map(formatPredictionVenueLabel))];
+  if (labels.length <= 1) return labels[0] ?? "";
+  return `${labels.slice(0, -1).join(" and ")} and ${labels.at(-1)}`;
+}
+
+function formatPredictionLoadError(
+  venue: PredictionVenue,
+  subject: "markets" | "market detail",
+  error: unknown,
+): string {
+  const venueLabel = formatPredictionVenueLabel(venue);
+  const fallback = `Could not load ${venueLabel} ${subject}.`;
+  if (!(error instanceof Error)) {
+    return fallback;
+  }
+
+  const message = error.message.trim();
+  if (message.length === 0) {
+    return fallback;
+  }
+
+  const requestFailureMatch = message.match(/Request failed \((\d+)\)/i);
+  if (requestFailureMatch) {
+    return `${venueLabel} ${subject} request failed (${requestFailureMatch[1]}).`;
+  }
+
+  if (
+    /typo in the url or port|access the url|unable to connect|could not resolve host|connection refused/i.test(
+      message,
+    )
+  ) {
+    return `${venueLabel} is unavailable right now.`;
+  }
+
+  if (
+    /socket connection|socket hang up|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|fetch failed|network connection|connection closed/i.test(
+      message,
+    )
+  ) {
+    return `${venueLabel} is unavailable right now.`;
+  }
+
+  return `${fallback} ${message}`;
+}
+
 export function usePredictionMarketsDataState({
   browseTab,
   categoryId,
@@ -152,14 +203,84 @@ export function usePredictionMarketsDataState({
       ].filter((value): value is string => value != null),
     [includeKalshi, includePolymarket, kalshiCatalogKey, polymarketCatalogKey],
   );
+  const activeCatalogSources = useMemo(
+    () =>
+      [
+        includePolymarket
+          ? {
+              venue: "polymarket" as const,
+              cacheKey: polymarketCatalogKey,
+              error: catalogErrors[polymarketCatalogKey] ?? null,
+              markets: polymarketCatalog,
+            }
+          : null,
+        includeKalshi
+          ? {
+              venue: "kalshi" as const,
+              cacheKey: kalshiCatalogKey,
+              error: catalogErrors[kalshiCatalogKey] ?? null,
+              markets: kalshiCatalog,
+            }
+          : null,
+      ].filter(
+        (
+          value,
+        ): value is {
+          venue: PredictionVenue;
+          cacheKey: string;
+          error: string | null;
+          markets: PredictionMarketSummary[];
+        } => value != null,
+      ),
+    [
+      catalogErrors,
+      includeKalshi,
+      includePolymarket,
+      kalshiCatalog,
+      kalshiCatalogKey,
+      polymarketCatalog,
+      polymarketCatalogKey,
+    ],
+  );
   const catalogLoadCount = activeCatalogKeys.reduce(
     (count, cacheKey) => count + (catalogPending[cacheKey] ?? 0),
     0,
   );
-  const catalogError = activeCatalogKeys
-    .map((cacheKey) => catalogErrors[cacheKey])
-    .filter((value): value is string => !!value)
-    .join(" ") || null;
+  const catalogStatus = useMemo(() => {
+    const failingSources = activeCatalogSources.filter((source) => !!source.error);
+    if (failingSources.length === 0) {
+      return null;
+    }
+
+    const loadedSources = activeCatalogSources.filter(
+      (source) => !source.error && source.markets.length > 0,
+    );
+    if (failingSources.length < activeCatalogSources.length) {
+      const unavailableVenues = joinPredictionVenueLabels(
+        failingSources.map((source) => source.venue),
+      );
+      if (loadedSources.length > 0) {
+        return {
+          tone: "warning" as const,
+          message: `${unavailableVenues} unavailable right now; showing ${joinPredictionVenueLabels(
+            loadedSources.map((source) => source.venue),
+          )} markets.`,
+        };
+      }
+      return {
+        tone: "warning" as const,
+        message: `${unavailableVenues} unavailable right now.`,
+      };
+    }
+
+    return {
+      tone: "danger" as const,
+      message: failingSources
+        .map((source) => source.error)
+        .filter((value): value is string => !!value)
+        .join(" "),
+    };
+  }, [activeCatalogSources]);
 
   const allMarkets = useMemo(() => {
     const merged: PredictionMarketSummary[] = [];
@@ -276,9 +397,7 @@ export function usePredictionMarketsDataState({
           updatePredictionErrorState(
             current,
             cacheKey,
-            error instanceof Error
-              ? error.message
-              : "Could not load Polymarket markets.",
+            formatPredictionLoadError("polymarket", "markets", error),
           ),
         );
       } finally {
@@ -310,9 +429,7 @@ export function usePredictionMarketsDataState({
           updatePredictionErrorState(
             current,
             cacheKey,
-            error instanceof Error
-              ? error.message
-              : "Could not load Kalshi markets.",
+            formatPredictionLoadError("kalshi", "markets", error),
           ),
         );
       } finally {
@@ -360,9 +477,7 @@ export function usePredictionMarketsDataState({
           updatePredictionErrorState(
             current,
             cacheKey,
-            error instanceof Error
-              ? error.message
-              : "Could not load market detail.",
+            formatPredictionLoadError(summary.venue, "market detail", error),
           ),
         );
         if (currentDetailCacheKeyRef.current === cacheKey) {
@@ -605,7 +720,7 @@ export function usePredictionMarketsDataState({
   }, []);
 
   return {
-    catalogError,
+    catalogStatus,
     catalogLoadCount,
     debouncedSearchQuery,
     detail,

package/src/plugins/prediction-markets/controller.ts

@@ -692,7 +692,7 @@ export function usePredictionMarketsController({
     paneSettings,
     browseTab,
     categoryId,
-    catalogError: data.catalogError,
+    catalogStatus: data.catalogStatus,
     catalogLoadCount: data.catalogLoadCount,
     detail: data.detail,
     detailError: data.detailError,

package/src/plugins/prediction-markets/detail/shared.tsx

@@ -1,6 +1,5 @@
-import { TextAttributes } from "@opentui/core";
 import { colors } from "../../../theme/colors";
-import { openUrl } from "../../../components/ui/external-link";
+import { ExternalLinkText } from "../../../components/ui/external-link";
 
 export function truncatePredictionText(
   value: string,
@@ -19,10 +18,12 @@ export function SummaryLink({
   maxLength: number;
 }) {
   return (
-    <box height={1} onMouseDown={() => openUrl(url)}>
-      <text fg={colors.textBright} attributes={TextAttributes.UNDERLINE}>
-        {truncatePredictionText(url, maxLength)}
-      </text>
+    <box height={1}>
+      <ExternalLinkText
+        url={url}
+        label={truncatePredictionText(url, maxLength)}
+        color={colors.textBright}
+      />
     </box>
   );
 }

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

@@ -1,7 +1,7 @@
 import type { GloomPlugin, GloomPluginContext } from "../../types/plugin";
 import { parsePredictionSearchShortcut } from "./navigation";
 import { PredictionMarketsPane } from "./pane";
-import { attachPredictionMarketsPersistence } from "./services/fetch";
+import { attachPredictionMarketsPersistence, resetPredictionMarketsPersistence } from "./services/fetch";
 import { predictionMarketsCliCommand } from "./cli";
 import {
   buildPredictionMarketsPaneSettingsDef,
@@ -101,4 +101,8 @@ export const predictionMarketsPlugin: GloomPlugin = {
       },
     });
   },
+
+  dispose() {
+    resetPredictionMarketsPersistence();
+  },
 };

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

@@ -83,6 +83,57 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("Will the Fed cut rates?");
   });
 
+  test("shows a venue warning instead of a raw fetch error when one catalog fails", async () => {
+    attachPredictionMarketsPersistence(new MemoryPersistence());
+
+    globalThis.fetch = (async (input: Request | string | URL) => {
+      const url = String(input);
+      if (url.includes("gamma-api.polymarket.com")) {
+        throw new Error("Unable to connect. Was there a typo in the url or port?");
+      }
+      if (url.includes("/trade-api/v2/events?")) {
+        return new Response(
+          JSON.stringify({
+            events: [
+              {
+                title: "Fed series",
+                category: "Economics",
+                event_ticker: "FED-1",
+                series_ticker: "FED",
+                markets: [
+                  {
+                    ticker: "KAL-1",
+                    title: "Will the Fed cut rates?",
+                    yes_sub_title: "Yes",
+                    event_ticker: "FED-1",
+                    status: "open",
+                    market_type: "binary",
+                    last_price_dollars: "0.48",
+                    volume_24h_fp: "15000",
+                    volume_fp: "90000",
+                    open_interest_fp: "45000",
+                  },
+                ],
+              },
+            ],
+          }),
+          { status: 200 },
+        );
+      }
+      return new Response(JSON.stringify({}), { status: 200 });
+    }) as unknown as typeof fetch;
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Will the Fed cut rates?");
+    expect(frame).toContain(
+      "Polymarket unavailable right now; showing Kalshi markets.",
+    );
+    expect(frame).not.toContain("Was there a typo in the url or port?");
+  });
+
   test("selects a market on single click and opens detail on double click", async () => {
     installPredictionMarketMocks();
 
@@ -127,6 +178,33 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("Kalshi primary rule");
   });
 
+  test("focuses the pane when a market row is clicked", async () => {
+    installPredictionMarketMocks();
+
+    testSetup = await testRender(
+      <Harness initialFocusedPaneId="portfolio-list:main" />,
+      { width: 120, height: 34 },
+    );
+    await flushFrames(testSetup);
+
+    expect(harnessStateRef.current?.focusedPaneId).toBe("portfolio-list:main");
+
+    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);
+
+    expect(harnessStateRef.current?.focusedPaneId).toBe(TEST_PANE_ID);
+  });
+
   test("loads selected detail once instead of refetching in a render loop", async () => {
     const { fetchUrls } = installPredictionMarketMocks();
 

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

@@ -11,6 +11,10 @@ import type { PredictionBrowseTab, PredictionCategoryId } from "./types";
 
 export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
   const controller = usePredictionMarketsController({ focused });
+  const catalogStatusColor =
+    controller.catalogStatus?.tone === "danger"
+      ? colors.negative
+      : colors.borderFocused;
 
   const browseContent = (
     <box
@@ -113,9 +117,9 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
         </scrollbox>
       ) : null}
 
-      {controller.catalogError ? (
-        <box height={1} paddingX={1}>
-          <text fg={colors.negative}>{controller.catalogError}</text>
+      {controller.catalogStatus ? (
+        <box height={1} paddingX={1} width={width} backgroundColor={colors.panel}>
+          <text fg={catalogStatusColor}>{controller.catalogStatus.message}</text>
         </box>
       ) : null}
 

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

@@ -363,6 +363,53 @@ describe("prediction markets plugin registration and services", () => {
     expect(markets[0]?.marketLabel).toBe("April 30");
   });
 
+  test("keeps Polymarket catalog results when one page connection resets", async () => {
+    let resetFetchCount = 0;
+
+    globalThis.fetch = (async (input: Request | string | URL) => {
+      const url = String(input);
+      if (url.includes("gamma-api.polymarket.com/events?")) {
+        if (url.includes("offset=200")) {
+          resetFetchCount += 1;
+          throw Object.assign(
+            new Error("The socket connection was closed unexpectedly."),
+            { code: "ECONNRESET" },
+          );
+        }
+        return new Response(
+          JSON.stringify([
+            {
+              id: "event-stable",
+              title: "Stable catalog page",
+              tags: [{ label: "Macro", slug: "economy" }],
+              markets: [
+                {
+                  id: "pm-stable",
+                  question: "Will the stable page load?",
+                  conditionId: "cond-stable",
+                  outcomes: '["Yes","No"]',
+                  outcomePrices: '["0.57","0.43"]',
+                  clobTokenIds: '["yes-stable","no-stable"]',
+                  volume24hr: 125000,
+                  active: true,
+                  closed: false,
+                },
+              ],
+            },
+          ]),
+          { status: 200 },
+        );
+      }
+      return new Response(JSON.stringify({}), { status: 200 });
+    }) as unknown as typeof fetch;
+
+    const markets = await loadPolymarketCatalog("", "all");
+
+    expect(markets).toHaveLength(1);
+    expect(markets[0]?.marketId).toBe("pm-stable");
+    expect(resetFetchCount).toBe(3);
+  });
+
   test("uses remote catalog endpoints for search and category changes", async () => {
     const { fetchUrls } = installPredictionMarketMocks();
 
@@ -420,7 +467,7 @@ describe("prediction markets plugin registration and services", () => {
       }
       if (url.includes("gamma-api.polymarket.com/events/event-1")) {
         eventFetchCount += 1;
-        if (eventFetchCount === 1) {
+        if (eventFetchCount <= 3) {
           return new Response("{}", { status: 500 });
         }
         return new Response(

package/src/plugins/prediction-markets/services/fetch.ts

@@ -1,6 +1,18 @@
 import type { PluginPersistence } from "../../../types/plugin";
+import { createThrottledFetch } from "../../../utils/throttled-fetch";
 
 const DEFAULT_SOURCE_KEY = "remote";
+const PREDICTION_FETCH = createThrottledFetch({
+  requestsPerMinute: 120,
+  maxRetries: 2,
+  timeoutMs: 10_000,
+  backoffBaseMs: 250,
+  dedupeGetRequests: false,
+  defaultHeaders: {
+    Accept: "application/json",
+    "User-Agent": "gloomberb-prediction-markets",
+  },
+});
 
 export const PREDICTION_CACHE_POLICIES = {
   catalog: { staleMs: 30_000, expireMs: 10 * 60_000 },
@@ -19,18 +31,16 @@ export function attachPredictionMarketsPersistence(
   predictionMarketsPersistence = persistence;
 }
 
+export function resetPredictionMarketsPersistence(): void {
+  predictionMarketsPersistence = null;
+}
+
 export function getPredictionMarketsPersistence(): PluginPersistence | null {
   return predictionMarketsPersistence;
 }
 
 export async function fetchJson<T>(url: string): Promise<T> {
-  const response = await fetch(url, {
-    signal: AbortSignal.timeout(10_000),
-    headers: {
-      Accept: "application/json",
-      "User-Agent": "gloomberb-prediction-markets",
-    },
-  });
+  const response = await PREDICTION_FETCH.fetch(url);
   if (!response.ok) {
     throw new Error(`Request failed (${response.status}) for ${url}`);
   }

package/src/plugins/prediction-markets/services/polymarket-adapter.ts

@@ -219,6 +219,27 @@ function buildPolymarketSearchUrl(query: string): string {
   return url.toString();
 }
 
+async function loadPolymarketCatalogPages(
+  offsets: number[],
+  tagSlug?: string,
+): Promise<PolymarketEventRecord[]> {
+  const results = await Promise.allSettled(
+    offsets.map((offset) =>
+      fetchJson<PolymarketEventRecord[]>(
+        buildPolymarketCatalogUrl(offset, tagSlug),
+      ),
+    ),
+  );
+  const pages = results.flatMap((result) =>
+    result.status === "fulfilled" ? result.value : [],
+  );
+  if (pages.length > 0) return pages;
+
+  const rejected = results.find((result) => result.status === "rejected");
+  if (rejected?.status === "rejected") throw rejected.reason;
+  return [];
+}
+
 export function normalizePolymarketMarket(
   record: PolymarketMarketRecord,
   options?: {
@@ -360,12 +381,11 @@ export async function loadPolymarketCatalog(
       if (categoryId !== "all") {
         const tagSlugs = getPolymarketCategoryTagSlugs(categoryId);
         const categoryPages = await Promise.all(
-          tagSlugs.flatMap((tagSlug) =>
-            POLYMARKET_CATEGORY_OFFSETS.map((offset) =>
-              fetchJson<PolymarketEventRecord[]>(
-                buildPolymarketCatalogUrl(offset, tagSlug),
-              ).catch(() => []),
-            ),
+          tagSlugs.map((tagSlug) =>
+            loadPolymarketCatalogPages(
+              POLYMARKET_CATEGORY_OFFSETS,
+              tagSlug,
+            ).catch(() => []),
           ),
         );
         const categorized = sortPolymarketMarkets(
@@ -374,13 +394,11 @@ export async function loadPolymarketCatalog(
         if (categorized.length > 0) return categorized;
       }
 
-      const pages = await Promise.all(
-        POLYMARKET_CATALOG_OFFSETS.map((offset) =>
-          fetchJson<PolymarketEventRecord[]>(buildPolymarketCatalogUrl(offset)),
-        ),
+      const pages = await loadPolymarketCatalogPages(
+        POLYMARKET_CATALOG_OFFSETS,
       );
       return sortPolymarketMarkets(
-        flattenPolymarketEvents(pages.flat(), "", categoryId),
+        flattenPolymarketEvents(pages, "", categoryId),
       );
     },
     PREDICTION_CACHE_POLICIES.catalog,

package/src/plugins/prediction-markets/services/polymarket-ws.ts

@@ -1,6 +1,8 @@
 import type { PredictionBookLevel, PredictionTrade } from "../types";
 import { parseFloatSafe } from "./fetch";
 
+const POLYMARKET_HEARTBEAT_MS = 10_000;
+
 interface PolymarketLiveCallbacks {
   onBestBidAsk?: (
     assetId: string,
@@ -38,8 +40,23 @@ export function subscribePolymarketMarket(
   let closed = false;
   let socket: WebSocket | null = null;
   let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+  const clearHeartbeat = () => {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  };
+
+  const sendHeartbeat = () => {
+    try {
+      socket?.send("PING");
+    } catch {
+      // The close handler will schedule reconnects for broken sockets.
+    }
+  };
 
   const connect = () => {
+    clearHeartbeat();
     socket = new WebSocket(
       "wss://ws-subscriptions-clob.polymarket.com/ws/market",
     );
@@ -51,6 +68,7 @@ export function subscribePolymarketMarket(
           custom_feature_enabled: true,
         }),
       );
+      heartbeatTimer = setInterval(sendHeartbeat, POLYMARKET_HEARTBEAT_MS);
     });
     socket.addEventListener("message", (event) => {
       try {
@@ -89,6 +107,7 @@ export function subscribePolymarketMarket(
       }
     });
     socket.addEventListener("close", () => {
+      clearHeartbeat();
       socket = null;
       if (closed) return;
       reconnectTimer = setTimeout(connect, 1_500);
@@ -103,6 +122,7 @@ export function subscribePolymarketMarket(
   return () => {
     closed = true;
     if (reconnectTimer) clearTimeout(reconnectTimer);
+    clearHeartbeat();
     socket?.close();
   };
 }

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

@@ -99,11 +99,22 @@ export class MemoryPersistence implements PluginPersistence {
 
 attachPredictionMarketsPersistence(new MemoryPersistence());
 
-export function createConfig(): AppConfig {
+export function createConfig(options?: {
+  initialFocusedPaneId?: string;
+}): AppConfig {
   const config = createDefaultConfig("/tmp/gloomberb-prediction-markets");
+  const initialFocusedPaneId = options?.initialFocusedPaneId ?? TEST_PANE_ID;
+  const extraInstances = initialFocusedPaneId !== TEST_PANE_ID
+    ? [{
+        instanceId: initialFocusedPaneId,
+        paneId: initialFocusedPaneId.split(":")[0] ?? "portfolio-list",
+        binding: { kind: "none" as const },
+      }]
+    : [];
   const layout = {
     dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
     instances: [
+      ...extraInstances,
       {
         instanceId: TEST_PANE_ID,
         paneId: "prediction-markets",
@@ -126,6 +137,8 @@ export function createRuntime(): PluginRuntimeAccess {
   const listeners = new Map<string, Set<() => void>>();
 
   return {
+    pinTicker() {},
+    navigateTicker() {},
     subscribeResumeState(pluginId, key, listener) {
       const listenerKey = `${pluginId}:${key}`;
       if (!listeners.has(listenerKey)) listeners.set(listenerKey, new Set());
@@ -424,13 +437,17 @@ export function installPredictionMarketMocks() {
   return { fetchUrls };
 }
 
-export function Harness() {
+export function Harness({
+  initialFocusedPaneId = TEST_PANE_ID,
+}: {
+  initialFocusedPaneId?: string;
+} = {}) {
   const runtime = useMemo(() => createRuntime(), []);
   const [state, dispatch] = useReducer(
     appReducer,
     (() => {
-      const initial = createInitialState(createConfig());
-      initial.focusedPaneId = TEST_PANE_ID;
+      const initial = createInitialState(createConfig({ initialFocusedPaneId }));
+      initial.focusedPaneId = initialFocusedPaneId;
       return initial;
     })(),
   );
@@ -442,7 +459,7 @@ export function Harness() {
           <PredictionMarketsPane
             paneId={TEST_PANE_ID}
             paneType="prediction-markets"
-            focused
+            focused={state.focusedPaneId === TEST_PANE_ID}
             width={120}
             height={34}
           />