gloomberb 0.2.0 → 0.3.1

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

@@ -0,0 +1,100 @@
+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";
+
+function createTickerRepository(initial: TickerRecord[] = []) {
+  const tickers = new Map(initial.map((ticker) => [ticker.metadata.ticker, ticker] as const));
+
+  return {
+    async loadAllTickers() {
+      return [...tickers.values()];
+    },
+    async loadTicker(symbol: string) {
+      return tickers.get(symbol) ?? null;
+    },
+    async saveTicker(ticker: TickerRecord) {
+      tickers.set(ticker.metadata.ticker, ticker);
+    },
+    async createTicker(metadata: TickerRecord["metadata"]) {
+      const ticker = { metadata };
+      tickers.set(metadata.ticker, ticker);
+      return ticker;
+    },
+    async deleteTicker(symbol: string) {
+      tickers.delete(symbol);
+    },
+  };
+}
+
+function createBrokerInstance(): BrokerInstanceConfig {
+  return {
+    id: "demo-broker",
+    brokerType: "demo",
+    label: "Demo Broker",
+    config: { apiKey: "demo-key" },
+    enabled: true,
+  };
+}
+
+function createDemoBroker(): BrokerAdapter {
+  return {
+    id: "demo",
+    name: "Demo Broker",
+    configSchema: [{ key: "apiKey", label: "API Key", type: "text", required: true }],
+    validate: async () => true,
+    listAccounts: async () => [{ accountId: "ACC-1", name: "Primary", currency: "USD" }],
+    importPositions: async () => [{
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      shares: 12,
+      avgCost: 180,
+      currency: "USD",
+      accountId: "ACC-1",
+      name: "Apple Inc.",
+      assetCategory: "STK",
+    }],
+  };
+}
+
+describe("syncBrokerInstance", () => {
+  test("creates broker portfolios and imports positions into local tickers", async () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-instance"),
+      portfolios: [],
+      brokerInstances: [createBrokerInstance()],
+    };
+    const tickerRepository = createTickerRepository();
+
+    const result = await syncBrokerInstance({
+      config,
+      instanceId: "demo-broker",
+      brokers: new Map([["demo", createDemoBroker()]]),
+      tickerRepository: tickerRepository as any,
+    });
+
+    expect(result.portfolioIds).toEqual(["broker:demo-broker:ACC-1"]);
+    expect(result.config.portfolios).toEqual([
+      {
+        id: "broker:demo-broker:ACC-1",
+        name: "Primary",
+        currency: "USD",
+        brokerId: "demo",
+        brokerInstanceId: "demo-broker",
+        brokerAccountId: "ACC-1",
+      },
+    ]);
+    expect(result.positions).toHaveLength(1);
+    expect(result.addedTickers).toHaveLength(1);
+    expect(result.tickers.get("AAPL")?.metadata.positions).toEqual([
+      expect.objectContaining({
+        portfolio: "broker:demo-broker:ACC-1",
+        broker: "demo",
+        shares: 12,
+        brokerInstanceId: "demo-broker",
+        brokerAccountId: "ACC-1",
+      }),
+    ]);
+  });
+});

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

