gloomberb 0.13.2 → 0.14.0

package/src/core/app-runtime.test.ts

@@ -0,0 +1,113 @@
+import { afterEach, expect, test } from "bun:test";
+import { JsonPersistence } from "../data/json-persistence";
+import { JsonTickerRepository } from "../data/json-ticker-repository";
+import { getSharedMarketDataCoordinator } from "../market-data/coordinator";
+import { getSharedNewsService } from "../news/hooks";
+import { getSharedRegistry, getSharedMarketData } from "../plugins/registry";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { createDefaultConfig } from "../types/config";
+import { createAppRuntime } from "./app-runtime";
+
+const runtimes: ReturnType<typeof createAppRuntime>[] = [];
+function runtime(overrides: Partial<Parameters<typeof createAppRuntime>[0]> = {}) {
+  const services = createAppRuntime({
+    config: createDefaultConfig("/tmp/runtime-test"),
+    plugins: [],
+    persistence: new JsonPersistence(),
+    tickerRepository: new JsonTickerRepository(),
+    dataProvider: createTestDataProvider(),
+    ...overrides,
+  });
+  runtimes.push(services);
+  return services;
+}
+
+afterEach(() => { for (const services of runtimes.splice(0).reverse()) services.destroy(); });
+
+test("retiring an old runtime cannot disconnect its replacement", async () => {
+  const dataProvider = createTestDataProvider();
+  const previous = runtime({ dataProvider });
+  const current = runtime({ dataProvider });
+  await Promise.all([previous.ready, current.ready]);
+  previous.destroy();
+  expect(getSharedRegistry()).toBe(current.pluginRegistry);
+  expect(getSharedMarketData()).toBe(dataProvider);
+  expect(getSharedMarketDataCoordinator()).toBe(current.marketData);
+  expect(getSharedNewsService()).toBe(current.newsService);
+  current.destroy();
+  expect(getSharedRegistry()).toBeUndefined();
+  expect(getSharedMarketDataCoordinator()).toBeNull();
+  expect(getSharedNewsService()).toBeNull();
+});
+
+test("destroy waits for pending setup before disposing plugins and storage, and skips remote readiness", async () => {
+  const setup = Promise.withResolvers<void>();
+  const calls: string[] = [];
+  const persistence = new JsonPersistence();
+  persistence.close = () => { calls.push("close"); };
+  const services = runtime({
+    persistence,
+    plugins: [{
+      id: "late-setup", name: "Late setup", version: "1",
+      async setup(context) {
+        await setup.promise;
+        expect(calls).toEqual([]);
+        context.resume.setState("draft", "saved");
+        context.registerPane({ id: "late-pane", name: "Late pane", component: () => null });
+        calls.push("setup");
+      },
+      dispose() { calls.push("plugin"); },
+    }],
+    onReady: () => { calls.push("remote-connected"); },
+  });
+  services.destroy();
+  services.destroy();
+  expect(getSharedRegistry()).toBeUndefined();
+  setup.resolve();
+  await services.ready;
+  expect(calls).toEqual(["setup", "plugin", "close"]);
+  expect(services.pluginRegistry.panes.size).toBe(0);
+  expect(persistence.pluginState.get("late-setup", "resume:draft")?.value).toBe("saved");
+});
+
+test("teardown releases every owner and closes persistence even when a host disposer throws", async () => {
+  const calls: string[] = [];
+  const persistence = new JsonPersistence();
+  persistence.close = () => { calls.push("close"); };
+  const services = runtime({
+    persistence,
+    plugins: [{ id: "cleanup", name: "Cleanup", version: "1", dispose() { calls.push("plugin"); } }],
+    configure: () => () => { calls.push("host"); throw new Error("host failed"); },
+    onReady: () => () => { calls.push("remote"); throw new Error("remote failed"); },
+  });
+  await services.ready;
+  expect(() => services.destroy()).toThrow("App runtime teardown failed");
+  expect(calls).toEqual(["remote", "plugin", "host", "close"]);
+  expect(getSharedRegistry()).toBeUndefined();
+  expect(getSharedMarketDataCoordinator()).toBeNull();
+  expect(getSharedNewsService()).toBeNull();
+  services.destroy();
+  expect(calls).toHaveLength(4);
+});
+
+test("failed setup still waits for other plugins before closing their storage", async () => {
+  const setup = Promise.withResolvers<void>();
+  let closed = false;
+  const persistence = new JsonPersistence();
+  persistence.close = () => { closed = true; };
+  const services = runtime({
+    persistence,
+    plugins: [
+      { id: "failed", name: "Failed", version: "1", setup() { throw new Error("setup failed"); } },
+      { id: "waiting", name: "Waiting", version: "1", async setup(context) {
+        await setup.promise;
+        expect(closed).toBe(false);
+        context.resume.setState("draft", "saved");
+      } },
+    ],
+  });
+  setup.resolve();
+  await expect(services.ready).rejects.toThrow("setup failed");
+  expect(closed).toBe(true);
+  expect(getSharedRegistry()).toBeUndefined();
+});

