gloomberb 0.11.2 → 0.12.0

package/src/plugins/registry/pane-settings.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import { registerPaneTableExporter } from "../../state/pane-table-export-registry";
+import { createDefaultConfig } from "../../types/config";
+import type { AppNotificationRequest, PaneDef } from "../../types/plugin";
+import { resolveRegistryPaneSettings } from "./pane-settings";
+
+test("adds a working CSV action to exportable table panes", async () => {
+  const pane = { instanceId: "prices:main", paneId: "prices", title: "Market Prices" };
+  const config = createDefaultConfig("/tmp/gloomberb-pane-export-test");
+  config.layout.instances = [pane];
+  const filenames: string[] = [];
+  const unregister = registerPaneTableExporter(pane.instanceId, async (filename) => {
+    filenames.push(filename);
+    return `~/Downloads/${filename}`;
+  });
+
+  try {
+    const paneDef: PaneDef = {
+      id: pane.paneId,
+      name: "Prices",
+      component: () => null,
+      defaultPosition: "right",
+      tableExport: true,
+    };
+    const resolved = resolveRegistryPaneSettings({
+      config,
+      getConfigState: () => null,
+      getPaneRuntimeState: () => null,
+      layout: config.layout,
+      paneDefs: new Map([[pane.paneId, paneDef]]),
+      paneOwners: new Map(),
+      resolvePaneTarget: () => pane.instanceId,
+      requestedPaneId: pane.instanceId,
+    });
+    const field = resolved?.settingsDef.fields[0];
+    expect(field).toMatchObject({ type: "action", label: "Export CSV", disabled: false });
+    if (!field || field.type !== "action" || !resolved) throw new Error("Missing export action");
+
+    const notifications: AppNotificationRequest[] = [];
+    await field.action({
+      ...resolved.context,
+      surface: "pane-dialog",
+      close: () => {},
+      openCommandBar: () => {},
+      notify: (notification) => notifications.push(notification),
+    });
+
+    expect(filenames[0]).toMatch(/^Market-Prices-.*\.csv$/);
+    expect(notifications[0]).toMatchObject({ type: "success" });
+  } finally {
+    unregister();
+  }
+});

package/src/plugins/registry/pane-settings.ts

@@ -12,6 +12,10 @@ import type {
   PaneSettingsContext,
   PaneSettingsDef,
 } from "../../types/plugin";
