gloomberb 0.9.6 → 0.9.8

package/src/sync/controller.ts

@@ -0,0 +1,296 @@
+import type { Dispatch } from "react";
+import type { AppAction, AppState } from "../core/state/app/state";
+import type { TickerRepository } from "../data/ticker-repository";
+import {
+  SYNC_SNAPSHOT_SCHEMA_VERSION,
+  type RegisteredSyncContributor,
+  type RegisteredSyncTransport,
+  type SyncContributor,
+  type SyncSnapshot,
+  type SyncTransport,
+} from "./types";
+
+export type CloudSyncPhase = "idle" | "disabled" | "syncing" | "synced" | "error";
+
+export interface CloudSyncStatus {
+  phase: CloudSyncPhase;
+  transportId: string | null;
+  lastSyncAt: string | null;
+  lastPullAt: string | null;
+  revision: number | null;
+  error: string | null;
+}
+
+interface SyncRuntime {
+  state: AppState;
+  dispatch: Dispatch<AppAction>;
+  tickerRepository: TickerRepository;
+  getContributors: () => RegisteredSyncContributor[];
+  getTransport: () => RegisteredSyncTransport | null;
+}
+
+const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
+const PUSH_DEBOUNCE_MS = 2500;
+const PULL_MIN_INTERVAL_MS = 60_000;
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function stableStringify(value: unknown): string {
+  if (value == null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const entries = Object.entries(value as Record<string, unknown>)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child)}`);
+  return `{${entries.join(",")}}`;
+}
+
+function resolveClientId(): string {
+  const storage = globalThis.localStorage;
+  const existing = storage?.getItem(CLIENT_ID_STORAGE_KEY);
+  if (existing) return existing;
+  const id = `client_${crypto.randomUUID()}`;
+  storage?.setItem(CLIENT_ID_STORAGE_KEY, id);
+  return id;
+}
+
+class CloudSyncController {
+  private runtime: SyncRuntime | null = null;
+  private contributors = new Map<string, RegisteredSyncContributor>();
+  private transports = new Map<string, RegisteredSyncTransport>();
+  private listeners = new Set<() => void>();
+  private pushTimer: ReturnType<typeof setTimeout> | null = null;
+  private inFlight: Promise<void> | null = null;
+  private clientId: string | null = null;
+  private lastSignature: string | null = null;
+  private lastPulledAtMs = 0;
+  private hasPulledForTransport = new Set<string>();
+  private status: CloudSyncStatus = {
+    phase: "idle",
+    transportId: null,
+    lastSyncAt: null,
+    lastPullAt: null,
+    revision: null,
+    error: null,
+  };
+
+  registerContributor(pluginId: string, contributor: SyncContributor): () => void {
+    this.contributors.set(contributor.id, { pluginId, contributor });
+    this.emit();
+    return () => {
+      const current = this.contributors.get(contributor.id);
+      if (current?.contributor === contributor) {
+        this.contributors.delete(contributor.id);
+        this.emit();
+      }
+    };
+  }
+
+  registerTransport(pluginId: string, transport: SyncTransport): () => void {
+    this.transports.set(transport.id, { pluginId, transport });
+    this.emit();
+    return () => {
+      const current = this.transports.get(transport.id);
+      if (current?.transport === transport) {
+        this.transports.delete(transport.id);
+        this.emit();
+      }
+    };
+  }
+
+  getRegisteredContributors(): RegisteredSyncContributor[] {
+    return [...this.contributors.values()];
+  }
+
+  getRegisteredTransports(): RegisteredSyncTransport[] {
+    return [...this.transports.values()];
+  }
+
+  setRuntime(runtime: SyncRuntime): void {
+    this.runtime = runtime;
+    this.updateAvailability();
+  }
+
+  clearRuntime(): void {
+    this.runtime = null;
+    if (this.pushTimer) clearTimeout(this.pushTimer);
+    this.pushTimer = null;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  getStatus(): CloudSyncStatus {
+    return this.status;
+  }
+
+  schedulePush(reason: string): void {
+    const runtime = this.runtime;
+    if (!runtime) return;
+    const transport = runtime.getTransport();
+    if (!transport?.transport.isAvailable()) {
+      this.setStatus({
+        phase: "disabled",
+        transportId: transport?.transport.id ?? null,
+        error: null,
+      });
+      return;
+    }
+    if (this.pushTimer) clearTimeout(this.pushTimer);
+    this.pushTimer = setTimeout(() => {
+      void this.requestSync({ reason });
+    }, PUSH_DEBOUNCE_MS);
+  }
+
+  async requestSync(options: { reason?: string; force?: boolean } = {}): Promise<void> {
+    if (this.inFlight) return this.inFlight;
+    const run = this.syncOnce(options).finally(() => {
+      this.inFlight = null;
+    });
+    this.inFlight = run;
+    return run;
+  }
+
+  async pullLatest(options: { force?: boolean } = {}): Promise<void> {
+    const runtime = this.runtime;
+    if (!runtime) return;
+    const transport = runtime.getTransport();
+    if (!transport?.transport.isAvailable()) {
+      this.setStatus({ phase: "disabled", transportId: transport?.transport.id ?? null, error: null });
+      return;
+    }
+    const currentMs = Date.now();
+    if (!options.force && currentMs - this.lastPulledAtMs < PULL_MIN_INTERVAL_MS) return;
+    this.lastPulledAtMs = currentMs;
+    await this.runPull(runtime, transport.transport);
+  }
+
+  private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
+    const runtime = this.runtime;
+    if (!runtime) return;
+    const transportRegistration = runtime.getTransport();
+    if (!transportRegistration?.transport.isAvailable()) {
+      this.setStatus({ phase: "disabled", transportId: transportRegistration?.transport.id ?? null, error: null });
+      return;
+    }
+    const transport = transportRegistration.transport;
+    if (!this.hasPulledForTransport.has(transport.id)) {
+      await this.runPull(runtime, transport);
+      this.hasPulledForTransport.add(transport.id);
+    }
+
+    const snapshot = await this.assembleSnapshot(runtime);
+    const signature = stableStringify(snapshot.contributors);
+    if (!options.force && signature === this.lastSignature) return;
+
+    this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
+    try {
+      const result = await transport.pushSnapshot(snapshot, { baseRevision: this.status.revision });
+      this.lastSignature = signature;
+      this.setStatus({
+        phase: "synced",
+        transportId: transport.id,
+        revision: result.revision,
+        lastSyncAt: result.updatedAt,
+        error: null,
+      });
+    } catch (error) {
+      this.setStatus({
+        phase: "error",
+        transportId: transport.id,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<void> {
+    this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
+    try {
+      const response = await transport.pullSnapshot();
+      this.setStatus({
+        phase: response.snapshot ? "synced" : "idle",
+        transportId: transport.id,
+        revision: response.revision,
+        lastPullAt: response.updatedAt ?? nowIso(),
+        lastSyncAt: response.updatedAt,
+        error: null,
+      });
+      if (!response.snapshot) return;
+      for (const entry of runtime.getContributors()) {
+        const payload = response.snapshot.contributors[entry.contributor.id]?.payload;
+        if (payload === undefined || !entry.contributor.apply) continue;
+        await entry.contributor.apply(payload, {
+          snapshot: response.snapshot,
+          state: runtime.state,
+          dispatch: runtime.dispatch,
+          tickerRepository: runtime.tickerRepository,
+        });
+      }
+    } catch (error) {
+      this.setStatus({
+        phase: "error",
+        transportId: transport.id,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  private async assembleSnapshot(runtime: SyncRuntime): Promise<SyncSnapshot> {
+    const contributors = runtime.getContributors();
+    const createdAt = nowIso();
+    const payloads: SyncSnapshot["contributors"] = {};
+    for (const entry of contributors) {
+      const payload = await entry.contributor.collect({ state: runtime.state });
+      payloads[entry.contributor.id] = {
+        schemaVersion: entry.contributor.schemaVersion,
+        updatedAt: createdAt,
+        payload,
+      };
+    }
+    return {
+      schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+      appId: "gloomberb",
+      clientId: this.clientId ??= resolveClientId(),
+      createdAt,
+      contributors: payloads,
+    };
+  }
+
+  private updateAvailability(): void {
+    const transport = this.runtime?.getTransport() ?? null;
+    if (!transport) {
+      this.setStatus({ phase: "disabled", transportId: null, error: null });
+      return;
+    }
+    if (!transport.transport.isAvailable()) {
+      this.setStatus({ phase: "disabled", transportId: transport.transport.id, error: null });
+      return;
+    }
+    if (
+      this.status.transportId === transport.transport.id &&
+      this.status.phase !== "disabled" &&
+      this.status.phase !== "idle"
+    ) {
+      return;
+    }
+    this.setStatus({
+      phase: "idle",
+      transportId: transport.transport.id,
+      error: null,
+    });
+  }
+
+  private setStatus(patch: Partial<CloudSyncStatus>): void {
+    this.status = { ...this.status, ...patch };
+    this.emit();
+  }
+
+  private emit(): void {
+    for (const listener of this.listeners) listener();
+  }
+}
+
+export const cloudSyncController = new CloudSyncController();

package/src/sync/core-contributors.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, test } from "bun:test";
+import { createInitialState } from "../core/state/app/state";
+import { createDefaultConfig } from "../types/config";
+import type { PricePoint } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+import {
+  __syncContributorInternalsForTests,
+  coreCollectionsSyncContributor,
+  coreConfigSyncContributor,
+} from "./core-contributors";
+import { setSyncedProfileAnalytics } from "./profile-analytics";
+
+describe("core sync contributors", () => {
+  function priceHistoryFromReturns(returns: number[]): PricePoint[] {
+    let close = 100;
+    return [
+      { date: new Date("2026-06-01T20:00:00.000Z"), close },
+      ...returns.map((value, index) => {
+        close *= 1 + value;
+        return {
+          date: new Date(Date.UTC(2026, 5, index + 2, 20)),
+          close,
+        };
+      }),
+    ];
+  }
+
+  test("redacts local paths and credential-like config keys", async () => {
+    const config = createDefaultConfig("/Users/vince/private-data");
+    config.brokerInstances = [{
+      id: "broker-1",
+      brokerType: "demo",
+      label: "Demo Broker",
+      config: {
+        apiKey: "secret-api-key",
+        password: "secret-password",
+      },
+    }];
+    config.pluginConfig = {
+      "demo-plugin": {
+        theme: "dark",
+        token: "secret-token",
+        downloadPath: "/Users/vince/private-downloads",
+      },
+    };
+
+    const state = createInitialState(config);
+    const payload = await coreConfigSyncContributor.collect({ state });
+    const serialized = JSON.stringify(payload);
+
+    expect(serialized).not.toContain("/Users/vince/private-data");
+    expect(serialized).not.toContain("/Users/vince/private-downloads");
+    expect(serialized).not.toContain("secret-api-key");
+    expect(serialized).not.toContain("secret-password");
+    expect(serialized).not.toContain("secret-token");
+    expect(serialized).toContain("Demo Broker");
+  });
+
+  test("syncs collection memberships and sanitized positions", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    config.portfolios = [{
+      id: "main",
+      name: "Main",
+      currency: "USD",
+      brokerAccountId: "account-id",
+      brokerInstanceId: "broker-id",
+    }];
+    config.watchlists = [{ id: "ai", name: "AI" }];
+    const ticker: TickerRecord = {
+      metadata: {
+        ticker: "NVDA",
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: "NVIDIA",
+        portfolios: ["main"],
+        watchlists: ["ai"],
+        positions: [{
+          portfolio: "main",
+          shares: 10,
+          avgCost: 100,
+          broker: "manual",
+          marketValue: 1500,
+          brokerAccountId: "account-id",
+          brokerInstanceId: "broker-id",
+          brokerContractId: 42,
+        }],
+        custom: { secretToken: "hidden", note: "keep" },
+        tags: ["semis"],
+      },
+    };
+    const state = createInitialState(config);
+    state.tickers = new Map([["NVDA", ticker]]);
+    state.financials = new Map([[
+      "NVDA",
+      {
+        quote: {
+          symbol: "NVDA",
+          price: 150,
+          currency: "USD",
+          change: 1,
+          changePercent: 2,
+          lastUpdated: 1,
+        },
+        fundamentals: { return1Y: 0.42 },
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [
+          { date: new Date("2026-06-23T20:00:00.000Z"), close: 125 },
+          { date: new Date("2026-06-30T20:00:00.000Z"), close: 149 },
+        ],
+      },
+    ]]);
+
+    const payload = await coreCollectionsSyncContributor.collect({ state });
+    const serialized = JSON.stringify(payload);
+
+    expect(serialized).toContain("NVDA");
+    expect(serialized).toContain("AI");
+    expect(serialized).toContain("Main");
+    expect(serialized).toContain("keep");
+    expect(serialized).not.toContain("account-id");
+    expect(serialized).not.toContain("broker-id");
+    expect(serialized).not.toContain("hidden");
+    expect(serialized).not.toContain("brokerContractId");
+    expect((payload as any).baseCurrency).toBe("USD");
+    expect((payload as any).exchangeRates).toEqual({ USD: 1 });
+    expect((payload as any).tickers[0].quote.price).toBe(150);
+    expect((payload as any).tickers[0].quote.weekReferencePrice).toBe(125);
+    expect((payload as any).tickers[0].quote.weekChangePercent).toBe(20);
+    expect((payload as any).analyticsByPortfolio.main.oneYearReturn).toBe(0.42);
+  });
+
+  test("syncs only public return and beta analytics", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    config.baseCurrency = "USD";
+    config.portfolios = [
+      { id: "main", name: "Main", currency: "USD" },
+      {
+        id: "broker:ibkr:U123",
+        name: "U123",
+        currency: "USD",
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr",
+        brokerAccountId: "U123",
+      },
+    ];
+    config.brokerInstances = [{
+      id: "ibkr",
+      brokerType: "ibkr",
+      label: "IBKR",
+      config: {},
+      enabled: true,
+    }];
+    const ticker = (symbol: string, portfolio: string): TickerRecord => ({
+      metadata: {
+        ticker: symbol,
+        exchange: "TSE",
+        currency: "JPY",
+        name: symbol,
+        portfolios: [portfolio],
+        watchlists: [],
+        positions: [{
+          portfolio,
+          shares: 10,
+          avgCost: 900,
+          broker: "manual",
+          currency: "JPY",
+        }],
+        custom: {},
+        tags: [],
+      },
+    });
+    const state = createInitialState(config);
+    state.exchangeRates = new Map([["USD", 1], ["JPY", 0.0067]]);
+    state.tickers = new Map([
+      ["7203.T", ticker("7203.T", "main")],
+      ["6758.T", ticker("6758.T", "broker:ibkr:U123")],
+    ]);
+    state.financials = new Map([
+      ["7203.T", {
+        quote: { symbol: "7203.T", price: 1000, currency: "JPY", change: 0, changePercent: 0, lastUpdated: 1 },
+        fundamentals: { return1Y: 0.1 },
+        priceHistory: priceHistoryFromReturns([0.015, -0.0045, 0.018, 0.009, -0.006, 0.012, 0.0045, -0.003, 0.0105, 0.006, -0.0015]),
+        annualStatements: [],
+        quarterlyStatements: [],
+      }],
+      ["6758.T", {
+        quote: { symbol: "6758.T", price: 1000, currency: "JPY", change: 0, changePercent: 0, lastUpdated: 1 },
+        fundamentals: { return1Y: 0.2 },
+        priceHistory: priceHistoryFromReturns([0.03, -0.009, 0.036, 0.018, -0.012, 0.024, 0.009, -0.006, 0.021, 0.012, -0.003]),
+        annualStatements: [],
+        quarterlyStatements: [],
+      }],
+      ["SPY", {
+        quote: { symbol: "SPY", price: 100, currency: "USD", change: 0, changePercent: 0, lastUpdated: 1 },
+        priceHistory: priceHistoryFromReturns([0.01, -0.003, 0.012, 0.006, -0.004, 0.008, 0.003, -0.002, 0.007, 0.004, -0.001]),
+        annualStatements: [],
+        quarterlyStatements: [],
+      }],
+    ]);
+    state.brokerAccounts = {
+      ibkr: [{
+        accountId: "U123",
+        name: "U123",
+        currency: "USD",
+        source: "flex",
+        grossPositionValue: 1234,
+      }],
+    };
+
+    const payload = await coreCollectionsSyncContributor.collect({ state }) as any;
+
+    expect(payload.baseCurrency).toBe("USD");
+    expect(payload.exchangeRates).toEqual({ USD: 1, JPY: 0.0067 });
+    expect(payload.analyticsByPortfolio.main.oneYearReturn).toBe(0.1);
+    expect(payload.analyticsByPortfolio.main.spyBeta).toBeCloseTo(1.5, 5);
+    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].oneYearReturn).toBe(0.2);
+    expect(payload.analyticsByPortfolio["broker:ibkr:U123"].spyBeta).toBeCloseTo(3, 5);
+    expect(payload.analyticsByPortfolio.main).not.toHaveProperty("marketValue");
+    expect(payload.analyticsByPortfolio.main).not.toHaveProperty("holdingsCount");
+    expect(payload.analyticsByPortfolio.main).not.toHaveProperty("currency");
+    expect(payload.analyticsByPortfolio.main).not.toHaveProperty("sourceLabel");
+  });
+
+  test("redaction removes nested credential-shaped fields", () => {
+    const sanitized = __syncContributorInternalsForTests.sanitizeUnknown({
+      nested: {
+        refreshToken: "nope",
+        publicValue: "ok",
+      },
+    });
+
+    expect(sanitized).toEqual({ nested: { publicValue: "ok" } });
+  });
+
+  test("uses preview-computed profile analytics without exposing values", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-sync-test");
+    config.portfolios = [{ id: "preview", name: "Preview", currency: "USD" }];
+    const state = createInitialState(config);
+
+    setSyncedProfileAnalytics("preview", { oneYearReturn: 0.25, spyBeta: 1.4 });
+    const payload = await coreCollectionsSyncContributor.collect({ state }) as any;
+    setSyncedProfileAnalytics("preview", null);
+
+    expect(payload.analyticsByPortfolio.preview).toEqual({
+      oneYearReturn: 0.25,
+      spyBeta: 1.4,
+    });
+    expect(payload.analyticsByPortfolio.preview).not.toHaveProperty("marketValue");
+  });
+});