package/src/core/app-runtime.ts

@@ -0,0 +1,97 @@
+import { MarketDataCoordinator, getSharedMarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
+import { NewsService, type NewsServiceOptions } from "../news/aggregator";
+import { getSharedNewsService, setSharedNewsService } from "../news/hooks";
+import { PluginRegistry } from "../plugins/registry";
+import { releaseSharedRegistry } from "../plugins/registry/shared";
+import type { GloomPlugin } from "../types/plugin";
+import { measurePerfAsync } from "../utils/perf-marks";
+import type { AppRuntimeServices, AppServicesFactoryOptions } from "./app-service-ports";
+
+type Dispose = () => void;
+type Runtime = AppRuntimeServices & { newsService: NewsService };
+type RuntimeModules = Pick<Runtime, "pluginRegistry" | "marketData" | "newsService">;
+
+interface AppRuntimeOptions extends AppServicesFactoryOptions, Pick<Runtime, "persistence" | "tickerRepository" | "dataProvider"> {
+  registryOptions?: ConstructorParameters<typeof PluginRegistry>[3];
+  newsOptions?: NewsServiceOptions;
+  configure?: (modules: RuntimeModules) => void | Dispose;
+  onReady?: (modules: RuntimeModules) => void | Dispose;
+  onPluginError?: (error: unknown, plugin: GloomPlugin) => void;
+}
+
+/** Hosts supply adapters; registration, shared-service ownership and disposal have one lifecycle. */
+export function createAppRuntime({
+  config, plugins, persistence, tickerRepository, dataProvider,
+  registryOptions, newsOptions, configure, onReady, onPluginError,
+}: AppRuntimeOptions): Runtime {
+  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository, persistence, registryOptions);
+  const marketData = new MarketDataCoordinator(dataProvider);
+  const newsService = new NewsService({
+    connectionHealth: pluginRegistry.connectionHealth,
+    pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60_000,
+    ...newsOptions,
+  });
+  const modules = { pluginRegistry, marketData, newsService };
+  pluginRegistry.getConfigFn = () => config;
+  pluginRegistry.getLayoutFn = () => config.layout;
+  pluginRegistry.registerNewsCapabilityFn = registryOptions?.enableCapabilityHandlers === false
+    ? () => () => {}
+    : (capability) => newsService.register(capability);
+  pluginRegistry.watchNewsQueryFn = (query, listener) => newsService.watchQuery(query, listener);
+  setSharedMarketDataCoordinator(marketData);
+  setSharedNewsService(newsService);
+
+  let destroyed = false;
+  let registering = false;
+  let disposeConfigured: void | Dispose;
+  let disposeReady: void | Dispose;
+  const dispose = (...callbacks: Array<void | Dispose>) => {
+    const errors: unknown[] = [];
+    for (const callback of callbacks) {
+      try { callback?.(); } catch (error) { errors.push(error); }
+    }
+    if (errors.length) throw new AggregateError(errors, "App runtime teardown failed");
+  };
+  const disposePlugins = () => dispose(() => pluginRegistry.destroy(), disposeConfigured, () => persistence.close());
+  const destroy = () => {
+    if (destroyed) return;
+    destroyed = true;
+    if (getSharedMarketDataCoordinator() === marketData) setSharedMarketDataCoordinator(null);
+    if (getSharedNewsService() === newsService) setSharedNewsService(null);
+    dispose(
+      disposeReady, () => newsService.stop(), () => marketData.destroy(),
+      // An async setup may still use persistence or contribute panes. Dispose it
+      // after setup settles, so it cannot write into a closed store or leak late contributions.
+      registering ? undefined : disposePlugins,
+      () => releaseSharedRegistry(pluginRegistry, dataProvider),
+    );
+  };
+
+  try {
+    disposeConfigured = configure?.(modules);
+    newsService.start();
+  } catch (error) {
+    try { destroy(); } catch { /* Preserve the startup failure. */ }
+    throw error;
+  }
+  registering = true;
+  const ready = Promise.allSettled(plugins.map((plugin) => (
+    measurePerfAsync("startup.services.register-plugin", () => pluginRegistry.register(plugin), { pluginId: plugin.id })
+      .catch((error) => { if (onPluginError) onPluginError(error, plugin); else throw error; })
+  ))).then((results) => {
+    registering = false;
+    if (destroyed) {
+      disposePlugins();
+      return;
+    }
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure?.status === "rejected") throw failure.reason;
+    const cleanup = onReady?.(modules);
+    if (destroyed) cleanup?.();
+    else disposeReady = cleanup;
+  }).catch((error) => {
+    try { destroy(); } catch { /* Preserve the startup failure. */ }
+    throw error;
+  });
+  return { persistence, tickerRepository, dataProvider, ...modules, ready, destroy };
+}

