gloomberb 0.2.0 → 0.3.2

package/src/plugins/ibkr/account-cache.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { AppPersistence } from "../../data/app-persistence";
+import type { BrokerInstanceConfig } from "../../types/config";
+import type { BrokerAccount } from "../../types/trading";
+import {
+  clearPersistedIbkrAccounts,
+  loadPersistedIbkrAccountMap,
+  loadPersistedIbkrAccounts,
+  persistIbkrAccounts,
+} from "./account-cache";
+
+const tempPaths: string[] = [];
+
+function createTempDbPath(name: string): string {
+  const path = join(tmpdir(), `gloomberb-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  tempPaths.push(path);
+  return path;
+}
+
+function createIbkrInstance(connectionMode: "flex" | "gateway", overrides: Partial<BrokerInstanceConfig> = {}): BrokerInstanceConfig {
+  return {
+    id: overrides.id ?? `ibkr-${connectionMode}`,
+    brokerType: "ibkr",
+    label: overrides.label ?? `IBKR ${connectionMode}`,
+    connectionMode,
+    config: connectionMode === "gateway"
+      ? { connectionMode, gateway: { host: "127.0.0.1", port: 4002, clientId: 1 } }
+      : { connectionMode, flex: { token: "token", queryId: "query" } },
+    enabled: true,
+    ...overrides,
+  };
+}
+
+const TEST_ACCOUNTS: BrokerAccount[] = [{
+  accountId: "DU12345",
+  name: "DU12345",
+  currency: "USD",
+  source: "gateway",
+  updatedAt: 1_717_000_000_000,
+  totalCashValue: 125000,
+  cashBalances: [{ currency: "USD", quantity: 125000, baseValue: 125000, baseCurrency: "USD" }],
+}];
+
+afterEach(() => {
+  for (const path of tempPaths.splice(0)) {
+    if (existsSync(path)) rmSync(path, { force: true });
+  }
+});
+
+describe("IBKR account cache", () => {
+  test("persists and reloads account snapshots by broker instance", () => {
+    const persistence = new AppPersistence(createTempDbPath("ibkr-account-cache"));
+    const instance = createIbkrInstance("flex", { id: "ibkr-personal" });
+
+    persistIbkrAccounts(persistence.resources, instance, TEST_ACCOUNTS);
+
+    expect(loadPersistedIbkrAccounts(persistence.resources, instance)).toEqual(TEST_ACCOUNTS);
+    expect(loadPersistedIbkrAccountMap(persistence.resources, [instance])).toEqual({
+      "ibkr-personal": TEST_ACCOUNTS,
+    });
+
+    persistence.close();
+  });
+
+  test("drops snapshots whose config fingerprint no longer matches", () => {
+    const persistence = new AppPersistence(createTempDbPath("ibkr-account-cache-mismatch"));
+    const original = createIbkrInstance("gateway", { id: "ibkr-live" });
+    const updated = createIbkrInstance("gateway", {
+      id: "ibkr-live",
+      config: { connectionMode: "gateway", gateway: { host: "127.0.0.1", port: 4003, clientId: 1 } },
+    });
+
+    persistIbkrAccounts(persistence.resources, original, TEST_ACCOUNTS);
+
+    expect(loadPersistedIbkrAccounts(persistence.resources, updated)).toBeNull();
+    expect(persistence.resources.list({
+      namespace: "plugin:ibkr",
+      kind: "account-snapshot",
+      entityKey: "ibkr-live",
+    }, {
+      allowExpired: true,
+      schemaVersion: 1,
+    })).toHaveLength(0);
+
+    persistence.close();
+  });
+
+  test("clears all persisted snapshots for an IBKR instance", () => {
+    const persistence = new AppPersistence(createTempDbPath("ibkr-account-cache-clear"));
+    const instance = createIbkrInstance("gateway", { id: "ibkr-live" });
+
+    persistIbkrAccounts(persistence.resources, instance, TEST_ACCOUNTS);
+    clearPersistedIbkrAccounts(persistence.resources, instance.id);
+
+    expect(loadPersistedIbkrAccounts(persistence.resources, instance)).toBeNull();
+    persistence.close();
+  });
+});

package/src/plugins/ibkr/account-cache.ts

@@ -0,0 +1,137 @@
+import { createHash } from "crypto";
+import type { ResourceStore } from "../../data/resource-store";
+import type { BrokerInstanceConfig } from "../../types/config";
+import type { BrokerAccount } from "../../types/trading";
+import { normalizeIbkrConfig, type IbkrConnectionMode } from "./config";
+
+const IBKR_PLUGIN_NAMESPACE = "plugin:ibkr";
+const IBKR_ACCOUNT_SNAPSHOT_KIND = "account-snapshot";
+const IBKR_ACCOUNT_SNAPSHOT_SCHEMA_VERSION = 1;
+
+const FLEX_ACCOUNT_CACHE_POLICY = {
+  staleMs: 6 * 60 * 60 * 1000,
+  expireMs: 30 * 24 * 60 * 60 * 1000,
+} as const;
+
+const GATEWAY_ACCOUNT_CACHE_POLICY = {
+  staleMs: 30 * 1000,
+  expireMs: 7 * 24 * 60 * 60 * 1000,
+} as const;
+
+interface PersistedIbkrAccountSnapshot {
+  connectionMode: IbkrConnectionMode;
+  accounts: BrokerAccount[];
+}
+
+function getIbkrAccountSnapshotSourceKey(instance: BrokerInstanceConfig): string {
+  const normalized = normalizeIbkrConfig(instance.config);
+  return createHash("sha256")
+    .update(JSON.stringify(normalized))
+    .digest("hex");
+}
+
+function getAccountCachePolicy(instance: BrokerInstanceConfig) {
+  const normalized = normalizeIbkrConfig(instance.config);
+  return normalized.connectionMode === "gateway"
+    ? GATEWAY_ACCOUNT_CACHE_POLICY
+    : FLEX_ACCOUNT_CACHE_POLICY;
+}
+
+function pruneMismatchedSnapshots(resources: ResourceStore, instance: BrokerInstanceConfig, sourceKey: string): void {
+  const records = resources.list<PersistedIbkrAccountSnapshot>({
+    namespace: IBKR_PLUGIN_NAMESPACE,
+    kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+  }, {
+    schemaVersion: IBKR_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+
+  for (const record of records) {
+    if (record.sourceKey === sourceKey) continue;
+    resources.delete({
+      namespace: IBKR_PLUGIN_NAMESPACE,
+      kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+      entityKey: instance.id,
+      sourceKey: record.sourceKey,
+    });
+  }
+}
+
+export function loadPersistedIbkrAccounts(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+): BrokerAccount[] | null {
+  const sourceKey = getIbkrAccountSnapshotSourceKey(instance);
+  pruneMismatchedSnapshots(resources, instance, sourceKey);
+
+  return resources.get<PersistedIbkrAccountSnapshot>({
+    namespace: IBKR_PLUGIN_NAMESPACE,
+    kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+    sourceKey,
+  }, {
+    schemaVersion: IBKR_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+  })?.value.accounts ?? null;
+}
+
+export function persistIbkrAccounts(
+  resources: ResourceStore,
+  instance: BrokerInstanceConfig,
+  accounts: BrokerAccount[],
+): void {
+  const sourceKey = getIbkrAccountSnapshotSourceKey(instance);
+  pruneMismatchedSnapshots(resources, instance, sourceKey);
+
+  resources.set<PersistedIbkrAccountSnapshot>({
+    namespace: IBKR_PLUGIN_NAMESPACE,
+    kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instance.id,
+    sourceKey,
+  }, {
+    connectionMode: normalizeIbkrConfig(instance.config).connectionMode,
+    accounts,
+  }, {
+    schemaVersion: IBKR_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    cachePolicy: getAccountCachePolicy(instance),
+  });
+}
+
+export function loadPersistedIbkrAccountMap(
+  resources: ResourceStore,
+  brokerInstances: BrokerInstanceConfig[],
+): Record<string, BrokerAccount[]> {
+  const accountMap: Record<string, BrokerAccount[]> = {};
+
+  for (const instance of brokerInstances) {
+    if (instance.brokerType !== "ibkr") continue;
+    const accounts = loadPersistedIbkrAccounts(resources, instance);
+    if (!accounts || accounts.length === 0) continue;
+    accountMap[instance.id] = accounts;
+  }
+
+  return accountMap;
+}
+
+export function clearPersistedIbkrAccounts(
+  resources: ResourceStore,
+  instanceId: string,
+): void {
+  const records = resources.list<PersistedIbkrAccountSnapshot>({
+    namespace: IBKR_PLUGIN_NAMESPACE,
+    kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+    entityKey: instanceId,
+  }, {
+    schemaVersion: IBKR_ACCOUNT_SNAPSHOT_SCHEMA_VERSION,
+    allowExpired: true,
+  });
+
+  for (const record of records) {
+    resources.delete({
+      namespace: IBKR_PLUGIN_NAMESPACE,
+      kind: IBKR_ACCOUNT_SNAPSHOT_KIND,
+      entityKey: instanceId,
+      sourceKey: record.sourceKey,
+    });
+  }
+}

package/src/plugins/ibkr/broker-adapter.ts

@@ -0,0 +1,168 @@
+import type { BrokerAdapter, BrokerPosition } from "../../types/broker";
+import type { BrokerInstanceConfig } from "../../types/config";
+import {
+  getGatewayConfig,
+  IBKR_CONFIG_FIELDS,
+  isFlexConfigured,
+  isGatewayConfigured,
+  normalizeIbkrConfig,
+  type FlexQueryConfig,
+} from "./config";
+import { loadFlexStatement, parseFlexAccounts, parseFlexPositions } from "./flex";
+import { ibkrGatewayManager } from "./gateway-service";
+import { refreshGatewayData } from "./gateway-helpers";
+
+async function importFlexPositions(config: FlexQueryConfig): Promise<BrokerPosition[]> {
+  const xml = await loadFlexStatement(config);
+  return parseFlexPositions(xml);
+}
+
+export const ibkrBroker: BrokerAdapter = {
+  id: "ibkr",
+  name: "Interactive Brokers",
+  configSchema: IBKR_CONFIG_FIELDS,
+
+  async validate(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    return normalized.connectionMode === "gateway"
+      ? isGatewayConfigured(instance.config)
+      : isFlexConfigured(instance.config);
+  },
+
+  async importPositions(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode === "gateway") {
+      await refreshGatewayData(instance);
+      return ibkrGatewayManager.getService(instance.id).getPositions(normalized.gateway);
+    }
+    return importFlexPositions(normalized.flex);
+  },
+
+  async connect(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") return;
+    await ibkrGatewayManager.getService(instance.id).connect(normalized.gateway);
+  },
+
+  async disconnect(instance) {
+    await ibkrGatewayManager.removeInstance(instance.id);
+  },
+
+  getStatus(instance) {
+    return { ...ibkrGatewayManager.getSnapshot(instance.id).status, mode: "gateway" };
+  },
+
+  async listAccounts(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode === "gateway") {
+      return ibkrGatewayManager.getService(instance.id).getAccounts(normalized.gateway);
+    }
+    const xml = await loadFlexStatement(normalized.flex);
+    return parseFlexAccounts(xml);
+  },
+
+  async searchInstruments(query, instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") return [];
+    return (await ibkrGatewayManager.getService(instance.id).searchInstruments(query, normalized.gateway)).map((result) => ({
+      ...result,
+      brokerInstanceId: result.brokerInstanceId ?? instance.id,
+      brokerLabel: result.brokerLabel ?? instance.label,
+      brokerContract: result.brokerContract
+        ? { ...result.brokerContract, brokerInstanceId: result.brokerContract.brokerInstanceId ?? instance.id }
+        : undefined,
+    }));
+  },
+
+  async getTickerFinancials(ticker, instance, exchange, instrument) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for broker market data");
+    }
+    return ibkrGatewayManager.getService(instance.id).getTickerFinancials(ticker, normalized.gateway, exchange, instrument);
+  },
+
+  async getQuote(ticker, instance, exchange, instrument) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for broker quotes");
+    }
+    return ibkrGatewayManager.getService(instance.id).getQuote(ticker, normalized.gateway, exchange, instrument);
+  },
+
+  async getPriceHistory(ticker, instance, exchange, range, instrument) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for broker history");
+    }
+    return ibkrGatewayManager.getService(instance.id).getPriceHistory(ticker, normalized.gateway, exchange, range, instrument);
+  },
+
+  async getDetailedPriceHistory(ticker, instance, exchange, startDate, endDate, barSize, instrument) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for broker history");
+    }
+    return ibkrGatewayManager.getService(instance.id).getDetailedPriceHistory(
+      ticker,
+      normalized.gateway,
+      exchange,
+      startDate,
+      endDate,
+      barSize,
+      instrument,
+    );
+  },
+
+  subscribeQuotes(instance, targets, onQuote) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      return () => {};
+    }
+    return ibkrGatewayManager.getService(instance.id).subscribeQuotes(normalized.gateway, targets, onQuote);
+  },
+
+  async listOpenOrders(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") return [];
+    return ibkrGatewayManager.getService(instance.id).listOpenOrders(normalized.gateway);
+  },
+
+  async listExecutions(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") return [];
+    return ibkrGatewayManager.getService(instance.id).listExecutions(normalized.gateway);
+  },
+
+  async previewOrder(instance, request) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for order preview");
+    }
+    return ibkrGatewayManager.getService(instance.id).previewOrder(normalized.gateway, request);
+  },
+
+  async placeOrder(instance, request) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for trading");
+    }
+    return ibkrGatewayManager.getService(instance.id).placeOrder(normalized.gateway, request);
+  },
+
+  async modifyOrder(instance, orderId, request) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for trading");
+    }
+    return ibkrGatewayManager.getService(instance.id).modifyOrder(normalized.gateway, orderId, request);
+  },
+
+  async cancelOrder(instance, orderId) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode !== "gateway") {
+      throw new Error("Gateway mode is required for trading");
+    }
+    return ibkrGatewayManager.getService(instance.id).cancelOrder(normalized.gateway, orderId);
+  },
+};

package/src/plugins/ibkr/config.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import { buildIbkrConfigFromValues, normalizeIbkrConfig } from "./config";
+
+describe("ibkr config helpers", () => {
+  test("builds nested manual gateway config from flat wizard values", () => {
+    const config = buildIbkrConfigFromValues({
+      connectionMode: "gateway",
+      gatewaySetupMode: "manual",
+      host: "127.0.0.1",
+      port: "4002",
+    });
+
+    expect(config.connectionMode).toBe("gateway");
+    expect(config.gatewaySetupMode).toBe("manual");
+    expect(config.gateway).toEqual({
+      host: "127.0.0.1",
+      port: 4002,
+      clientId: undefined,
+      lastSuccessfulPort: undefined,
+      lastSuccessfulClientId: undefined,
+      marketDataType: "auto",
+    });
+  });
+
+  test("defaults gateway profiles to automatic connection detection", () => {
+    const config = buildIbkrConfigFromValues({
+      connectionMode: "gateway",
+      gatewaySetupMode: "auto",
+    });
+
+    expect(config.connectionMode).toBe("gateway");
+    expect(config.gatewaySetupMode).toBe("auto");
+    expect(config.gateway).toEqual({
+      host: "127.0.0.1",
+      port: undefined,
+      clientId: undefined,
+      lastSuccessfulPort: undefined,
+      lastSuccessfulClientId: undefined,
+      marketDataType: "auto",
+    });
+  });
+
+  test("treats explicit port/client configs as manual at runtime", () => {
+    const config = normalizeIbkrConfig({
+      connectionMode: "gateway",
+      host: "127.0.0.1",
+      port: 4002,
+      clientId: 1,
+    });
+
+    expect(config.gatewaySetupMode).toBe("manual");
+    expect(config.gateway.port).toBe(4002);
+    expect(config.gateway.clientId).toBe(1);
+  });
+
+  test("normalizes flat flex wizard values", () => {
+    const config = normalizeIbkrConfig({
+      token: "abc",
+      queryId: "123",
+    });
+
+    expect(config.connectionMode).toBe("flex");
+    expect(config.gatewaySetupMode).toBe("auto");
+    expect(config.flex.token).toBe("abc");
+    expect(config.flex.queryId).toBe("123");
+    expect(config.flex.endpoint).toContain("FlexStatementService.SendRequest");
+  });
+});