gloomberb 0.7.5 → 0.8.0

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

@@ -0,0 +1,66 @@
+export interface PolymarketEventRecord {
+  id: string;
+  title: string;
+  slug?: string;
+  description?: string;
+  endDate?: string;
+  startDate?: string;
+  updatedAt?: string;
+  resolutionSource?: string;
+  openInterest?: number;
+  volume24hr?: number;
+  tags?: Array<{ label?: string; slug?: string }>;
+  markets?: PolymarketMarketRecord[];
+}
+
+export interface PolymarketMarketRecord {
+  id?: string;
+  question: string;
+  conditionId?: string;
+  slug?: string;
+  groupItemTitle?: string;
+  description?: string;
+  endDate?: string;
+  updatedAt?: string;
+  createdAt?: string;
+  volume24hr?: number;
+  volumeNum?: number;
+  liquidityNum?: number;
+  spread?: number;
+  bestBid?: number | null;
+  bestAsk?: number | null;
+  lastTradePrice?: number | null;
+  outcomes?: string | string[];
+  outcomePrices?: string | string[];
+  clobTokenIds?: string | string[];
+  events?: PolymarketEventRecord[];
+  resolutionSource?: string;
+  active?: boolean;
+  closed?: boolean;
+}
+
+export interface PolymarketSearchResponse {
+  events?: PolymarketEventRecord[] | null;
+}
+
+export interface PolymarketBookResponse {
+  bids?: Array<{ price: string; size: string }>;
+  asks?: Array<{ price: string; size: string }>;
+  last_trade_price?: string;
+}
+
+export interface PolymarketTradesResponseItem {
+  proxyWallet?: string;
+  side?: string;
+  asset?: string;
+  conditionId?: string;
+  size?: number;
+  price?: number;
+  timestamp?: number;
+  outcome?: string;
+  transactionHash?: string;
+}
+
+export interface PolymarketHistoryResponse {
+  history?: Array<{ t: number; p: number }>;
+}

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

@@ -0,0 +1,128 @@
+import type { PredictionBookLevel, PredictionTrade } from "../../types";
+import { parseFloatSafe } from "../fetch";
+
+const POLYMARKET_HEARTBEAT_MS = 10_000;
+
+interface PolymarketLiveCallbacks {
+  onBestBidAsk?: (
+    assetId: string,
+    bestBid: number | null,
+    bestAsk: number | null,
+    spread: number | null,
+  ) => void;
+  onBook?: (
+    assetId: string,
+    bids: PredictionBookLevel[],
+    asks: PredictionBookLevel[],
+    lastTradePrice: number | null,
+  ) => void;
+  onTrade?: (assetId: string, trade: PredictionTrade) => void;
+}
+
+function toBookLevels(
+  levels: Array<{ price: string; size: string }> | undefined,
+): PredictionBookLevel[] {
+  return (levels ?? [])
+    .map((level) => {
+      const price = parseFloatSafe(level.price);
+      const size = parseFloatSafe(level.size);
+      return price == null || size == null ? null : { price, size };
+    })
+    .filter((level): level is PredictionBookLevel => level != null);
+}
+
+export function subscribePolymarketMarket(
+  assetIds: string[],
+  callbacks: PolymarketLiveCallbacks,
+): () => void {
+  if (assetIds.length === 0) return () => {};
+
+  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",
+    );
+    socket.addEventListener("open", () => {
+      socket?.send(
+        JSON.stringify({
+          assets_ids: assetIds,
+          type: "market",
+          custom_feature_enabled: true,
+        }),
+      );
+      heartbeatTimer = setInterval(sendHeartbeat, POLYMARKET_HEARTBEAT_MS);
+    });
+    socket.addEventListener("message", (event) => {
+      try {
+        const payload = JSON.parse(String(event.data)) as any;
+        switch (payload.event_type) {
+          case "book":
+            callbacks.onBook?.(
+              String(payload.asset_id),
+              toBookLevels(payload.bids),
+              toBookLevels(payload.asks),
+              parseFloatSafe(payload.last_trade_price),
+            );
+            break;
+          case "best_bid_ask":
+            callbacks.onBestBidAsk?.(
+              String(payload.asset_id),
+              parseFloatSafe(payload.best_bid),
+              parseFloatSafe(payload.best_ask),
+              parseFloatSafe(payload.spread),
+            );
+            break;
+          case "last_trade_price":
+            callbacks.onTrade?.(String(payload.asset_id), {
+              id: `${payload.asset_id}:${payload.timestamp}:${payload.price}`,
+              timestamp: Number.parseInt(String(payload.timestamp), 10),
+              side:
+                String(payload.side).toUpperCase() === "SELL" ? "sell" : "buy",
+              outcome: "yes",
+              price: parseFloatSafe(payload.price) ?? 0,
+              size: parseFloatSafe(payload.size) ?? 0,
+            });
+            break;
+        }
+      } catch {
+        // ignore malformed messages
+      }
+    });
+    socket.addEventListener("close", () => {
+      clearHeartbeat();
+      socket = null;
+      if (closed) return;
+      reconnectTimer = setTimeout(connect, 1_500);
+    });
+    socket.addEventListener("error", () => {
+      socket?.close();
+    });
+  };
+
+  connect();
+
+  return () => {
+    closed = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    clearHeartbeat();
+    socket?.close();
+  };
+}

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