package/src/core/app-services.ts

@@ -1,112 +1,44 @@
 import { join } from "path";
-import {
-  connectionHealth,
-  registerGloomCloudConnectionSources,
-} from "./connection-health";
+import { connectionHealth, registerGloomCloudConnectionSources } from "./connection-health";
 import { AppPersistence } from "../data/app-persistence";
 import { TickerRepository } from "../data/ticker-repository";
-import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
-import { NewsService } from "../news/aggregator";
-import { setSharedNewsService } from "../news/hooks";
-import { PluginRegistry } from "../plugins/registry";
 import { AssetDataRouter } from "../sources/provider-router";
 import { assetDataProvider, newsProvider } from "../capabilities";
-import type { DataProvider } from "../types/data-provider";
-import { debugLog } from "../utils/debug-log";
-import { measurePerf, measurePerfAsync } from "../utils/perf-marks";
-import { setPluginResourceStore } from "../public/broker";
-import type { AppRuntimeServices, AppServicesFactoryOptions } from "./app-service-ports";
+import { getPluginResourceStore, setPluginResourceStore } from "../public/broker";
+import type { AppServicesFactoryOptions } from "./app-service-ports";
+import { createAppRuntime } from "./app-runtime";
 
-const servicesLog = debugLog.createLogger("services");
+export type AppServices = ReturnType<typeof createAppServices>;
 