@@ -0,0 +1,341 @@
+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 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";
+
+export interface SyncBrokerInstanceArgs {
+  config: AppConfig;
+  instanceId: string;
+  brokers: ReadonlyMap<string, BrokerAdapter>;
+  tickerRepository: TickerRepository;
+  existingTickers?: Map<string, TickerRecord>;
+  resources?: ResourceStore;
+  persistResolvedIbkrConnection?: boolean;
+}
+
+export interface SyncBrokerInstanceResult {
+  config: AppConfig;
+  tickers: Map<string, TickerRecord>;
+  brokerAccounts: BrokerAccount[];
+  positions: BrokerPosition[];
+  portfolioIds: string[];
+  addedTickers: TickerRecord[];
+  updatedTickers: TickerRecord[];
+}
+
+function mergeBrokerContracts(existing: BrokerContractRef[], next: BrokerContractRef[]): BrokerContractRef[] {
+  const merged = new Map<string, BrokerContractRef>();
+  for (const contract of [...existing, ...next]) {
+    const key = `${contract.brokerId}:${contract.brokerInstanceId ?? ""}:${contract.conId ?? contract.localSymbol ?? contract.symbol}:${contract.secType ?? ""}`;
+    merged.set(key, contract);
+  }
+  return [...merged.values()];
+}
+
+function ensureBrokerPortfolio(
+  config: AppConfig,
+  instance: BrokerInstanceConfig,
+  portfolioId: string,
+  name: string,
+  currency: string,
+  brokerAccountId?: string,
+): AppConfig {
+  if (config.portfolios.some((portfolio) => portfolio.id === portfolioId)) {
+    return config;
+  }
+
+  return {
+    ...config,
+    portfolios: [
+      ...config.portfolios,
+      {
+        id: portfolioId,
+        name,
+        currency,
+        brokerId: instance.brokerType,
+        brokerInstanceId: instance.id,
+        brokerAccountId,
+      },
+    ],
+  };
+}
+
+function maybePersistResolvedIbkrConnection(
+  config: AppConfig,
+  instance: BrokerInstanceConfig,
+  persistResolvedIbkrConnection: boolean,
+): AppConfig {
+  if (!persistResolvedIbkrConnection || instance.brokerType !== "ibkr") {
+    return config;
+  }
+
+  const resolved = ibkrGatewayManager.getService(instance.id).getResolvedConnection();
+  if (!resolved) {
+    return config;
+  }
+
+  const nextConfig = buildPersistedIbkrGatewayConfig(instance.config, resolved);
+  if (!nextConfig) {
+    return config;
+  }
+
+  return {
+    ...config,
+    brokerInstances: config.brokerInstances.map((entry) =>
+      entry.id === instance.id
+        ? {
+          ...entry,
+          connectionMode: typeof nextConfig.connectionMode === "string" ? nextConfig.connectionMode : entry.connectionMode,
+          config: {
+            ...entry.config,
+            ...nextConfig,
+          },
+        }
+        : entry,
+    ),
+  };
+}
+
+async function loadTickerMap(
+  tickerRepository: TickerRepository,
+  existingTickers?: Map<string, TickerRecord>,
+): Promise<Map<string, TickerRecord>> {
+  if (existingTickers) {
+    return new Map(existingTickers);
+  }
+
+  const tickers = await tickerRepository.loadAllTickers();
+  return new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker] as const));
+}
+
+function buildPositionEntry(
+  instance: BrokerInstanceConfig,
+  portfolioId: string,
+  position: BrokerPosition,
+  brokerContract?: BrokerContractRef,
+): TickerPosition {
+  return {
+    portfolio: portfolioId,
+    shares: position.shares,
+    avgCost: position.avgCost ?? 0,
+    currency: position.currency,
+    broker: instance.brokerType,
+    side: position.side,
+    marketValue: position.marketValue,
+    unrealizedPnl: position.unrealizedPnl,
+    multiplier: position.multiplier,
+    markPrice: position.markPrice,
+    brokerInstanceId: instance.id,
+    brokerAccountId: position.accountId,
+    brokerContractId: brokerContract?.conId,
+  };
+}
+
+function createTickerMetadata(
+  position: BrokerPosition,
+  portfolioId: string,
+  positionEntry: TickerPosition,
+  brokerContract?: BrokerContractRef,
+): TickerMetadata {
+  return {
+    ticker: position.ticker,
+    exchange: position.exchange,
+    currency: position.currency,
+    name: position.name || position.ticker,
+    assetCategory: position.assetCategory,
+    isin: position.isin,
+    portfolios: [portfolioId],
+    watchlists: [],
+    positions: [positionEntry],
+    broker_contracts: brokerContract ? [brokerContract] : [],
+    custom: {},
+    tags: [],
+  };
+}
+
+function updateExistingTicker(
+  ticker: TickerRecord,
+  instance: BrokerInstanceConfig,
+  portfolioId: string,
+  position: BrokerPosition,
+  positionEntry: TickerPosition,
+  brokerContract?: BrokerContractRef,
+): TickerRecord {
+  if (position.name && ticker.metadata.name === ticker.metadata.ticker) {
+    ticker.metadata.name = position.name;
+  }
+  if (position.assetCategory && !ticker.metadata.assetCategory) {
+    ticker.metadata.assetCategory = position.assetCategory;
+  }
+  if (position.isin && !ticker.metadata.isin) {
+    ticker.metadata.isin = position.isin;
+  }
+
+  const otherPositions = ticker.metadata.positions.filter(
+    (entry) => !(entry.brokerInstanceId === instance.id && entry.portfolio === portfolioId),
+  );
+  ticker.metadata.positions = [...otherPositions, positionEntry];
+  ticker.metadata.broker_contracts = mergeBrokerContracts(
+    ticker.metadata.broker_contracts ?? [],
+    brokerContract ? [brokerContract] : [],
+  );
+  if (!ticker.metadata.portfolios.includes(portfolioId)) {
+    ticker.metadata.portfolios.push(portfolioId);
+  }
+
+  return ticker;
+}
+
+export async function syncBrokerInstance({
+  config,
+  instanceId,
+  brokers,
+  tickerRepository,
+  existingTickers,
+  resources,
+  persistResolvedIbkrConnection = false,
+}: SyncBrokerInstanceArgs): Promise<SyncBrokerInstanceResult> {
+  const instance = getBrokerInstance(config.brokerInstances, instanceId);
+  if (!instance) {
+    throw new Error(`Broker instance "${instanceId}" was not found.`);
+  }
+  if (instance.enabled === false) {
+    throw new Error(`Broker instance "${instance.label}" is disabled.`);
+  }
+
+  const broker = brokers.get(instance.brokerType);
+  if (!broker) {
+    throw new Error(`Broker "${instance.brokerType}" is not available.`);
+  }
+
+  const valid = await broker.validate(instance).catch(() => false);
+  if (!valid) {
+    throw new Error(`${broker.name} setup is incomplete.`);
+  }
+
+  const tickers = await loadTickerMap(tickerRepository, existingTickers);
+
+  let brokerAccounts: BrokerAccount[] = [];
+  if (broker.listAccounts) {
+    try {
+      brokerAccounts = await broker.listAccounts(instance);
+      if (instance.brokerType === "ibkr" && resources) {
+        try {
+          persistIbkrAccounts(resources, instance, brokerAccounts);
+        } catch {}
+      }
+    } catch {
+      brokerAccounts = [];
+    }
+  }
+
+  const accountMetadata = new Map(
+    brokerAccounts.map((account) => [
+      account.accountId,
+      {
+        name: account.name || account.accountId,
+        currency: account.currency || "USD",
+      },
+    ]),
+  );
+
+  const positions = await broker.importPositions(instance);
+
+  let nextConfig = config;
+  const accountIds = new Set<string>();
+  for (const account of brokerAccounts) {
+    if (account.accountId) {
+      accountIds.add(account.accountId);
+    }
+  }
+  for (const position of positions) {
+    if (position.accountId) {
+      accountIds.add(position.accountId);
+    }
+  }
+
+  const portfolioIds: string[] = [];
+  if (accountIds.size > 0) {
+    for (const accountId of accountIds) {
+      const portfolioId = buildBrokerPortfolioId(instance.id, accountId);
+      const account = accountMetadata.get(accountId);
+      nextConfig = ensureBrokerPortfolio(
+        nextConfig,
+        instance,
+        portfolioId,
+        account?.name || accountId,
+        account?.currency || "USD",
+        accountId,
+      );
+      portfolioIds.push(portfolioId);
+    }
+  } else {
+    const defaultAccount = brokerAccounts[0];
+    const portfolioId = buildBrokerPortfolioId(instance.id, defaultAccount?.accountId);
+    const fallbackName = defaultAccount?.name || defaultAccount?.accountId || instance.label || broker.name;
+    nextConfig = ensureBrokerPortfolio(
+      nextConfig,
+      instance,
+      portfolioId,
+      fallbackName,
+      defaultAccount?.currency || "USD",
+      defaultAccount?.accountId,
+    );
+    portfolioIds.push(portfolioId);
+  }
+
+  nextConfig = maybePersistResolvedIbkrConnection(nextConfig, instance, persistResolvedIbkrConnection);
+
+  const addedTickers = new Map<string, TickerRecord>();
+  const updatedTickers = new Map<string, TickerRecord>();
+
+  for (const position of positions) {
+    const portfolioId = buildBrokerPortfolioId(instance.id, position.accountId);
+    const brokerContract = position.brokerContract
+      ? {
+        ...position.brokerContract,
+        brokerId: instance.brokerType,
+        brokerInstanceId: instance.id,
+      }
+      : undefined;
+    const positionEntry = buildPositionEntry(instance, portfolioId, position, brokerContract);
+
+    let ticker = tickers.get(position.ticker);
+    if (!ticker) {
+      ticker = await tickerRepository.createTicker(
+        createTickerMetadata(position, portfolioId, positionEntry, brokerContract),
+      );
+      addedTickers.set(position.ticker, ticker);
+    } else {
+      ticker = updateExistingTicker(ticker, instance, portfolioId, position, positionEntry, brokerContract);
+      await tickerRepository.saveTicker(ticker);
+      if (!addedTickers.has(position.ticker)) {
+        updatedTickers.set(position.ticker, ticker);
+      }
+    }
+
+    tickers.set(position.ticker, ticker);
+    if (addedTickers.has(position.ticker)) {
+      addedTickers.set(position.ticker, ticker);
+    } else {
+      updatedTickers.set(position.ticker, ticker);
+    }
+  }
+
+  return {
+    config: nextConfig,
+    tickers,
+    brokerAccounts,
+    positions,
+    portfolioIds,
+    addedTickers: [...addedTickers.values()],
+    updatedTickers: [...updatedTickers.values()],
+  };
+}

