gloomberb 0.5.0 → 0.6.0

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

@@ -1,14 +1,17 @@
 import { act, useMemo, useReducer, useRef } from "react";
-import type { ScrollBoxRenderable } from "@opentui/core";
+import type { ScrollBoxRenderable } from "#opentui/core";
+import { PaneFooterBar, PaneFooterProvider } from "../../components/layout/pane-footer";
 import {
   AppContext,
   appReducer,
   createInitialState,
   PaneInstanceProvider,
 } from "../../state/app-context";
+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,
@@ -133,42 +136,7 @@ export function createConfig(options?: {
 }
 
 export function createRuntime(): PluginRuntimeAccess {
-  const resumeState = new Map<string, unknown>();
-  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());
-      listeners.get(listenerKey)!.add(listener);
-      return () => {
-        listeners.get(listenerKey)?.delete(listener);
-      };
-    },
-    getResumeState(pluginId, key) {
-      return (resumeState.get(`${pluginId}:${key}`) as any) ?? null;
-    },
-    setResumeState(pluginId, key, value) {
-      const listenerKey = `${pluginId}:${key}`;
-      resumeState.set(listenerKey, value);
-      for (const listener of listeners.get(listenerKey) ?? []) listener();
-    },
-    deleteResumeState(pluginId, key) {
-      const listenerKey = `${pluginId}:${key}`;
-      resumeState.delete(listenerKey);
-      for (const listener of listeners.get(listenerKey) ?? []) listener();
-    },
-    getConfigState() {
-      return null;
-    },
-    async setConfigState() {},
-    async deleteConfigState() {},
-    getConfigStateKeys() {
-      return [];
-    },
-  };
+  return createStatefulTestPluginRuntime();
 }
 
 export function installPredictionMarketMocks() {
@@ -456,13 +424,20 @@ export function Harness({
     <AppContext value={{ state, dispatch }}>
       <PaneInstanceProvider paneId={TEST_PANE_ID}>
         <PluginRenderProvider pluginId="prediction-markets" runtime={runtime}>
-          <PredictionMarketsPane
-            paneId={TEST_PANE_ID}
-            paneType="prediction-markets"
-            focused={state.focusedPaneId === TEST_PANE_ID}
-            width={120}
-            height={34}
-          />
+          <PaneFooterProvider>
+            {(footer) => (
+              <Box flexDirection="column" width={120} height={34}>
+                <PredictionMarketsPane
+                  paneId={TEST_PANE_ID}
+                  paneType="prediction-markets"
+                  focused={state.focusedPaneId === TEST_PANE_ID}
+                  width={120}
+                  height={33}
+                />
+                <PaneFooterBar footer={footer} focused={state.focusedPaneId === TEST_PANE_ID} width={120} />
+              </Box>
+            )}
+          </PaneFooterProvider>
         </PluginRenderProvider>
       </PaneInstanceProvider>
     </AppContext>

package/src/plugins/registry.test.ts

@@ -0,0 +1,307 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { AppPersistence } from "../data/app-persistence";
+import { TickerRepository } from "../data/ticker-repository";
+import { createDefaultConfig } from "../types/config";
+import type { DataProvider } from "../types/data-provider";
+import type { GloomPlugin, GloomPluginContext } from "../types/plugin";
+import { assetDataProvider } from "../capabilities";
+import { PluginRegistry } from "./registry";
+
+const dataProvider: DataProvider = {
+  id: "test-provider",
+  name: "Test Provider",
+  getTickerFinancials: async () => ({ annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+  getQuote: async (symbol) => ({
+    symbol,
+    price: 1,
+    currency: "USD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.now(),
+  }),
+  getExchangeRate: async () => 1,
+  search: async () => [],
+  getArticleSummary: async () => null,
+  getPriceHistory: async () => [],
+};
+
+let currentRegistry: PluginRegistry | null = null;
+let currentPersistence: AppPersistence | null = null;
+
+function createRegistry(options: {
+  disabledPlugins?: string[];
+  disabledSources?: string[];
+  enableCapabilityHandlers?: boolean;
+} = {}): PluginRegistry {
+  const persistence = new AppPersistence(":memory:");
+  const registry = new PluginRegistry(
+    dataProvider,
+    new TickerRepository(persistence.tickers),
+    persistence,
+    { enableCapabilityHandlers: options.enableCapabilityHandlers },
+  );
+  registry.getConfigFn = () => ({
+    ...createDefaultConfig("/tmp/gloomberb-context-menu-test"),
+    disabledPlugins: options.disabledPlugins ?? [],
+    disabledSources: options.disabledSources ?? [],
+  });
+  currentRegistry = registry;
+  currentPersistence = persistence;
+  return registry;
+}
+
+function plugin(id: string, setup: (ctx: GloomPluginContext) => void): GloomPlugin {
+  return {
+    id,
+    name: id,
+    version: "1.0.0",
+    setup,
+  };
+}
+
+function contextMenuLabels(items: ReturnType<PluginRegistry["getContextMenuItems"]>): string[] {
+  return items.flatMap((item) => item.type === "divider" || !item.label ? [] : [item.label]);
+}
+
+afterEach(() => {
+  currentRegistry?.destroy();
+  currentRegistry = null;
+  currentPersistence?.close();
+  currentPersistence = null;
+});
+
+describe("PluginRegistry context menu providers", () => {
+  test("registers and unregisters context menu providers", async () => {
+    const registry = createRegistry();
+    await registry.register(plugin("tools", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "app-menu",
+        contexts: ["app"],
+        getItems: () => [{ id: "tools:item", label: "Tools Item" }],
+      });
+    }));
+
+    expect(contextMenuLabels(registry.getContextMenuItems({ kind: "app" }))).toEqual(["Tools Item"]);
+
+    registry.unregister("tools");
+    expect(registry.getContextMenuItems({ kind: "app" })).toEqual([]);
+  });
+
+  test("orders providers by order, plugin id, and provider id", async () => {
+    const registry = createRegistry();
+    await registry.register(plugin("z-plugin", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "z-provider",
+        order: 20,
+        getItems: () => [{ id: "z", label: "Z" }],
+      });
+    }));
+    await registry.register(plugin("a-plugin", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "b-provider",
+        order: 10,
+        getItems: () => [{ id: "a-b", label: "A/B" }],
+      });
+      ctx.registerContextMenuProvider({
+        id: "a-provider",
+        order: 10,
+        getItems: () => [{ id: "a-a", label: "A/A" }],
+      });
+    }));
+
+    expect(contextMenuLabels(registry.getContextMenuItems({ kind: "app" }))).toEqual([
+      "A/A",
+      "A/B",
+      "Z",
+    ]);
+  });
+
+  test("filters providers from disabled plugins", async () => {
+    const registry = createRegistry({ disabledPlugins: ["disabled-tools"] });
+    await registry.register(plugin("disabled-tools", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "hidden",
+        getItems: () => [{ id: "hidden", label: "Hidden" }],
+      });
+    }));
+    await registry.register(plugin("enabled-tools", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "visible",
+        getItems: () => [{ id: "visible", label: "Visible" }],
+      });
+    }));
+
+    expect(contextMenuLabels(registry.getContextMenuItems({ kind: "app" }))).toEqual(["Visible"]);
+  });
+
+  test("provider exceptions do not prevent other provider items", async () => {
+    const registry = createRegistry();
+    await registry.register(plugin("bad-tools", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "throws",
+        getItems: () => {
+          throw new Error("boom");
+        },
+      });
+    }));
+    await registry.register(plugin("good-tools", (ctx) => {
+      ctx.registerContextMenuProvider({
+        id: "works",
+        getItems: () => [{ id: "works", label: "Works" }],
+      });
+    }));
+
+    expect(contextMenuLabels(registry.getContextMenuItems({ kind: "app" }))).toEqual(["Works"]);
+  });
+});
+
+describe("PluginRegistry capabilities", () => {
+  const source = (id: string) => assetDataProvider({ ...dataProvider, id, name: id });
+
+  test("disabled plugins disable their contributed capabilities", async () => {
+    const registry = createRegistry({ disabledPlugins: ["source-plugin"] });
+    await registry.register({
+      id: "source-plugin",
+      name: "Source Plugin",
+      version: "1.0.0",
+      capabilities: [source("source-a")],
+    });
+
+    expect(registry.getCapability("asset-data.source-a")?.sourceId).toBe("source-a");
+    expect(registry.getCapabilityPluginId("asset-data.source-a")).toBe("source-plugin");
+    expect(registry.getEnabledCapabilities("asset-data")).toEqual([]);
+  });
+
+  test("disabledSources disables only the matching capability source", async () => {
+    const registry = createRegistry({ disabledSources: ["source-a"] });
+    await registry.register({
+      id: "source-plugin",
+      name: "Source Plugin",
+      version: "1.0.0",
+      capabilities: [source("source-a"), source("source-b")],
+    });
+
+    expect(registry.getEnabledCapabilities("asset-data").map((entry) => entry.sourceId)).toEqual(["source-b"]);
+  });
+
+  test("can skip plugin capability handlers in renderer registries", async () => {
+    const registry = createRegistry({ enableCapabilityHandlers: false });
+    await registry.register({
+      id: "source-plugin",
+      name: "Source Plugin",
+      version: "1.0.0",
+      capabilities: [source("source-a")],
+      setup(ctx) {
+        ctx.registerCapability(source("source-b"));
+      },
+    });
+
+    expect(registry.getCapability("asset-data.source-a")).toBeNull();
+    expect(registry.getCapability("asset-data.source-b")).toBeNull();
+    expect(registry.getEnabledCapabilities("asset-data")).toEqual([]);
+  });
+});
+
+describe("PluginRegistry detail tabs", () => {
+  test("tracks the owning plugin for registered detail tabs", async () => {
+    const registry = createRegistry();
+    await registry.register(plugin("company-research", (ctx) => {
+      ctx.registerDetailTab({
+        id: "sec",
+        name: "SEC",
+        order: 45,
+        component: () => null,
+      });
+    }));
+
+    expect(registry.getDetailTabPluginId("sec")).toBe("company-research");
+
+    registry.unregister("company-research");
+    expect(registry.getDetailTabPluginId("sec")).toBeUndefined();
+  });
+});
+
+describe("PluginRegistry pane settings", () => {
+  test("resolves plugin-scoped pane setting values from plugin config", async () => {
+    const registry = createRegistry();
+    const config = createDefaultConfig("/tmp/gloomberb-pane-settings-test");
+    config.layout = {
+      dockRoot: { kind: "pane", instanceId: "test-pane:main" },
+      instances: [{
+        instanceId: "test-pane:main",
+        paneId: "test-pane",
+        binding: { kind: "none" },
+        settings: { breakingNewsNotificationsEnabled: false },
+      }],
+      floating: [],
+      detached: [],
+    };
+    config.pluginConfig = {
+      news: { breakingNewsNotificationsEnabled: true },
+    };
+    registry.getConfigFn = () => config;
+    registry.getLayoutFn = () => config.layout;
+
+    await registry.register(plugin("news", (ctx) => {
+      ctx.registerPane({
+        id: "test-pane",
+        name: "Test Pane",
+        defaultPosition: "right",
+        component: () => null,
+        settings: {
+          fields: [{
+            key: "breakingNewsNotificationsEnabled",
+            label: "Notifications",
+            type: "toggle",
+            storage: "plugin",
+          }],
+        },
+      });
+    }));
+
+    const descriptor = registry.resolvePaneSettings("test-pane:main");
+
+    expect(descriptor?.pluginId).toBe("news");
+    expect(descriptor?.context.settings.breakingNewsNotificationsEnabled).toBe(true);
+  });
+});
+
+describe("PluginRegistry broker runtime", () => {
+  test("exposes broker adapters and broker instance operations to rendered panes", async () => {
+    const registry = createRegistry();
+    const broker = {
+      id: "demo",
+      name: "Demo",
+      configSchema: [],
+      validate: async () => true,
+      importPositions: async () => [],
+    };
+    const calls: string[] = [];
+    registry.connectBrokerInstanceFn = async (instanceId) => { calls.push(`connect:${instanceId}`); };
+    registry.updateBrokerInstanceFn = async (instanceId, values, options) => {
+      calls.push(`update:${instanceId}:${values.mode}:${options?.replaceConfig ? "replace" : "merge"}`);
+    };
+    registry.syncBrokerInstanceFn = async (instanceId) => { calls.push(`sync:${instanceId}`); };
+    registry.removeBrokerInstanceFn = async (instanceId) => { calls.push(`remove:${instanceId}`); };
+
+    await registry.register({
+      id: "demo-plugin",
+      name: "Demo Plugin",
+      version: "1.0.0",
+      broker,
+    });
+
+    expect(registry.getBrokerAdapter("demo")).toBe(broker);
+    await registry.connectBrokerInstance("demo-live");
+    await registry.updateBrokerInstance("demo-live", { mode: "paper" }, { replaceConfig: true });
+    await registry.syncBrokerInstance("demo-live");
+    await registry.removeBrokerInstance("demo-live");
+
+    expect(calls).toEqual([
+      "connect:demo-live",
+      "update:demo-live:paper:replace",
+      "sync:demo-live",
+      "remove:demo-live",
+    ]);
+  });
+});