-export interface AppServices extends AppRuntimeServices {
-  persistence: AppPersistence;
-  tickerRepository: TickerRepository;
-  providerRouter: AssetDataRouter;
-  dataProvider: DataProvider;
-  marketData: MarketDataCoordinator;
-  pluginRegistry: PluginRegistry;
-  newsService: NewsService;
-  ready: Promise<void>;
-  destroy(): void;
-}
-
-export function createAppServices({
-  config,
-  plugins,
-}: AppServicesFactoryOptions): AppServices {
-  servicesLog.info("create services start", {
-    pluginCount: plugins.length,
-    brokerInstanceCount: config.brokerInstances.length,
-  });
-  const dbPath = join(config.dataDir, ".gloomberb-cache.db");
-  const persistence = measurePerf("startup.services.persistence", () => new AppPersistence(dbPath));
-  setPluginResourceStore(persistence.resources);
-  const tickerRepository = measurePerf("startup.services.ticker-repository", () => new TickerRepository(persistence.tickers));
-  const disposeCloudConnectionSources = registerGloomCloudConnectionSources(connectionHealth);
-  const providerRouter = measurePerf("startup.services.asset-data-router", () => (
-    new AssetDataRouter(null, [], persistence.resources, connectionHealth)
-  ));
-  const dataProvider: DataProvider = providerRouter;
-  const marketData = new MarketDataCoordinator(dataProvider);
-  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository, persistence, { connectionHealth });
-  const newsService = new NewsService({
-    connectionHealth,
-    pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60 * 1000,
-  });
-  pluginRegistry.capabilities.register("core", assetDataProvider(providerRouter));
-  pluginRegistry.capabilities.register("core", {
-    ...newsProvider({
-      id: "core",
-      name: "News",
-      provider: {
-        fetchNews: async (query) => (await newsService.load(query)).articles,
-        getCachedNews: (query) => newsService.getQueryState(query).articles,
-      },
-    }),
-    // This capability exposes the aggregate service to remote renderers. Giving
-    // it the router source id prevents the router from rediscovering its own
-    // aggregate facade alongside the underlying plugin news sources.
-    sourceId: providerRouter.id,
-  });
-
-  providerRouter.attachRegistry(pluginRegistry);
-  pluginRegistry.getConfigFn = () => config;
-  pluginRegistry.getLayoutFn = () => config.layout;
-  pluginRegistry.registerNewsCapabilityFn = (capability) => newsService.register(capability);
-  pluginRegistry.watchNewsQueryFn = (query, listener) => newsService.watchQuery(query, listener);
-
-  setSharedNewsService(newsService);
-  setSharedMarketDataCoordinator(marketData);
-
-  const pluginReadyPromises: Promise<void>[] = [];
-  for (const plugin of plugins) {
-    pluginReadyPromises.push(measurePerfAsync("startup.services.register-plugin", () => (
-      pluginRegistry.register(plugin)
-    ), { pluginId: plugin.id }));
-  }
-  measurePerf("startup.services.news-start", () => {
-    newsService.start();
-  });
-  servicesLog.info("create services complete", { pluginCount: plugins.length });
-
-  return {
-    persistence,
-    tickerRepository,
-    providerRouter,
-    dataProvider,
-    marketData,
-    pluginRegistry,
-    newsService,
-    ready: Promise.all(pluginReadyPromises).then(() => {}),
-    destroy() {
-      setSharedMarketDataCoordinator(null);
-      setSharedNewsService(null);
-      newsService.stop();
-      pluginRegistry.destroy();
-      disposeCloudConnectionSources();
-      setPluginResourceStore(null);
-      persistence.close();
+export function createAppServices({ config, plugins }: AppServicesFactoryOptions) {
+  const persistence = new AppPersistence(join(config.dataDir, ".gloomberb-cache.db"));
+  const tickerRepository = new TickerRepository(persistence.tickers);
+  const providerRouter = new AssetDataRouter(null, [], persistence.resources, connectionHealth);
+  const runtime = createAppRuntime({
+    config, plugins, persistence, tickerRepository, dataProvider: providerRouter,
+    registryOptions: { connectionHealth },
+    configure({ pluginRegistry, newsService }) {
+      providerRouter.attachRegistry(pluginRegistry);
+      pluginRegistry.capabilities.register("core", assetDataProvider(providerRouter));
+      pluginRegistry.capabilities.register("core", {
+        ...newsProvider({
+          id: "core",
+          name: "News",
+          provider: {
+            fetchNews: async (query) => (await newsService.load(query)).articles,
+            getCachedNews: (query) => newsService.getQueryState(query).articles,
+          },
+        }),
+        // The router must not rediscover its own aggregate facade as a source.
+        sourceId: providerRouter.id,
+      });
+      setPluginResourceStore(persistence.resources);
+      const disposeCloudSources = registerGloomCloudConnectionSources(connectionHealth);
+      return () => {
+        if (getPluginResourceStore() === persistence.resources) setPluginResourceStore(null);
+        disposeCloudSources();
+      };
     },
-  };
+  });
+  return { ...runtime, persistence, tickerRepository, providerRouter };
 }

package/src/core/state/app/instrument.ts

@@ -0,0 +1,77 @@
+import type { AppState } from "./types";
+import { findPaneInstance, type PaneBinding } from "../../../types/config";
+import type { BrokerContractRef, TickerListingRef } from "../../../types/instrument";
+import type { TickerRecord } from "../../../types/ticker";
+import { instrumentFromTicker, type InstrumentRef } from "../../../market-data/request-types";
+import { scopedBrokerContractIdentityKey } from "../../../utils/instrument-identity";
+import { isBrokerPortfolioId } from "../../../utils/broker-instances";
+import { searchContractKey } from "../../../tickers/search/identity";
+import { resolveCollectionForPane, resolveTickerForPane } from "./layout";
+
+type InstrumentState = Pick<AppState, "config" | "paneState" | "tickers">;
+
+export function hasAmbiguousTickerContracts(ticker: TickerRecord | null | undefined): boolean {
+  return new Set((ticker?.metadata.broker_contracts ?? []).map((brokerContract) => (
+    searchContractKey({ brokerContract, type: ticker?.metadata.assetCategory || "" })
+  )).filter(Boolean)).size > 1;
+}
+
+function fixedSelection(state: InstrumentState, paneId: string, seen = new Set<string>()): Extract<PaneBinding, { kind: "fixed" }> | undefined {
+  if (seen.has(paneId)) return undefined;
+  seen.add(paneId);
+  const pane = findPaneInstance(state.config.layout, paneId);
+  if (!pane) return undefined;
+  const cursor = state.paneState[paneId]?.cursorSymbol;
+  // A row cursor owns its own target, even in a pane with a fixed default.
+  if (typeof cursor === "string" && cursor.trim()) return undefined;
+  if (pane.binding?.kind === "fixed") return pane.binding;
+  return pane.binding?.kind === "follow" ? fixedSelection(state, pane.binding.sourceInstanceId, seen) : undefined;
+}
+
+export function resolveListingForPane(state: InstrumentState, paneId: string): TickerListingRef | undefined {
+  return fixedSelection(state, paneId)?.listing;
+}
+
+/** Resolve the same instrument for a pane, its followers and restored caches. */
+export function resolveInstrumentForPane(state: InstrumentState, paneId: string): InstrumentRef | null {
+  const symbol = resolveTickerForPane(state as AppState, paneId);
+  if (!symbol) return null;
+  const ticker = state.tickers.get(symbol);
+  const selection = fixedSelection(state, paneId);
+  const instrument = selection?.instrument;
+  if (instrument === null) return { symbol, exchange: selection?.listing?.exchange || ticker?.metadata.exchange || "", instrument: null };
+  if (instrument) return {
+    symbol,
+    exchange: selection?.listing?.exchange || instrument.exchange || ticker?.metadata.exchange || "",
+    brokerId: instrument.brokerId,
+    brokerInstanceId: instrument.brokerInstanceId,
+    instrument,
+  };
+  const collectionId = resolveCollectionForPane(state as AppState, paneId);
+  const portfolioId = collectionId && (
+    isBrokerPortfolioId(collectionId) || state.config.portfolios.some((portfolio) => portfolio.id === collectionId)
+    || ticker?.metadata.positions.some((position) => position.portfolio === collectionId)
+  ) ? collectionId : undefined;
+  if (!portfolioId && hasAmbiguousTickerContracts(ticker)) return null;
+  return instrumentFromTicker(ticker, symbol, { portfolioId });
+}
+
+/** A view of one contract, without changing the shared saved ticker record. */
+export function tickerForInstrument(ticker: TickerRecord | null, instrument: BrokerContractRef | null | undefined, listing?: TickerListingRef): TickerRecord | null {
+  if (!ticker || instrument === undefined) return null;
+  if (!instrument && !listing && !ticker.metadata.broker_contracts?.length) return ticker;
+  const key = instrument ? scopedBrokerContractIdentityKey(instrument) : null;
+  const positions = ticker.metadata.positions.filter((position) => {
+    const selected = instrumentFromTicker({ ...ticker, metadata: { ...ticker.metadata, positions: [position] } }, null, { portfolioId: position.portfolio });
+    return selected && (selected.instrument ? scopedBrokerContractIdentityKey(selected.instrument) : null) === key;
+  });
+  return { ...ticker, metadata: {
+    ...ticker.metadata,
+    name: listing?.name ?? ticker.metadata.name,
+    exchange: listing?.exchange ?? instrument?.exchange ?? ticker.metadata.exchange,
+    currency: listing?.currency ?? instrument?.currency ?? (listing ? "" : ticker.metadata.currency),
+    assetCategory: listing?.type ?? instrument?.secType ?? ticker.metadata.assetCategory,
+    broker_contracts: instrument ? [instrument] : [],
+    positions,
+  } };
+}

package/src/core/state/app/layout-reducer.ts

@@ -173,6 +173,7 @@ export function reduceLayoutAction(state: AppState, action: AppAction): AppState
         name: availableLayoutName(action.name, currentConfig.layouts),
         layout: cloneLayout(action.layout),
         paneState: clonePaneStateMap(action.paneState),
+        ...(action.origin ? { origin: action.origin } : {}),
       };
       const layouts = [...currentConfig.layouts, installed];
       return withFocusedPane({
@@ -217,6 +218,65 @@ export function reduceLayoutAction(state: AppState, action: AppAction): AppState
       });
     }
 
