gloomberb 0.5.1 → 0.6.1

package/src/brokers/sync-broker-instance.test.ts

@@ -2,7 +2,11 @@ import { describe, expect, test } from "bun:test";
 import { createDefaultConfig, type BrokerInstanceConfig } from "../types/config";
 import type { BrokerAdapter } from "../types/broker";
 import type { TickerRecord } from "../types/ticker";
-import { syncBrokerInstance } from "./sync-broker-instance";
+import {
+  restoreBrokerPortfoliosFromTickerPositions,
+  syncBrokerInstance,
+  syncBrokerInstances,
+} from "./sync-broker-instance";
 
 function createTickerRepository(initial: TickerRecord[] = []) {
   const tickers = new Map(initial.map((ticker) => [ticker.metadata.ticker, ticker] as const));
@@ -38,6 +42,42 @@ function createBrokerInstance(): BrokerInstanceConfig {
   };
 }
 
+function createBrokerInstanceWithId(id: string): BrokerInstanceConfig {
+  return {
+    id,
+    brokerType: "demo",
+    label: id,
+    config: { apiKey: `${id}-key` },
+    enabled: true,
+  };
+}
+
+function createBrokerTicker(instanceId: string, accountId: string): TickerRecord {
+  const portfolioId = `broker:${instanceId}:${accountId}`;
+  return {
+    metadata: {
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      portfolios: [portfolioId],
+      watchlists: [],
+      positions: [{
+        portfolio: portfolioId,
+        shares: 12,
+        avgCost: 180,
+        currency: "USD",
+        broker: "demo",
+        brokerInstanceId: instanceId,
+        brokerAccountId: accountId,
+      }],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
 function createDemoBroker(): BrokerAdapter {
   return {
     id: "demo",
@@ -58,6 +98,30 @@ function createDemoBroker(): BrokerAdapter {
   };
 }
 
+function createMultiAccountDemoBroker(): BrokerAdapter {
+  return {
+    id: "demo",
+    name: "Demo Broker",
+    configSchema: [{ key: "apiKey", label: "API Key", type: "text", required: true }],
+    validate: async () => true,
+    listAccounts: async (instance) => [{
+      accountId: instance.id === "demo-work" ? "WORK" : "PERSONAL",
+      name: instance.id === "demo-work" ? "Work" : "Personal",
+      currency: "USD",
+    }],
+    importPositions: async (instance) => [{
+      ticker: instance.id === "demo-work" ? "AAPL" : "MSFT",
+      exchange: "NASDAQ",
+      shares: instance.id === "demo-work" ? 12 : 8,
+      avgCost: instance.id === "demo-work" ? 180 : 310,
+      currency: "USD",
+      accountId: instance.id === "demo-work" ? "WORK" : "PERSONAL",
+      name: instance.id === "demo-work" ? "Apple Inc." : "Microsoft Corp.",
+      assetCategory: "STK",
+    }],
+  };
+}
+
 describe("syncBrokerInstance", () => {
   test("creates broker portfolios and imports positions into local tickers", async () => {
     const config = {
@@ -97,4 +161,63 @@ describe("syncBrokerInstance", () => {
       }),
     ]);
   });
+
+  test("preserves broker portfolios across sequential profile syncs", async () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-instances"),
+      portfolios: [],
+      brokerInstances: [
+        createBrokerInstanceWithId("demo-work"),
+        createBrokerInstanceWithId("demo-personal"),
+      ],
+    };
+    const tickerRepository = createTickerRepository();
+
+    const result = await syncBrokerInstances({
+      config,
+      brokers: new Map([["demo", createMultiAccountDemoBroker()]]),
+      tickerRepository: tickerRepository as any,
+      existingTickers: new Map(),
+    });
+
+    expect(result.errors).toEqual([]);
+    expect(result.config.portfolios.map((portfolio) => portfolio.id)).toEqual([
+      "broker:demo-work:WORK",
+      "broker:demo-personal:PERSONAL",
+    ]);
+    expect(result.tickers.get("AAPL")?.metadata.positions[0]).toEqual(expect.objectContaining({
+      portfolio: "broker:demo-work:WORK",
+      brokerInstanceId: "demo-work",
+      brokerAccountId: "WORK",
+    }));
+    expect(result.tickers.get("MSFT")?.metadata.positions[0]).toEqual(expect.objectContaining({
+      portfolio: "broker:demo-personal:PERSONAL",
+      brokerInstanceId: "demo-personal",
+      brokerAccountId: "PERSONAL",
+    }));
+  });
+
+  test("restores missing broker portfolios from existing ticker positions", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-restore-broker-portfolios"),
+      portfolios: [],
+      brokerInstances: [createBrokerInstanceWithId("demo-work")],
+    };
+
+    const restored = restoreBrokerPortfoliosFromTickerPositions(config, [
+      createBrokerTicker("demo-work", "WORK"),
+    ]);
+
+    expect(restored.portfolios).toEqual([{
+      id: "broker:demo-work:WORK",
+      name: "WORK",
+      currency: "USD",
+      brokerId: "demo",
+      brokerInstanceId: "demo-work",
+      brokerAccountId: "WORK",
+    }]);
+    expect(restoreBrokerPortfoliosFromTickerPositions(restored, [
+      createBrokerTicker("demo-work", "WORK"),
+    ])).toBe(restored);
+  });
 });