@@ -1,21 +1,20 @@
 import { act, useMemo, useReducer, useRef } from "react";
 import type { ScrollBoxRenderable } from "@opentui/core";
-import { PaneFooterBar, PaneFooterProvider } from "../../components/layout/pane-footer";
+import { PaneFooterBar, PaneFooterProvider } from "../../components/layout/pane/footer";
 import {
   AppContext,
   appReducer,
   createInitialState,
   PaneInstanceProvider,
-} from "../../state/app-context";
+} from "../../state/app/context";
+import { MemoryPluginPersistence } from "../../test-support/plugin-persistence";
 import { createStatefulTestPluginRuntime } from "../../test-support/plugin-runtime";
 import { createDefaultConfig, type AppConfig } from "../../types/config";
-import type { PersistedResourceValue } from "../../types/persistence";
-import type { PluginPersistence } from "../../types/plugin";
 import { Box } from "../../ui";
 import {
   PluginRenderProvider,
   type PluginRuntimeAccess,
-} from "../plugin-runtime";
+} from "../runtime";
 import { PredictionMarketChart } from "./chart";
 import { PredictionMarketDetailPane } from "./detail/pane";
 import { PredictionMarketsPane } from "./pane";
@@ -24,7 +23,7 @@ import {
   PREDICTION_CACHE_POLICIES,
   attachPredictionMarketsPersistence,
 } from "./services/fetch";
-import { normalizeKalshiMarket } from "./services/kalshi-adapter";
+import { normalizeKalshiMarket } from "./services/kalshi/adapter";
 
 export const TEST_PANE_ID = "prediction-markets:main";
 const originalFetch = globalThis.fetch;
@@ -34,75 +33,11 @@ export const harnessStateRef: {
   current: ReturnType<typeof createInitialState> | null;
 } = { current: null };
 
-export class MemoryPersistence implements PluginPersistence {
-  private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
-  private readonly resources = new Map<string, PersistedResourceValue<unknown>>();
+export { MemoryPluginPersistence as MemoryPersistence } from "../../test-support/plugin-persistence";
 
-  getState<T = unknown>(key: string, options?: { schemaVersion?: number }): T | null {
-    const record = this.state.get(key);
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) {
-      this.state.delete(key);
-      return null;
-    }
-    return record.value as T;
-  }
-
-  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
-    this.state.set(key, { schemaVersion: options?.schemaVersion ?? 1, value });
-  }
-
-  deleteState(key: string): void {
-    this.state.delete(key);
-  }
-
-  getResource<T = unknown>(
-    kind: string,
-    key: string,
-    options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
-  ): PersistedResourceValue<T> | null {
-    const record = this.resources.get(`${kind}:${key}:${options?.sourceKey ?? ""}`);
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) {
-      this.resources.delete(`${kind}:${key}:${options.sourceKey ?? ""}`);
-      return null;
-    }
-    return record as PersistedResourceValue<T>;
-  }
-
-  setResource<T = unknown>(
-    kind: string,
-    key: string,
-    value: T,
-    options: {
-      cachePolicy: { staleMs: number; expireMs: number };
-      sourceKey?: string;
-      schemaVersion?: number;
-      provenance?: unknown;
-    },
-  ): PersistedResourceValue<T> {
-    const now = Date.now();
-    const record: PersistedResourceValue<T> = {
-      value,
-      fetchedAt: now,
-      staleAt: now + options.cachePolicy.staleMs,
-      expiresAt: now + options.cachePolicy.expireMs,
-      sourceKey: options.sourceKey ?? "",
-      schemaVersion: options.schemaVersion ?? 1,
-      provenance: options.provenance,
-    };
-    this.resources.set(`${kind}:${key}:${options.sourceKey ?? ""}`, record);
-    return record;
-  }
-
-  deleteResource(kind: string, key: string, options?: { sourceKey?: string }): void {
-    this.resources.delete(`${kind}:${key}:${options?.sourceKey ?? ""}`);
-  }
-}
-
-attachPredictionMarketsPersistence(new MemoryPersistence());
+attachPredictionMarketsPersistence(new MemoryPluginPersistence());
 