+import {
+  exportPaneTableCsv,
+  hasPaneTableExporter,
+} from "../../state/pane-table-export-registry";
 
 export interface ResolvedRegistryPaneSettings {
   paneId: string;
@@ -76,7 +80,7 @@ export function resolveRegistryPaneSettings({
   if (!pane) return null;
 
   const paneDef = paneDefs.get(pane.paneId);
-  if (!paneDef?.settings) return null;
+  if (!paneDef || (!paneDef.settings && !paneDef.tableExport)) return null;
 
   const pluginId = paneOwners.get(pane.paneId);
   const paneSettings = getPaneSettings(pane);
@@ -99,10 +103,32 @@ export function resolveRegistryPaneSettings({
     activeTicker: resolveTickerForPane(stateView, targetPaneId),
     activeCollectionId: resolveCollectionForPane(stateView, targetPaneId),
   };
-  const settingsDef = typeof paneDef.settings === "function"
+  const baseSettingsDef = typeof paneDef.settings === "function"
     ? paneDef.settings(context)
     : paneDef.settings;
-  if (!settingsDef) return null;
+  if (!baseSettingsDef && !paneDef.tableExport) return null;
+  const settingsDef: PaneSettingsDef = paneDef.tableExport
+    ? {
+      ...(baseSettingsDef ?? {}),
+      fields: [
+        ...(baseSettingsDef?.fields ?? []),
+        {
+          key: "tableExport.csv",
+          label: "Export CSV",
+          description: "Export the current table as an Excel-compatible CSV file.",
+          type: "action",
+          actionId: "table.export-csv",
+          actionLabel: "Export",
+          disabled: !hasPaneTableExporter(targetPaneId),
+          action: (actionContext) => exportPaneTableCsv(
+            targetPaneId,
+            pane.title ?? paneDef.name,
+            actionContext.notify,
+          ),
+        },
+      ],
+    }
+    : baseSettingsDef!;
 
   const rawSettings = { ...paneSettings };
   const resolvedSettings = {

package/src/plugins/seed.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { EXTRACTED_PLUGINS, seedExtractedPlugins } from "./seed";
+import type { AppConfig } from "../types/config";
+
+/**
+ * Extracting a built-in plugin is the one change here that can quietly take a
+ * working feature away from an existing user, so the seeding rules are worth
+ * pinning: restore it once, never fight a deliberate removal, and never record
+ * a failure as done — being offline at startup is common, and marking it seeded
+ * would drop the plugin permanently.
+ */
+function config(overrides: Partial<AppConfig> = {}): AppConfig {
+  return { disabledPlugins: [], seededPlugins: [], ...overrides } as AppConfig;
+}
+
+function withPluginsDir<T>(setup: (dir: string) => T): T {
+  const dir = mkdtempSync(join(tmpdir(), "gloom-seed-"));
+  try {
+    return setup(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe("seedExtractedPlugins", () => {
+  test("installs an extracted plugin the user has not seen", async () => {
+    const installs: string[] = [];
+    const result = await withPluginsDir((dir) => seedExtractedPlugins(config(), async (ref) => {
+      installs.push(ref);
+    }, dir));
+
+    expect(installs).toEqual(EXTRACTED_PLUGINS.map((entry) => entry.repo));
+    expect(result.installed).toEqual(EXTRACTED_PLUGINS.map((entry) => entry.id));
+    expect(result.seeded).toEqual(EXTRACTED_PLUGINS.map((entry) => entry.id));
+  });
+
+  test("does nothing once a plugin has been seeded", async () => {
+    const installs: string[] = [];
+    const seeded = EXTRACTED_PLUGINS.map((entry) => entry.id);
+    await withPluginsDir((dir) => seedExtractedPlugins(config({ seededPlugins: seeded }), async (ref) => {
+      installs.push(ref);
+    }, dir));
+
+    expect(installs).toEqual([]);
+  });
+
+  test("respects a plugin the user disabled before the move", async () => {
+    const installs: string[] = [];
+    const result = await withPluginsDir((dir) => seedExtractedPlugins(
+      config({ disabledPlugins: ["substack"] }),
+      async (ref) => { installs.push(ref); },
+      dir,
+    ));
+
+    expect(installs).not.toContain("gloom-sh/gloomberb-substack");
+    // Recorded, so we stop asking rather than retrying every launch.
+    expect(result.seeded).toContain("substack");
+  });
+
+  test("records a plugin that is already installed without reinstalling it", async () => {
+    const installs: string[] = [];
+    const result = await withPluginsDir((pluginsDir) => {
+      mkdirSync(join(pluginsDir, "gloomberb-substack"), { recursive: true });
+      return seedExtractedPlugins(config(), async (ref) => { installs.push(ref); }, pluginsDir);
+    });
+
+    expect(installs).not.toContain("gloom-sh/gloomberb-substack");
+    expect(result.seeded).toContain("substack");
+  });
+
+  test("retries next launch instead of recording a failed install", async () => {
+    const result = await withPluginsDir((dir) => seedExtractedPlugins(config(), async () => {
+      throw new Error("offline");
+    }, dir));
+
+    expect(result.failed).toContain("substack");
+    expect(result.seeded).not.toContain("substack");
+  });
+});

package/src/plugins/seed.ts

@@ -0,0 +1,80 @@
+import { existsSync } from "fs";
+import { join } from "path";
+
+import type { AppConfig } from "../types/config";
+import { debugLog } from "../utils/debug-log";
+import { getPluginsDir } from "./loader";
+
+const log = debugLog.createLogger("plugin-seed");
+
+/**
+ * Plugins that used to ship inside Gloomberb and now live in their own
+ * repositories.
+ *
+ * Extracting one must not take a working feature away from someone who upgrades.
+ * On first launch after the move, each of these is installed once, then recorded
+ * so it is never reinstalled — including when the user removes it deliberately.
+ */
+export const EXTRACTED_PLUGINS = [
+  { id: "substack", repo: "gloom-sh/gloomberb-substack", directory: "gloomberb-substack" },
+  { id: "ibkr", repo: "gloom-sh/gloomberb-ibkr", directory: "gloomberb-ibkr" },
+  { id: "ibkr-gateway", repo: "gloom-sh/gloomberb-ibkr-gateway", directory: "gloomberb-ibkr-gateway" },
+] as const;
+
+export interface SeedResult {
+  installed: string[];
+  failed: string[];
+  /** Ids to record as seeded, whether or not this launch installed them. */
+  seeded: string[];
+}
+
+function isInstalled(directory: string, pluginsDir: string): boolean {
+  return existsSync(join(pluginsDir, directory));
+}
+
+/**
+ * Installs any extracted plugin the user has not seen yet.
+ *
+ * Best effort by design: a failure is logged and retried on the next launch
+ * rather than recorded, because the common cause is being offline at startup and
+ * marking it seeded would silently drop the plugin forever.
+ */
+export async function seedExtractedPlugins(
+  config: AppConfig,
+  installPlugin: (ref: string) => Promise<void>,
+  pluginsDir: string = getPluginsDir(),
+): Promise<SeedResult> {
+  const alreadySeeded = new Set(config.seededPlugins ?? []);
+  const disabled = new Set(config.disabledPlugins ?? []);
+
+  const result: SeedResult = { installed: [], failed: [], seeded: [...alreadySeeded] };
+
+  for (const entry of EXTRACTED_PLUGINS) {
+    if (alreadySeeded.has(entry.id)) continue;
+
+    // Present already: either installed by hand or seeded before this record
+    // existed. Mark it so we stop looking.
+    if (isInstalled(entry.directory, pluginsDir)) {
+      result.seeded.push(entry.id);
+      continue;
+    }
+
+    // Turned off before the move: restoring it would override that choice.
+    if (disabled.has(entry.id)) {
+      result.seeded.push(entry.id);
+      continue;
+    }
+
+    try {
+      log.info(`Restoring ${entry.id} from ${entry.repo}`);
+      await installPlugin(entry.repo);
+      result.installed.push(entry.id);
+      result.seeded.push(entry.id);
+    } catch (error) {
+      log.error(`Could not restore ${entry.id}: ${error}`);
+      result.failed.push(entry.id);
+    }
+  }
+
+  return result;
+}

package/src/public/broker.ts

@@ -0,0 +1,31 @@
+/**
+ * Broker plugin surface (`gloomberb/broker`).
+ *
+ * A broker plugin needs three things the generic plugin API does not cover: the
+ * account cache the app reads positions from, a resource store for cached
+ * fetches, and — on the desktop — a client for reaching its own Bun-side service
+ * from the view, since the renderer cannot open sockets itself.
+ */
+export { getBrokerRemoteClient, setBrokerRemoteClient } from "../brokers/remote-broker-adapter";
+export type { BrokerRemoteClient } from "../brokers/remote-broker-adapter";
+export type { ResourceStore } from "../data/resource-store";
+export { resolveTickerFinancialsForInstrument } from "../market-data/coordinator";
+
+/**
+ * The app's cached-resource store, for plugins that persist fetched data across
+ * restarts. Set by the host at startup and cleared on teardown.
+ *
+ * A plugin should treat a null store as "no cache available" and still work,
+ * since it is absent before services are constructed.
+ */
+let pluginResourceStore: import("../data/resource-store").ResourceStore | null = null;
+
+export function setPluginResourceStore(
+  store: import("../data/resource-store").ResourceStore | null,
+): void {
+  pluginResourceStore = store;
+}
+
+export function getPluginResourceStore(): import("../data/resource-store").ResourceStore | null {
+  return pluginResourceStore;
+}

package/src/public/market-data.ts

@@ -0,0 +1,9 @@
+/**
+ * Market-data request shapes and price formatting (`gloomberb/market-data`).
+ *
+ * A plugin that provides quotes or history has to build the same request
+ * objects the host does, and format prices the same way, or its output looks
+ * foreign next to first-party panes.
+ */
+export * from "../market-data/request-types";
+export * from "../market-data/market/format";

package/src/public/pane-hooks.ts

@@ -0,0 +1,57 @@
+/**
+ * App-state hooks a plugin pane legitimately needs.
+ *
+ * These exist so plugins do not import `state/app/context` directly. That module
+ * is the app's internal store: exposing it would let a plugin read and dispatch
+ * anything, and would make every refactor of app state a breaking change for
+ * plugins. Each hook here is a narrow, named read.
+ */
+import { useEffect } from "react";
+
+import {
+  useAppDispatch,
+  useAppSelector,
+  usePaneCollection as usePaneCollectionInternal,
+  usePaneInstanceId as usePaneInstanceIdInternal,
+  usePaneTicker as usePaneTickerInternal,
+} from "../state/app/context";
+import type { AppConfig } from "../types/config";
+import type { AppState } from "../state/app/context";
+
+export function useAppConfig(): AppConfig {
+  return useAppSelector((state) => state.config);
+}
+
+export function useBrokerAccounts(): AppState["brokerAccounts"] {
+  return useAppSelector((state) => state.brokerAccounts);
+}
+
+export function useTickers(): AppState["tickers"] {
+  return useAppSelector((state) => state.tickers);
+}
+
+/**
+ * Escape hatches for panes that need state this module has not named yet.
+ * Prefer a named hook above: these expose the app store directly, so anything
+ * built on them is coupled to its shape.
+ */
+export { AppContext, PaneInstanceProvider, useAppDispatch, useAppSelector } from "../state/app/context";
+
+export const usePaneInstanceId = usePaneInstanceIdInternal;
+export const usePaneCollection = usePaneCollectionInternal;
+export const usePaneTicker = usePaneTickerInternal;
+
+/**
+ * Declares that this pane owns keyboard input while `captured` is true, so the
+ * app stops routing keys to global shortcuts. Released automatically on unmount.
+ */
+export function useInputCapture(captured: boolean): void {
+  const dispatch = useAppDispatch();
+  useEffect(() => {
+    if (!captured) return;
+    dispatch({ type: "SET_INPUT_CAPTURED", captured: true });
+    return () => {
+      dispatch({ type: "SET_INPUT_CAPTURED", captured: false });
+    };
+  }, [captured, dispatch]);
+}

package/src/public/public-api.test.ts

@@ -0,0 +1,285 @@
+import { describe, expect, test } from "bun:test";
+
+import * as capabilities from "../capabilities";
+import * as components from "../components";
+import * as theme from "../theme/colors";
+import * as ui from "../ui";
+import * as pluginReact from "./react";
+import * as testSupport from "./test-support";
+import * as utils from "./utils";
+
+/**
+ * The public plugin API is a compatibility boundary: plugins in other
+ * repositories (gloom-sh/gloomberb-substack, -ibkr, -hackernews, and any
+ * community plugin) import these subpaths, and a rename here breaks them
+ * silently at their next install rather than in this repo's CI.
+ *
+ * Adding an export is deliberate — update the list below in the same commit.
+ * Removing or renaming one is a breaking change for every installed plugin and
+ * needs a major version plus a migration note in PLUGINS.md.
+ */
+const PUBLIC_API: Record<string, readonly string[]> = {
+  "ui": [
+    "AsciiText",
+    "Box",
+    "ChartSurface",
+    "ContextMenuProvider",
+    "ImageSurface",
+    "Input",
+    "MediaSurface",
+    "RGBA",
+    "ScrollBox",
+    "Span",
+    "SpinnerMark",
+    "Strong",
+    "StyledText",
+    "Text",
+    "TextAttributes",
+    "Textarea",
+    "UiHostProvider",
+    "Underline",
+    "compactContextMenuItems",
+    "contextMenuDivider",
+    "editableTextContextMenuItems",
+    "linkContextMenuItems",
+    "tickerContextMenuItems",
+    "useCommandBarShortcut",
+    "useContextMenu",
+    "useNativeRenderer",
+    "useRendererHost",
+    "useSyntaxStyleFactory",
+    "useTickerContextMenu",
+    "useUiCapabilities",
+    "useUiHost",
+  ],
+  "components": [
+    "Button",
+    "Checkbox",
+    "ChoiceDialog",
+    "ConfirmDialog",
+    "DataTableStackView",
+    "DataTableView",
+    "EmptyState",
+    "FeedDataTableStackView",
+    "InputSearchBar",
+    "MessageComposer",
+    "MetricTreemapSurface",
+    "NumberField",
+    "PaneFooterScope",
+    "PaneSidebar",
+    "PaneSidebarAction",
+    "PaneSidebarRow",
+    "PaneStatusBody",
+    "PriceSelectorDialog",
+    "RemoteImage",
+    "SegmentedControl",
+    "SelectButton",
+    "SpeedometerGauge",
+    "Spinner",
+    "StaticChartSurface",
+    "Tabs",
+    "TextField",
+    "TickerBadgeList",
+    "TickerBadgeText",
+    "TickerListTableView",
+    "activeStackIndex",
+    "buildMetricTreemapNavigationTiles",
+    "findMetricTreemapNeighbor",
+    "getMessageComposerBlockHeight",
+    "getPaneSidebarWidth",
+    "isTableScrollNearEnd",
+    "loadingText",
+    "shouldShowPaneSidebar",
+    "sortStackItems",
+    "unavailableText",
+    "useExternalLinkFooter",
+    "usePaneFooter",
+    "usePaneTicker",
+    "useTableLoadMore",
+  ],
+  "theme": [
+    "applyTheme",
+    "blendHex",
+    "clearTransientThemePreview",
+    "colors",
+    "commandBarAccentText",
+    "commandBarBadgeText",
+    "commandBarBg",
+    "commandBarHeadingText",
+    "commandBarHoverBg",
+    "commandBarInputBg",
+    "commandBarMatchText",
+    "commandBarPanelBg",
+    "commandBarSelectedBg",
+    "commandBarSelectedText",
+    "commandBarSubtleText",
+    "commandBarText",
+    "floatingPaneBg",
+    "floatingPaneTitleBg",
+    "getChartIndicatorColor",
+    "getCurrentThemeId",
+    "getThemeColors",
+    "hoverBg",
+    "paneBg",
+    "paneTitleBg",
+    "paneTitleText",
+    "previewTheme",
+    "priceColor",
+    "syncTheme",
+  ],
+  "capabilities": [
+    "AI_RUNNER_CAPABILITY_ID",
+    "BROKER_CAPABILITY_ID",
+    "CHART_SERIES_CAPABILITY_KIND",
+    "CapabilityRegistry",
+    "MAX_CHART_SERIES_CATALOG_ITEMS",
+    "MAX_CHART_SERIES_POINTS",
+    "NOTES_FILES_CAPABILITY_ID",
+    "assetDataProvider",
+    "chartSeriesCapabilityManifests",
+    "chartSeriesCatalogOutputSchema",
+    "chartSeriesCatalogRequestSchema",
+    "chartSeriesProvider",
+    "chartSeriesResolveOutputSchema",
+    "chartSeriesResolveRequestSchema",
+    "chartSeriesSourceKey",
+    "createChartSeriesResolver",
+    "isValidChartCapabilityId",
+    "isValidChartSeriesId",
+    "newsProvider",
+    "recordSchema",
+    "searchChartSeriesCapabilities",
+  ],
+  "utils": [
+    "buildBrokerPortfolioId",
+    "canonicalExchange",
+    "canonicalTickerKey",
+    "createBrokerInstanceId",
+    "createThrottledFetch",
+    "debugLog",
+    "decodeHtmlEntities",
+    "displayWidth",
+    "fnv1aHashString",
+    "formatCompact",
+    "formatCompactCurrency",
+    "formatCurrency",
+    "formatGrowthShort",
+    "formatNumber",
+    "formatPercent",
+    "formatPercentRaw",
+    "formatRelativeAge",
+    "formatTimeAgo",
+    "formatWithDivisor",
+    "getBrokerInstance",
+    "getBrokerInstancesByType",
+    "hasLikelyQuoteUnitMismatch",
+    "httpFetch",
+    "isBrokerPortfolioId",
+    "isPlainKey",
+    "isPlainKeyboardEvent",
+    "normalizePriceValueByDivisor",
+    "normalizeSymbol",
+    "normalizedHttpUrl",
+    "padTo",
+    "parsePublicTickerKey",
+    "pickUnit",
+    "publicExchange",
+    "publicTickerKey",
+    "resolveCurrencyUnit",
+    "resolveExchangeSubUnitCurrencyUnit",
+    "resolveExchangeTimeZone",
+    "resolvePriceHistoryCurrencyUnit",
+    "setHttpFetchTransport",
+    "splitLongTextSegmentByDisplayWidth",
+    "truncateToDisplayWidth",
+    "truncateWithEllipsis",
+    "wrapTextLines",
+  ],
+
+  "react": [
+    "AppContext",
+    "DEFAULT_MAX_READ_IDS",
+    "PaneInstanceProvider",
+    "deletePluginPaneStateValue",
+    "getPluginPaneStateValue",
+    "markPersistedReadId",
+    "normalizePersistedReadIdState",
+    "setPluginPaneStateValue",
+    "useAppConfig",
+    "useAppDispatch",
+    "useAppSelector",
+    "useAssetData",
+    "useBrokerAccounts",
+    "useCapabilityInvoker",
+    "useConnectionHealth",
+    "useDebouncedPluginPaneState",
+    "useInlineTickerOpener",
+    "useInlineTickers",
+    "useInputCapture",
+    "useMarketData",
+    "usePaneCollection",
+    "usePaneInstanceId",
+    "usePaneTicker",
+    "usePersistedReadIds",
+    "usePluginAppActions",
+    "usePluginBrokerActions",
+    "usePluginConfigState",
+    "usePluginPaneActions",
+    "usePluginPaneState",
+    "usePluginState",
+    "usePluginTickerActions",
+    "useSetPluginConfigStates",
+    "useShortcut",
+    "useTickers",
+  ],
+
+
+
+  "test-support": [
+    "AppContext",
+    "AppPersistence",
+    "MemoryPluginPersistence",
+    "PaneInstanceProvider",
+    "TestDialogProvider",
+    "clearPersistedBrokerAccounts",
+    "createInitialState",
+    "getBrokerAccountCacheSourceKey",
+    "loadPersistedBrokerAccountMap",
+    "loadPersistedBrokerAccounts",
+    "persistBrokerAccounts",
+    "testRender",
+  ],
+
+};
+
+const MODULES: Record<string, Record<string, unknown>> = {
+  ui,
+  components,
+  theme,
+  capabilities,
+  utils,
+  react: pluginReact,
+  "test-support": testSupport,
+};
+
+describe("public plugin API", () => {
+  for (const [name, expected] of Object.entries(PUBLIC_API)) {
+    test(`gloomberb/${name} exports exactly its documented surface`, () => {
+      const actual = Object.keys(MODULES[name]!)
+        .filter((key) => key !== "default")
+        .sort();
+      expect(actual).toEqual([...expected]);
+    });
+  }
+
+  test("every exports subpath in package.json resolves", async () => {
+    const pkg = JSON.parse(await Bun.file(new URL("../../package.json", import.meta.url)).text());
+    const subpaths = Object.entries(pkg.exports as Record<string, string>);
+    expect(subpaths.length).toBeGreaterThan(0);
+    for (const [subpath, target] of subpaths) {
+      if (subpath === "./package.json") continue;
+      const file = Bun.file(new URL(`../../${target.replace(/^\.\//, "")}`, import.meta.url));
+      expect(await file.exists(), `${subpath} -> ${target}`).toBe(true);
+    }
+  });
+});