package/src/brokers/sync-broker-instance.ts

@@ -1,14 +1,12 @@
 import type { ResourceStore } from "../data/resource-store";
 import type { TickerRepository } from "../data/ticker-repository";
-import { persistIbkrAccounts } from "../plugins/ibkr/account-cache";
-import { buildPersistedIbkrGatewayConfig } from "../plugins/ibkr/config";
-import { ibkrGatewayManager } from "../plugins/ibkr/gateway-service";
+import { persistBrokerAccounts } from "./account-cache";
 import type { BrokerAdapter, BrokerPosition } from "../types/broker";
 import type { AppConfig, BrokerInstanceConfig } from "../types/config";
 import type { BrokerContractRef } from "../types/instrument";
 import type { BrokerAccount } from "../types/trading";
 import type { TickerMetadata, TickerPosition, TickerRecord } from "../types/ticker";
-import { buildBrokerPortfolioId, getBrokerInstance } from "../utils/broker-instances";
+import { buildBrokerPortfolioId, getBrokerInstance, isBrokerPortfolioId } from "../utils/broker-instances";
 
 export interface SyncBrokerInstanceArgs {
   config: AppConfig;
@@ -17,7 +15,7 @@ export interface SyncBrokerInstanceArgs {
   tickerRepository: TickerRepository;
   existingTickers?: Map<string, TickerRecord>;
   resources?: ResourceStore;
-  persistResolvedIbkrConnection?: boolean;
+  persistResolvedBrokerConfig?: boolean;
 }
 
 export interface SyncBrokerInstanceResult {
@@ -30,6 +28,23 @@ export interface SyncBrokerInstanceResult {
   updatedTickers: TickerRecord[];
 }
 
+export interface SyncBrokerInstancesArgs {
+  config: AppConfig;
+  brokers: ReadonlyMap<string, BrokerAdapter>;
+  tickerRepository: TickerRepository;
+  existingTickers: Map<string, TickerRecord>;
+  resources?: ResourceStore;
+  persistResolvedBrokerConfig?: boolean;
+  onResult?: (result: SyncBrokerInstanceResult, instance: BrokerInstanceConfig, previousConfig: AppConfig) => void | Promise<void>;
+}
+
+export interface SyncBrokerInstancesResult {
+  config: AppConfig;
+  tickers: Map<string, TickerRecord>;
+  results: SyncBrokerInstanceResult[];
+  errors: Array<{ instanceId: string; error: unknown }>;
+}
+
 function mergeBrokerContracts(existing: BrokerContractRef[], next: BrokerContractRef[]): BrokerContractRef[] {
   const merged = new Map<string, BrokerContractRef>();
   for (const contract of [...existing, ...next]) {
@@ -67,21 +82,56 @@ function ensureBrokerPortfolio(
   };
 }
 
-function maybePersistResolvedIbkrConnection(
+function inferBrokerAccountId(position: TickerPosition, portfolioId: string, instanceId: string): string | undefined {
+  if (position.brokerAccountId) return position.brokerAccountId;
+  const prefix = `broker:${instanceId}:`;
+  if (!portfolioId.startsWith(prefix)) return undefined;
+  const accountId = portfolioId.slice(prefix.length).trim();
+  return accountId && accountId !== "default" ? accountId : undefined;
+}
+
+export function restoreBrokerPortfoliosFromTickerPositions(
   config: AppConfig,
-  instance: BrokerInstanceConfig,
-  persistResolvedIbkrConnection: boolean,
+  tickers: Iterable<TickerRecord>,
 ): AppConfig {
-  if (!persistResolvedIbkrConnection || instance.brokerType !== "ibkr") {
-    return config;
+  let nextConfig = config;
+  const knownPortfolioIds = new Set(config.portfolios.map((portfolio) => portfolio.id));
+
+  for (const ticker of tickers) {
+    for (const position of ticker.metadata.positions) {
+      if (!position.brokerInstanceId || !isBrokerPortfolioId(position.portfolio)) continue;
+      if (knownPortfolioIds.has(position.portfolio)) continue;
+
+      const instance = getBrokerInstance(config.brokerInstances, position.brokerInstanceId);
+      if (!instance) continue;
+
+      const brokerAccountId = inferBrokerAccountId(position, position.portfolio, instance.id);
+      nextConfig = ensureBrokerPortfolio(
+        nextConfig,
+        instance,
+        position.portfolio,
+        brokerAccountId || instance.label || instance.brokerType,
+        position.currency || config.baseCurrency,
+        brokerAccountId,
+      );
+      knownPortfolioIds.add(position.portfolio);
+    }
   }
 
-  const resolved = ibkrGatewayManager.getService(instance.id).getResolvedConnection();
-  if (!resolved) {
+  return nextConfig;
+}
+
+async function maybePersistResolvedBrokerConfig(
+  config: AppConfig,
+  instance: BrokerInstanceConfig,
+  broker: BrokerAdapter,
+  persistResolvedBrokerConfig: boolean,
+): Promise<AppConfig> {
+  if (!persistResolvedBrokerConfig || !broker.getPersistedConfigUpdate) {
     return config;
   }
 
-  const nextConfig = buildPersistedIbkrGatewayConfig(instance.config, resolved);
+  const nextConfig = await broker.getPersistedConfigUpdate(instance);
   if (!nextConfig) {
     return config;
   }
@@ -200,7 +250,7 @@ export async function syncBrokerInstance({
   tickerRepository,
   existingTickers,
   resources,
-  persistResolvedIbkrConnection = false,
+  persistResolvedBrokerConfig = false,
 }: SyncBrokerInstanceArgs): Promise<SyncBrokerInstanceResult> {
   const instance = getBrokerInstance(config.brokerInstances, instanceId);
   if (!instance) {
@@ -226,9 +276,9 @@ export async function syncBrokerInstance({
   if (broker.listAccounts) {
     try {
       brokerAccounts = await broker.listAccounts(instance);
-      if (instance.brokerType === "ibkr" && resources) {
+      if (resources) {
         try {
-          persistIbkrAccounts(resources, instance, brokerAccounts);
+          persistBrokerAccounts(resources, instance, broker, brokerAccounts);
         } catch {}
       }
     } catch {
@@ -291,7 +341,7 @@ export async function syncBrokerInstance({
     portfolioIds.push(portfolioId);
   }
 
-  nextConfig = maybePersistResolvedIbkrConnection(nextConfig, instance, persistResolvedIbkrConnection);
+  nextConfig = await maybePersistResolvedBrokerConfig(nextConfig, instance, broker, persistResolvedBrokerConfig);
 
   const addedTickers = new Map<string, TickerRecord>();
   const updatedTickers = new Map<string, TickerRecord>();
@@ -339,3 +389,49 @@ export async function syncBrokerInstance({
     updatedTickers: [...updatedTickers.values()],
   };
 }
+
+export async function syncBrokerInstances({
+  config,
+  brokers,
+  tickerRepository,
+  existingTickers,
+  resources,
+  persistResolvedBrokerConfig = false,
+  onResult,
+}: SyncBrokerInstancesArgs): Promise<SyncBrokerInstancesResult> {
+  let nextConfig = config;
+  let nextTickers = new Map(existingTickers);
+  const results: SyncBrokerInstanceResult[] = [];
+  const errors: SyncBrokerInstancesResult["errors"] = [];
+
+  for (const instance of config.brokerInstances) {
+    if (instance.enabled === false) continue;
+
+    const previousConfig = nextConfig;
+    try {
+      const result = await syncBrokerInstance({
+        config: previousConfig,
+        instanceId: instance.id,
+        brokers,
+        tickerRepository,
+        existingTickers: nextTickers,
+        resources,
+        persistResolvedBrokerConfig,
+      });
+
+      nextConfig = result.config;
+      nextTickers = result.tickers;
+      results.push(result);
+      await onResult?.(result, instance, previousConfig);
+    } catch (error) {
+      errors.push({ instanceId: instance.id, error });
+    }
+  }
+
+  return {
+    config: nextConfig,
+    tickers: nextTickers,
+    results,
+    errors,
+  };
+}

package/src/capabilities/factories.ts

@@ -0,0 +1,100 @@
+import type { AssetDataProvider } from "../types/data-provider";
+import type { NewsDataProvider } from "../types/capability-route-source";
+import type {
+  AssetDataCapability,
+  CapabilityOperation,
+  NewsCapability,
+} from "./types";
+
+function op(handler: CapabilityOperation["handler"], kind: CapabilityOperation["kind"] = "read"): CapabilityOperation {
+  return { kind, rendererSafe: true, handler };
+}
+
+function stream(subscribe: CapabilityOperation["subscribe"]): CapabilityOperation {
+  return { kind: "stream", rendererSafe: true, subscribe };
+}
+
+export function assetDataProvider(provider: AssetDataProvider): AssetDataCapability {
+  return {
+    id: `asset-data.${provider.id}`,
+    sourceId: provider.id,
+    kind: "asset-data",
+    name: provider.name,
+    priority: provider.priority,
+    cachePolicy: provider.cachePolicy,
+    provider,
+    operations: {
+      canProvide: op((input: any) => provider.canProvide?.(input.ticker, input.exchange, input.context) ?? true, "query"),
+      getCachedFinancialsForTargets: op((input: any) => provider.getCachedFinancialsForTargets?.(input.targets ?? [], input.options) ?? new Map()),
+      getTickerFinancials: op((input: any) => provider.getTickerFinancials(input.ticker, input.exchange, input.context)),
+      getQuote: op((input: any) => provider.getQuote(input.ticker, input.exchange, input.context)),
+      getExchangeRate: op((input: any) => provider.getExchangeRate(input.fromCurrency)),
+      search: op((input: any) => provider.search(input.query, input.context), "query"),
+      getSecFilings: op((input: any) => {
+        if (!provider.getSecFilings) throw new Error(`${provider.name} does not provide SEC filings.`);
+        return provider.getSecFilings(input.ticker, input.count, input.exchange, input.context);
+      }, "query"),
+      getHolders: op((input: any) => {
+        if (!provider.getHolders) throw new Error(`${provider.name} does not provide holders.`);
+        return provider.getHolders(input.ticker, input.exchange, input.context);
+      }, "query"),
+      getAnalystResearch: op((input: any) => {
+        if (!provider.getAnalystResearch) throw new Error(`${provider.name} does not provide analyst research.`);
+        return provider.getAnalystResearch(input.ticker, input.exchange, input.context);
+      }, "query"),
+      getCorporateActions: op((input: any) => {
+        if (!provider.getCorporateActions) throw new Error(`${provider.name} does not provide corporate actions.`);
+        return provider.getCorporateActions(input.ticker, input.exchange, input.context);
+      }, "query"),
+      getEarningsCalendar: op((input: any) => {
+        if (!provider.getEarningsCalendar) throw new Error(`${provider.name} does not provide earnings calendar.`);
+        return provider.getEarningsCalendar(input.symbols ?? [], input.context);
+      }, "query"),
+      getSecFilingContent: op((input: any) => {
+        if (!provider.getSecFilingContent) throw new Error(`${provider.name} does not provide SEC filing content.`);
+        return provider.getSecFilingContent(input.filing);
+      }, "query"),
+      getArticleSummary: op((input: any) => provider.getArticleSummary(input.url), "query"),
+      getPriceHistory: op((input: any) => provider.getPriceHistory(input.ticker, input.exchange, input.range, input.context), "query"),
+      getPriceHistoryForResolution: op((input: any) => {
+        if (!provider.getPriceHistoryForResolution) throw new Error(`${provider.name} does not provide resolution price history.`);
+        return provider.getPriceHistoryForResolution(input.ticker, input.exchange, input.bufferRange, input.resolution, input.context);
+      }, "query"),
+      getDetailedPriceHistory: op((input: any) => {
+        if (!provider.getDetailedPriceHistory) throw new Error(`${provider.name} does not provide detailed price history.`);
+        return provider.getDetailedPriceHistory(input.ticker, input.exchange, input.startDate, input.endDate, input.barSize, input.context);
+      }, "query"),
+      getChartResolutionSupport: op((input: any) => provider.getChartResolutionSupport?.(input.ticker, input.exchange, input.context) ?? [], "query"),
+      getChartResolutionCapabilities: op((input: any) => provider.getChartResolutionCapabilities?.(input.ticker, input.exchange, input.context) ?? [], "query"),
+      getOptionsChain: op((input: any) => {
+        if (!provider.getOptionsChain) throw new Error(`${provider.name} does not provide options.`);
+        return provider.getOptionsChain(input.ticker, input.exchange, input.expirationDate, input.context);
+      }, "query"),
+      subscribeQuotes: stream((input: any, emit) => {
+        if (!provider.subscribeQuotes) throw new Error(`${provider.name} does not provide quote streaming.`);
+        return provider.subscribeQuotes(input.targets ?? [], (target, quote) => emit({ target, quote }));
+      }),
+    },
+  };
+}
+
+export function newsProvider(options: {
+  id: string;
+  name: string;
+  priority?: number;
+  provider: NewsDataProvider;
+}): NewsCapability {
+  return {
+    id: `news.${options.id}`,
+    sourceId: options.id,
+    kind: "news",
+    name: options.name,
+    priority: options.priority,
+    provider: options.provider,
+    operations: {
+      supports: op((input: any) => options.provider.supports?.(input.query) ?? true, "query"),
+      getCachedNews: op((input: any) => options.provider.getCachedNews?.(input.query) ?? [], "query"),
+      fetchNews: op((input: any) => options.provider.fetchNews(input.query), "query"),
+    },
+  };
+}

package/src/capabilities/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./registry";
+export * from "./factories";
+export * from "./service-capabilities";

package/src/capabilities/registry.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+import { CapabilityRegistry } from "./registry";
+import type { CapabilitySchema, PluginCapability } from "./types";
+
+interface IncrementInput {
+  value: number;
+}
+
+const incrementSchema: CapabilitySchema<IncrementInput> = {
+  parse(value) {
+    if (!value || typeof value !== "object" || typeof (value as any).value !== "number") {
+      throw new Error("Expected numeric value.");
+    }
+    return value as IncrementInput;
+  },
+};
+
+function testCapability(overrides: Partial<PluginCapability> = {}): PluginCapability {
+  return {
+    id: "plugin-service.test",
+    kind: "plugin-service",
+    name: "Test Capability",
+    operations: {
+      increment: {
+        kind: "read",
+        rendererSafe: true,
+        input: incrementSchema,
+        handler: (input: IncrementInput) => input.value + 1,
+      },
+      privateRead: {
+        kind: "read",
+        rendererSafe: false,
+        handler: () => "private",
+      },
+    },
+    ...overrides,
+  };
+}
+
+describe("CapabilityRegistry", () => {
+  test("registers capabilities and rejects duplicate ids", () => {
+    const registry = new CapabilityRegistry();
+    const dispose = registry.register("plugin-a", testCapability());
+
+    expect(registry.list().map((entry) => entry.capability.id)).toEqual(["plugin-service.test"]);
+    expect(() => registry.register("plugin-b", testCapability())).toThrow("already registered");
+
+    dispose();
+    expect(registry.list()).toEqual([]);
+  });
+
+  test("filters disabled plugins and disabled capabilities", () => {
+    const registry = new CapabilityRegistry({
+      isPluginEnabled: (pluginId) => pluginId !== "disabled-plugin",
+      isCapabilityEnabled: (capability) => capability.sourceId !== "disabled-source",
+    });
+
+    registry.register("disabled-plugin", testCapability({ id: "plugin-service.disabled-plugin" }));
+    registry.register("enabled-plugin", testCapability({
+      id: "plugin-service.disabled-source",
+      sourceId: "disabled-source",
+    }));
+    registry.register("enabled-plugin", testCapability({ id: "plugin-service.enabled" }));
+
+    expect(registry.list().map((entry) => entry.capability.id)).toEqual(["plugin-service.enabled"]);
+  });
+
+  test("enforces renderer safety and input schemas on invoke", async () => {
+    const registry = new CapabilityRegistry();
+    registry.register("plugin-a", testCapability());
+
+    await expect(registry.invoke("plugin-service.test", "privateRead", {}, { renderer: true }))
+      .rejects.toThrow("not available to renderers");
+    await expect(registry.invoke("plugin-service.test", "increment", { value: "1" }, { renderer: true }))
+      .rejects.toThrow("Expected numeric value");
+
+    await expect(registry.invoke("plugin-service.test", "increment", { value: 1 }, { renderer: true }))
+      .resolves.toBe(2);
+  });
+
+  test("emits renderer-safe manifests only when requested", () => {
+    const registry = new CapabilityRegistry();
+    registry.register("plugin-a", testCapability());
+
+    expect(registry.manifests({ rendererOnly: true })[0]?.operations.map((operation) => operation.id))
+      .toEqual(["increment"]);
+    expect(registry.manifests()[0]?.operations.map((operation) => operation.id))
+      .toEqual(["increment", "privateRead"]);
+  });
+
+  test("subscribes, unsubscribes, and cleans up subscriptions on unregister", async () => {
+    const registry = new CapabilityRegistry();
+    const events: string[] = [];
+    let disposed = 0;
+
+    const disposeCapability = registry.register("plugin-a", testCapability({
+      id: "plugin-service.streams",
+      operations: {
+        ticks: {
+          kind: "stream",
+          rendererSafe: true,
+          subscribe: (input: any, emit) => {
+            emit(input.value);
+            return () => {
+              disposed += 1;
+            };
+          },
+        },
+      },
+    }));
+
+    const subscriptionId = await registry.subscribe<string>(
+      "plugin-service.streams",
+      "ticks",
+      { value: "first" },
+      (event) => events.push(event),
+      { renderer: true },
+    );
+
+    expect(events).toEqual(["first"]);
+    registry.unsubscribe(subscriptionId);
+    expect(disposed).toBe(1);
+
+    await registry.subscribe<string>(
+      "plugin-service.streams",
+      "ticks",
+      { value: "second" },
+      (event) => events.push(event),
+      { renderer: true, subscriptionId: "renderer:quote:1" },
+    );
+    disposeCapability();
+
+    expect(events).toEqual(["first", "second"]);
+    expect(disposed).toBe(2);
+    expect(registry.list()).toEqual([]);
+  });
+});