+    case "SET_LAYOUT_ORIGIN": {
+      if (action.index < 0 || action.index >= state.config.layouts.length) return state;
+      const currentConfig = syncConfigActiveLayoutState(
+        state.config,
+        state.paneState,
+        state.focusedPaneId,
+        state.activePanel,
+      );
+      return {
+        ...state,
+        config: {
+          ...currentConfig,
+          layouts: currentConfig.layouts.map((savedLayout, index) => {
+            if (index !== action.index) return savedLayout;
+            const { origin: _origin, ...rest } = savedLayout;
+            return action.origin ? { ...rest, origin: action.origin } : rest;
+          }),
+        },
+      };
+    }
+
+    case "REPLACE_LAYOUT_CONTENT": {
+      if (action.index < 0 || action.index >= state.config.layouts.length) return state;
+      const currentConfig = syncConfigActiveLayoutState(
+        state.config,
+        state.paneState,
+        state.focusedPaneId,
+        state.activePanel,
+      );
+      const replaced: SavedLayout = {
+        ...currentConfig.layouts[action.index]!,
+        ...(action.name ? { name: action.name } : {}),
+        layout: cloneLayout(action.layout),
+        paneState: clonePaneStateMap(action.paneState),
+        focusedPaneId: null,
+        origin: action.origin,
+      };
+      const layouts = currentConfig.layouts.map((savedLayout, index) => (
+        index === action.index ? replaced : savedLayout
+      ));
+      // Pulled content replaces what the tab shows, so its undo history is
+      // no longer about this content.
+      const nextState = {
+        ...state,
+        layoutHistory: setHistoryForIndex(state.layoutHistory, action.index, { past: [], future: [] }),
+      };
+      if (action.index !== currentConfig.activeLayoutIndex) {
+        return { ...nextState, config: { ...currentConfig, layouts } };
+      }
+      return withFocusedPane(nextState, {
+        ...currentConfig,
+        layout: cloneLayout(replaced.layout),
+        layouts,
+      }, {
+        paneState: clonePaneStateMap(replaced.paneState ?? {}),
+        focusedPaneId: null,
+      });
+    }
+
     case "RENAME_LAYOUT": {
       if (action.index < 0 || action.index >= state.config.layouts.length) return state;
       const currentConfig = syncConfigActiveLayoutState(