-export function createConfig(options?: {
+function createConfig(options?: {
   initialFocusedPaneId?: string;
 }): AppConfig {
   const config = createDefaultConfig("/tmp/gloomberb-prediction-markets");
@@ -126,6 +61,7 @@ export function createConfig(options?: {
       },
     ],
     floating: [],
+    detached: [],
   };
 
   return {
@@ -135,12 +71,12 @@ export function createConfig(options?: {
   };
 }
 
-export function createRuntime(): PluginRuntimeAccess {
+function createRuntime(): PluginRuntimeAccess {
   return createStatefulTestPluginRuntime();
 }
 
 export function installPredictionMarketMocks() {
-  attachPredictionMarketsPersistence(new MemoryPersistence());
+  attachPredictionMarketsPersistence(new MemoryPluginPersistence());
   const fetchUrls: string[] = [];
   const polymarketMarket = {
     id: "pm-1",
@@ -622,7 +558,7 @@ export async function cleanupPredictionTest(
   harnessStateRef.current = null;
   globalThis.fetch = originalFetch;
   globalThis.WebSocket = originalWebSocket;
-  attachPredictionMarketsPersistence(new MemoryPersistence());
+  attachPredictionMarketsPersistence(new MemoryPluginPersistence());
 }
 
 export { PREDICTION_CACHE_POLICIES };

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

@@ -7,7 +7,7 @@ export type PredictionBrowseTab = "top" | "ending" | "new" | "watchlist";
 export type PredictionDetailTab = "overview" | "book" | "trades" | "rules";
 export type PredictionHistoryRange = "1D" | "1W" | "1M" | "ALL";
 export type PredictionVolumeUnit = "usd" | "contracts";
-export type PredictionSortDirection = "asc" | "desc";
+type PredictionSortDirection = "asc" | "desc";
 export type PredictionTransportState =
   | "idle"
   | "loading"
@@ -131,7 +131,7 @@ export interface PredictionColumnDef extends ColumnConfig {
   description: string;
 }
 
-export interface PredictionListRowBase {
+interface PredictionListRowBase {
   key: string;
   kind: "market" | "group";
   venue: PredictionVenue;

package/src/plugins/registry/context-menu.ts

@@ -0,0 +1,36 @@
+import type { ContextMenuContext, ContextMenuItem } from "../../types/context-menu";
+import type { ContextMenuProviderEntry } from "./contributions";
+
+interface ResolveRegistryContextMenuItemsOptions {
+  context: ContextMenuContext;
+  disabledPlugins: Set<string>;
+  providers: Iterable<[string, ContextMenuProviderEntry]>;
+  onProviderError: (entry: ContextMenuProviderEntry, error: unknown) => void;
+}
+
+export function resolveRegistryContextMenuItems({
+  context,
+  disabledPlugins,
+  providers,
+  onProviderError,
+}: ResolveRegistryContextMenuItemsOptions): ContextMenuItem[] {
+  const entries = [...providers]
+    .filter(([, entry]) => !disabledPlugins.has(entry.pluginId))
+    .filter(([, entry]) => !entry.provider.contexts || entry.provider.contexts.includes(context.kind))
+    .sort((left, right) => (
+      (left[1].provider.order ?? 0) - (right[1].provider.order ?? 0)
+      || left[1].pluginId.localeCompare(right[1].pluginId)
+      || left[1].provider.id.localeCompare(right[1].provider.id)
+    ));
+
+  const items: ContextMenuItem[] = [];
+  for (const [, entry] of entries) {
+    try {
+      const provided = entry.provider.getItems(context);
+      if (provided?.length) items.push(...provided);
+    } catch (error) {
+      onProviderError(entry, error);
+    }
+  }
+  return items;
+}

package/src/plugins/registry/context.ts

@@ -0,0 +1,196 @@
+import type { AppPersistence } from "../../data/app-persistence";
+import type { TickerRepository } from "../../data/ticker-repository";
+import type { BrokerInstanceConfig, LayoutConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
+import type { TickerFinancials } from "../../types/financials";
+import type { TickerRecord } from "../../types/ticker";
+import type { PluginCapability } from "../../capabilities";
+import type {
+  AppNotificationRequest,
+  BrokerInstanceUpdateOptions,
+  GloomPluginContext,
+  PaneTemplateCreateOptions,
+  PinTickerOptions,
+} from "../../types/plugin";
+import type { PaneRuntimeState } from "../../core/state/app/state";
+import type { NewsQuery, NewsQueryState } from "../../types/news-source";
+import { debugLog } from "../../utils/debug-log";
+import { createPluginPersistence } from "../plugin-persistence";
+import type { PluginEvents } from "../event-bus";
+import type { PluginItems, RegistryContributions } from "./contributions";
+import {
+  createPluginPaneSettingsState,
+  createPluginResumeState,
+} from "./plugin-state";
+
+export interface RegistryPluginContextOptions {
+  pluginId: string;
+  items: PluginItems;
+  contributions: RegistryContributions;
+  enableCapabilityHandlers: boolean;
+  marketData: DataProvider;
+  tickerRepository: TickerRepository;
+  persistence: AppPersistence;
+  getLayout: () => LayoutConfig;
+  updateLayout: (layout: LayoutConfig) => void;
+  resolvePaneTarget: (paneId: string) => string | undefined;
+  registerCapabilityForPlugin: (pluginId: string, capability: PluginCapability, items: PluginItems) => void;
+  watchNewsQuery: (query: NewsQuery, listener: (state: NewsQueryState) => void) => () => void;
+  getData: (ticker: string) => TickerFinancials | null;
+  getTicker: (symbol: string) => TickerRecord | null;
+  getConfig: () => import("../../types/config").AppConfig;
+  getResumeState: <T = unknown>(key: string, schemaVersion?: number) => T | null;
+  setResumeState: (key: string, value: unknown, schemaVersion?: number) => void;
+  deleteResumeState: (key: string) => void;
+  getPaneRuntimeState: (paneId: string) => PaneRuntimeState | null;
+  updatePaneRuntimeState: (paneId: string, patch: Partial<PaneRuntimeState>) => void;
+  getConfigState: <T = unknown>(key: string) => T | null;
+  setConfigState: (key: string, value: unknown) => Promise<void>;
+  deleteConfigState: (key: string) => Promise<void>;
+  getConfigStateKeys: () => string[];
+  createBrokerInstance: (brokerType: string, label: string, values: Record<string, unknown>) => Promise<BrokerInstanceConfig>;
+  updateBrokerInstance: (instanceId: string, values: Record<string, unknown>, options?: BrokerInstanceUpdateOptions) => Promise<void>;
+  syncBrokerInstance: (instanceId: string) => Promise<void>;
+  removeBrokerInstance: (instanceId: string) => Promise<void>;
+  selectTicker: (symbol: string, paneId?: string) => void;
+  switchPanel: (panel: "left" | "right") => void;
+  switchTab: (tabId: string, paneId?: string) => void;
+  openCommandBar: (query?: string) => void;
+  showPane: (paneId: string) => void;
+  createPaneFromTemplate: (templateId: string, options?: PaneTemplateCreateOptions) => void;
+  hidePane: (paneId: string) => void;
+  focusPane: (paneId: string) => void;
+  pinTicker: (symbol: string, options?: PinTickerOptions) => void;
+  navigateTicker: (symbol: string, options?: { sourcePaneId?: string | null }) => void;
+  openPaneSettings: (paneId?: string) => void;
+  events: {
+    on: <K extends keyof PluginEvents>(event: K, handler: (payload: PluginEvents[K]) => void) => () => void;
+    emit: <K extends keyof PluginEvents>(event: K, payload: PluginEvents[K]) => void;
+  };
+  notify: (notification: AppNotificationRequest) => void;
+}
+
+export function createRegistryPluginContext({
+  pluginId,
+  items,
+  contributions,
+  enableCapabilityHandlers,
+  marketData,
+  tickerRepository,
+  persistence,
+  getLayout,
+  updateLayout,
+  resolvePaneTarget,
+  registerCapabilityForPlugin,
+  watchNewsQuery,
+  getData,
+  getTicker,
+  getConfig,
+  getResumeState,
+  setResumeState,
+  deleteResumeState,
+  getPaneRuntimeState,
+  updatePaneRuntimeState,
+  getConfigState,
+  setConfigState,
+  deleteConfigState,
+  getConfigStateKeys,
+  createBrokerInstance,
+  updateBrokerInstance,
+  syncBrokerInstance,
+  removeBrokerInstance,
+  selectTicker,
+  switchPanel,
+  switchTab,
+  openCommandBar,
+  showPane,
+  createPaneFromTemplate,
+  hidePane,
+  focusPane,
+  pinTicker,
+  navigateTicker,
+  openPaneSettings,
+  events,
+  notify,
+}: RegistryPluginContextOptions): GloomPluginContext {
+  const pluginNamespace = `plugin:${pluginId}`;
+  const pluginPersistence = createPluginPersistence(persistence.pluginState, persistence.resources, pluginNamespace, pluginId);
+  const log = debugLog.createLogger(pluginId);
+  const resume = createPluginResumeState({
+    pluginId,
+    getResumeState,
+    setResumeState,
+    deleteResumeState,
+    getPaneRuntimeState,
+    updatePaneRuntimeState,
+  });
+  const paneSettings = createPluginPaneSettingsState({
+    getLayout,
+    resolvePaneTarget,
+    updateLayout,
+  });
+
+  return {
+    registerPane: (pane) => contributions.registerPane(pluginId, pane, items),
+    registerPaneTemplate: (template) => contributions.registerPaneTemplate(pluginId, template, items),
+    registerCommand: (command) => contributions.registerCommand(pluginId, command, items),
+    registerColumn: (column) => contributions.registerColumn(pluginId, column, items),
+    registerBroker: (broker) => contributions.registerBroker(pluginId, broker, items),
+    registerCapability: (capability) => {
+      if (enableCapabilityHandlers) registerCapabilityForPlugin(pluginId, capability, items);
+    },
+    registerTickerResearchTab: (tab) => contributions.registerTickerResearchTab(pluginId, tab, items),
+    registerShortcut: (shortcut) => contributions.registerShortcut(pluginId, shortcut, items),
+    registerTickerAction: (action) => contributions.registerTickerAction(pluginId, action, items),
+    registerContextMenuProvider: (provider) => contributions.registerContextMenuProvider(pluginId, provider, items),
+    watchNewsQuery: (query, listener) => {
+      const dispose = watchNewsQuery(query, listener);
+      items.newsQueryWatchDisposers.push(dispose);
+      return dispose;
+    },
+
+    getData,
+    getTicker,
+    getConfig,
+    getPaneDef: (paneId) => contributions.panesMap.get(paneId),
+
+    marketData,
+    tickerRepository,
+    persistence: pluginPersistence,
+    log,
+    resume,
+    paneSettings,
+    configState: {
+      get: getConfigState,
+      set: setConfigState,
+      delete: deleteConfigState,
+      keys: getConfigStateKeys,
+    },
+
+    createBrokerInstance,
+    updateBrokerInstance,
+    syncBrokerInstance,
+    removeBrokerInstance,
+
+    selectTicker,
+    switchPanel,
+    switchTab,
+    openCommandBar,
+    showPane,
+    createPaneFromTemplate,
+    hidePane,
+    focusPane,
+    pinTicker,
+    navigateTicker,
+    openPaneSettings,
+
+    on: (event, handler) => {
+      const dispose = events.on(event, handler);
+      items.eventDisposers.push(dispose);
+      return dispose;
+    },
+    emit: (event, payload) => events.emit(event, payload),
+
+    notify,
+  };
+}