package/src/cli/commands/plugins.ts

@@ -0,0 +1,173 @@
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
+import { execSync } from "child_process";
+import { getPluginsDir } from "../../plugins/loader";
+import {
+  cliStyles,
+  renderSection,
+  renderStat,
+  renderTable,
+} from "../../utils/cli-output";
+import { fail } from "../errors";
+
+const PLUGINS_DIR = getPluginsDir();
+
+function ensurePluginsDir() {
+  if (!existsSync(PLUGINS_DIR)) {
+    mkdirSync(PLUGINS_DIR, { recursive: true });
+  }
+}
+
+function parseGitHubRef(ref: string): { url: string; name: string } {
+  if (ref.startsWith("https://github.com/")) {
+    const clean = ref.replace(/\.git$/, "");
+    const name = clean.split("/").pop()!;
+    return { url: clean.endsWith(".git") ? ref : `${clean}.git`, name };
+  }
+  if (ref.startsWith("github:")) {
+    ref = ref.slice(7);
+  }
+  if (ref.includes("/") && !ref.includes("://")) {
+    const name = ref.split("/").pop()!;
+    return { url: `https://github.com/${ref}.git`, name };
+  }
+  throw new Error(`Invalid plugin reference: ${ref}. Use user/repo or a GitHub URL.`);
+}
+
+export async function installPlugin(ref: string) {
+  ensurePluginsDir();
+  const { url, name } = parseGitHubRef(ref);
+  const targetDir = join(PLUGINS_DIR, name);
+
+  if (existsSync(targetDir)) {
+    fail(`Plugin "${name}" already exists.`, `Use "gloomberb update ${name}" to refresh it.`);
+  }
+
+  console.log(cliStyles.accent(`Installing ${name}`));
+  console.log(cliStyles.muted(url));
+
+  try {
+    execSync(`git clone --depth 1 ${url} ${targetDir}`, { stdio: "inherit" });
+  } catch {
+    fail(`Failed to clone ${url}.`);
+  }
+
+  const pkgPath = join(targetDir, "package.json");
+  if (existsSync(pkgPath)) {
+    console.log(cliStyles.muted("Installing plugin dependencies..."));
+    try {
+      execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+    } catch {
+      console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
+    }
+  }
+
+  try {
+    let entryFile: string | null = null;
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(await Bun.file(pkgPath).text());
+      if (pkg.main) entryFile = join(targetDir, pkg.main);
+    }
+    if (!entryFile) {
+      for (const candidate of ["index.ts", "index.tsx", "index.js"]) {
+        const path = join(targetDir, candidate);
+        if (existsSync(path)) {
+          entryFile = path;
+          break;
+        }
+      }
+    }
+    if (entryFile) {
+      const mod = await import(entryFile);
+      const plugin = mod.default ?? mod.plugin;
+      if (plugin?.id && plugin?.name) {
+        console.log(cliStyles.success(`Installed ${plugin.name} v${plugin.version || "0.0.0"}`));
+        return;
+      }
+    }
+    console.log(cliStyles.warning("Installed files, but no valid GloomPlugin export was found."));
+  } catch (err) {
+    console.log(cliStyles.warning(`Plugin validation failed: ${err}`));
+  }
+}
+
+export async function removePlugin(name: string) {
+  const targetDir = join(PLUGINS_DIR, name);
+  if (!existsSync(targetDir)) {
+    fail(`Plugin "${name}" was not found.`, PLUGINS_DIR);
+  }
+  rmSync(targetDir, { recursive: true, force: true });
+  console.log(cliStyles.success(`Removed plugin "${name}".`));
+}
+
+export async function updatePlugins(name?: string) {
+  ensurePluginsDir();
+  const dirs = name
+    ? [name]
+    : readdirSync(PLUGINS_DIR, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+
+  if (dirs.length === 0) {
+    console.log(cliStyles.muted("No plugins installed."));
+    return;
+  }
+
+  for (const dir of dirs) {
+    const targetDir = join(PLUGINS_DIR, dir);
+    if (!existsSync(join(targetDir, ".git"))) {
+      console.log(cliStyles.warning(`Skipping ${dir} (not a git repo)`));
+      continue;
+    }
+    console.log(cliStyles.accent(`Updating ${dir}...`));
+    try {
+      execSync("git pull", { cwd: targetDir, stdio: "inherit" });
+      const pkgPath = join(targetDir, "package.json");
+      if (existsSync(pkgPath)) {
+        execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+      }
+    } catch {
+      console.error(cliStyles.danger(`Failed to update ${dir}.`));
+    }
+  }
+}
+
+export function listPlugins() {
+  ensurePluginsDir();
+  const entries = readdirSync(PLUGINS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+
+  if (entries.length === 0) {
+    console.log(cliStyles.muted("No plugins installed."));
+    console.log(cliStyles.muted("Install one with: gloomberb install <github-user/repo>"));
+    return;
+  }
+
+  const rows = entries.map((entry) => {
+    const dir = join(PLUGINS_DIR, entry.name);
+    let version = "—";
+    let description = "—";
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        version = pkg.version || "—";
+        description = pkg.description || "—";
+      } catch {
+        description = "Unreadable package.json";
+      }
+    }
+    return [entry.name, version, description];
+  });
+
+  console.log(renderSection("Installed Plugins"));
+  console.log(renderTable(
+    [
+      { header: "Plugin" },
+      { header: "Version" },
+      { header: "Description" },
+    ],
+    rows,
+  ));
+  console.log("");
+  console.log(renderStat("Directory", PLUGINS_DIR));
+}