gloomberb 0.18.1 → 0.18.3

package/src/sync/core-contributors.ts

@@ -1,4 +1,5 @@
 import { scheduleConfigSave } from "../state/config-save-scheduler";
+import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
 import type { AppConfig, BrokerInstanceConfig, SavedLayout } from "../types/config";
@@ -39,6 +40,16 @@ import {
   knownBrokerHoldings,
   type KnownBrokerHoldings,
 } from "../brokers/broker-portfolio-sync";
+import {
+  isLocalOnlyInstance,
+  isLocalOnlyPortfolio,
+  localOnlyScope,
+  publicConfig,
+  publicMarketData,
+  publicTickers,
+  withLocalOnlyEntries,
+  type LocalOnlyScope,
+} from "./local-only";
 
 /**
  * What a saved layout mirrors from the live session rather than from the
@@ -612,9 +623,11 @@ function collectCoreCollectionsPayload(
   financials: Map<string, TickerFinancials>,
   exchangeRates: Map<string, number>,
   brokerAccounts: Record<string, BrokerAccount[]>,
+  /** The financials whose quotes may be uploaded: without those a source that keeps its market data local supplied. */
+  quoted: Map<string, TickerFinancials> = financials,
 ) {
   const records = [...tickers.values()]
-    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, financials.get(ticker.metadata.ticker)))
+    .map((ticker) => sanitizeTickerMetadata(ticker.metadata, quoted.get(ticker.metadata.ticker)))
     .filter(isSyncableTicker);
 
   // Only the USD anchor goes on the wire, as before: readers of the snapshot
@@ -873,14 +886,38 @@ interface LayoutMergeContext {
   pushedAt?: string;
 }
 
+/** A pulled config without profiles and portfolios that are local-only here (an older build may have pushed them). */
+function publicConfigPayload(payload: Record<string, unknown>, scope: LocalOnlyScope): Record<string, unknown> {
+  const without = (entries: unknown, isLocal: (entry: Record<string, unknown>) => boolean) => (
+    Array.isArray(entries) ? entries.filter((entry) => !isRecord(entry) || !isLocal(entry)) : entries
+  );
+  return {
+    ...payload,
+    ...("brokerInstances" in payload ? { brokerInstances: without(payload.brokerInstances, (entry) => isLocalOnlyInstance({ id: String(entry.id) }, scope)) } : {}),
+    ...("portfolios" in payload ? { portfolios: without(payload.portfolios, (entry) => isLocalOnlyPortfolio(entry as unknown as Portfolio, scope)) } : {}),
+  };
+}
+
 function mergeConfigPayload(
   config: AppConfig,
   payload: unknown,
   baselineConfig: AppConfig = config,
   lastSyncedPayload?: unknown,
   layoutContext: LayoutMergeContext = {},
+  scope: LocalOnlyScope | null = null,
 ): AppConfig | null {
   if (!isRecord(payload)) return null;
+  if (scope) {
+    // Merged as if the local-only profiles and portfolios were not here, then put back as they were.
+    const local = publicConfig(config, scope);
+    const merged = mergeConfigPayload(local, publicConfigPayload(payload, scope), baselineConfig === config ? local : publicConfig(baselineConfig, scope),
+      lastSyncedPayload, layoutContext);
+    return merged && {
+      ...merged,
+      brokerInstances: withLocalOnlyEntries(merged.brokerInstances, config.brokerInstances, (instance) => isLocalOnlyInstance(instance, scope)),
+      portfolios: withLocalOnlyEntries(merged.portfolios, config.portfolios, (portfolio) => isLocalOnlyPortfolio(portfolio, scope)),
+    };
+  }
   const next: AppConfig = { ...config };
   // Two guards, both needed. baselineConfig catches edits made while this pull
   // was in flight; lastSyncedPayload catches edits made while the app was not
@@ -900,6 +937,8 @@ function mergeConfigPayload(
   };
 
   assign("baseCurrency");
+  // A device on an older version may still send a name or sign (Canadian dollar, CA$): it applies as its code, as a saved one loads.
+  if (typeof next.baseCurrency === "string" && next.baseCurrency.trim()) next.baseCurrency = normalizeStoredBaseCurrency(next.baseCurrency);
   assign("refreshIntervalMinutes");
   if ("portfolios" in payload && canApply("portfolios")) {
     const syncedPortfolios = payload.portfolios;
@@ -1148,6 +1187,8 @@ interface PulledTickersMerge {
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
   brokerPortfolios: ReadonlyMap<string, "local" | "pulled">;
   known: KnownBrokerHoldings;
+  /** Connections kept on this device: their portfolios' holdings here outlast any pull. */
+  localOnly: LocalOnlyScope | null;
 }
 
 /**
@@ -1224,7 +1265,7 @@ function mergePulledTicker(
   const portfolios: string[] = [];
   for (const portfolioId of portfolioIds) {
     const brokerSide = merge.brokerPortfolios.get(portfolioId);
-    const takePulled = brokerSide
+    const takePulled = merge.localOnly?.portfolioIds.has(portfolioId) ? false : brokerSide
       ? brokerSide === "pulled"
       : !comparable || sameAsStored(
         holdingIn(localPositions, localLinks, portfolioId),
@@ -1269,7 +1310,7 @@ export const coreConfigSyncContributor: SyncContributor = {
   id: CORE_CONFIG_CONTRIBUTOR_ID,
   schemaVersion: 1,
   collect: ({ state, baselinePayload, memo }) => withLayoutProvenance(
-    collectCoreConfigPayload(state.config) as Record<string, unknown>,
+    collectCoreConfigPayload(publicConfig(state.config, localOnlyScope(state.config))) as Record<string, unknown>,
     baselinePayload,
     memo?.get(),
   ),
@@ -1282,7 +1323,7 @@ export const coreConfigSyncContributor: SyncContributor = {
     const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    });
+    }, localOnlyScope(state.config));
     if (!nextConfig) return;
     const configChanged = !valuesEqual(nextConfig, state.config);
     if (configChanged) {
@@ -1328,15 +1369,24 @@ export const coreConfigSyncContributor: SyncContributor = {
 export const coreCollectionsSyncContributor: SyncContributor = {
   id: "core.collections",
   schemaVersion: 1,
-  collect: async ({ state }) => collectCoreCollectionsPayload(
-    state.config,
-    state.tickers,
-    state.financials,
-    await loadHoldingExchangeRates(state.config, state.tickers, state.financials),
-    state.brokerAccounts,
-  ),
+  collect: async ({ state, isLocalMarketData }) => {
+    // Connections the user keeps on this device stay here, with their portfolios, account values and
+    // positions; so do the quotes and bars of a source that keeps its market data local.
+    const scope = localOnlyScope(state.config);
+    const config = publicConfig(state.config, scope);
+    const tickers = publicTickers(state.tickers, scope);
+    return collectCoreCollectionsPayload(
+      config,
+      tickers,
+      state.financials,
+      await loadHoldingExchangeRates(config, tickers, state.financials),
+      state.brokerAccounts,
+      publicMarketData(state.financials, isLocalMarketData),
+    );
+  },
   apply: async (payload, { snapshot, baselinePayload, baselineState, getState, isCurrent, dispatch, tickerRepository }) => {
     if (!isRecord(payload)) return;
+    const scope = localOnlyScope(getState().config);
     hydrateProfileAnalytics(payload);
     if (!isCurrent()) return;
     // The config contributor applies first, so this is the config this pull left.
@@ -1356,6 +1406,7 @@ export const coreCollectionsSyncContributor: SyncContributor = {
         portfolios: [pulledPortfolios, pulledConfig?.portfolios].flatMap(idEntries),
         brokerInstances: idEntries(pulledConfig?.brokerInstances),
       }),
+      localOnly: scope,
     };
     // Tickers here and pulled ones drop the ids of any watchlist that is gone
     // (removed elsewhere, or deleted by an older build that left its id on the

package/src/sync/local-only.ts

@@ -0,0 +1,121 @@
+import type { AppConfig, BrokerInstanceConfig } from "../types/config";
+import type { Quote, TickerFinancials } from "../types/financials";
+import type { BrokerContractRef } from "../types/instrument";
+import type { Portfolio, TickerPosition, TickerRecord } from "../types/ticker";
+
+/**
+ * Broker connections the user keeps on this device (`BrokerInstanceConfig.localOnly`), and the
+ * portfolios of their accounts. Cloud sync leaves the connections, those portfolios with their
+ * account values, and the positions held in them out of every push, and keeps them through every
+ * pull, so nothing of them reaches Gloom Cloud and a pull never removes them here.
+ */
+export interface LocalOnlyScope {
+  instanceIds: ReadonlySet<string>;
+  portfolioIds: ReadonlySet<string>;
+}
+
+/**
+ * Whether a source keeps the quotes and bars it supplies on this device (`BrokerAdapter.localMarketData`),
+ * by its provider id: a broker's is its broker id.
+ */
+export type LocalMarketDataLookup = (providerId: string) => boolean;
+
+/** The connections the user keeps on this device, or null when there are none. */
+export function localOnlyScope(config: Pick<AppConfig, "brokerInstances" | "portfolios">): LocalOnlyScope | null {
+  const instanceIds = new Set(config.brokerInstances.flatMap((instance) => instance.localOnly === true ? [instance.id] : []));
+  if (instanceIds.size === 0) return null;
+  const scope = { instanceIds, portfolioIds: new Set<string>() };
+  return { instanceIds, portfolioIds: new Set(config.portfolios.flatMap((portfolio) => isLocalOnlyPortfolio(portfolio, scope) ? [portfolio.id] : [])) };
+}
+
+export function isLocalOnlyInstance(instance: Pick<BrokerInstanceConfig, "id">, scope: LocalOnlyScope): boolean {
+  return scope.instanceIds.has(instance.id);
+}
+
+export function isLocalOnlyPortfolio(portfolio: Pick<Portfolio, "id" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(portfolio.id) || !!portfolio.brokerInstanceId && scope.instanceIds.has(portfolio.brokerInstanceId)
+    // A pulled portfolio has no profile id; its own id names the profile.
+    || [...scope.instanceIds].some((id) => portfolio.id.startsWith(`broker:${id}:`));
+}
+
+function isLocalOnlyPosition(position: Pick<TickerPosition, "portfolio" | "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return scope.portfolioIds.has(position.portfolio) || !!position.brokerInstanceId && scope.instanceIds.has(position.brokerInstanceId);
+}
+
+function isLocalOnlyContract(contract: Pick<BrokerContractRef, "brokerInstanceId">, scope: LocalOnlyScope): boolean {
+  return !!contract.brokerInstanceId && scope.instanceIds.has(contract.brokerInstanceId);
+}
+
+/** The config as Cloud sync may see it: without the connections kept on this device and their portfolios. */
+export function publicConfig<T extends Pick<AppConfig, "brokerInstances" | "portfolios">>(config: T, scope: LocalOnlyScope | null): T {
+  if (!scope) return config;
+  const brokerInstances = config.brokerInstances.filter((instance) => !isLocalOnlyInstance(instance, scope));
+  const portfolios = config.portfolios.filter((portfolio) => !isLocalOnlyPortfolio(portfolio, scope));
+  if (brokerInstances.length === config.brokerInstances.length && portfolios.length === config.portfolios.length) return config;
+  return { ...config, brokerInstances, portfolios };
+}
+
+/** The ticker as Cloud sync may see it: without positions, portfolios or contracts of connections kept on this device. */
+function publicTicker(ticker: TickerRecord, scope: LocalOnlyScope | null): TickerRecord {
+  if (!scope) return ticker;
+  const { metadata } = ticker;
+  const positions = metadata.positions.filter((position) => !isLocalOnlyPosition(position, scope));
+  const portfolios = metadata.portfolios.filter((id) => !scope.portfolioIds.has(id));
+  const contracts = metadata.broker_contracts?.filter((contract) => !isLocalOnlyContract(contract, scope));
+  if (positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
+    && contracts?.length === metadata.broker_contracts?.length) return ticker;
+  return { ...ticker, metadata: { ...metadata, positions, portfolios, ...(contracts ? { broker_contracts: contracts } : {}) } };
+}
+
+export function publicTickers(tickers: Map<string, TickerRecord>, scope: LocalOnlyScope | null): Map<string, TickerRecord> {
+  if (!scope) return tickers;
+  return new Map([...tickers].map(([symbol, ticker]) => [symbol, publicTicker(ticker, scope)]));
+}
+
+/** The quote fields sync uploads, any of which a source that keeps its market data local may have supplied. */
+const SYNCED_QUOTE_FIELDS = ["price", "change", "changePercent", "previousClose"] as const;
+
+function isLocalQuote(quote: Quote, isLocal: LocalMarketDataLookup): boolean {
+  const provenance = quote.provenance;
+  const providers = [quote.providerId, provenance?.price?.providerId, ...SYNCED_QUOTE_FIELDS.map((field) => provenance?.fields?.[field]?.providerId)];
+  return providers.some((providerId) => !!providerId && isLocal(providerId));
+}
+
+/** The provider of stored bars, from their source key: `provider:<id>` or `broker:<broker id>:<profile>`. */
+function historyProvider(sourceKey: string | undefined): string | null {
+  const [kind, id] = sourceKey?.split(":") ?? [];
+  return (kind === "provider" || kind === "broker") && id ? id : null;
+}
+
+/**
+ * Financials as Cloud sync may upload them: without a quote or bars a source that keeps its market
+ * data local supplied. Sync reads only the quote and the week's move from them.
+ */
+export function publicMarketData(financials: Map<string, TickerFinancials>, isLocal?: LocalMarketDataLookup): Map<string, TickerFinancials> {
+  if (!isLocal) return financials;
+  const output = new Map<string, TickerFinancials>();
+  for (const [symbol, entry] of financials) {
+    const localQuote = !!entry.quote && isLocalQuote(entry.quote, isLocal);
+    const provider = historyProvider(entry.priceHistorySourceKey);
+    const localBars = !!provider && isLocal(provider);
+    output.set(symbol, localQuote || localBars ? { ...entry, ...(localQuote ? { quote: undefined } : {}), ...(localBars ? { priceHistory: [] } : {}) } : entry);
+  }
+  return output;
+}
+
+/**
+ * `merged` (a list merged without the local-only entries) with this device's local-only entries
+ * of `local` back where they were: each stays at its place among the others, so an unchanged list
+ * comes back equal to `local`. An entry the pull brought that is local-only here is left out.
+ */
+export function withLocalOnlyEntries<T>(merged: readonly T[], local: readonly T[], isLocalOnly: (entry: T) => boolean): T[] {
+  const incoming = merged.filter((entry) => !isLocalOnly(entry));
+  const output: T[] = [];
+  let next = 0;
+  for (const entry of local) {
+    if (isLocalOnly(entry)) output.push(entry);
+    else if (next < incoming.length) output.push(incoming[next++]!);
+  }
+  output.push(...incoming.slice(next));
+  return output;
+}

package/src/sync/react.ts

@@ -41,6 +41,12 @@ export function useCloudSyncRuntime({
       baselineStore,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
+      isLocalMarketData: (providerId) => {
+        const broker = pluginRegistry.brokers.get(providerId);
+        if (broker) return broker.localMarketData === true;
+        // A broker whose plugin is off may still have its quotes about from before; they stay here too.
+        return getState().config.brokerInstances.some((instance) => instance.brokerType === providerId);
+      },
     });
   }, [baselineStore, dispatch, getState, pluginRegistry, tickerRepository]);
 

package/src/sync/types.ts

@@ -1,6 +1,7 @@
 import type { Dispatch } from "react";
 import type { AppAction, AppState } from "../core/state/app/state";
 import type { AppTickerRepositoryPort } from "../core/app-service-ports";
+import type { LocalMarketDataLookup } from "./local-only";
 
 export const SYNC_SNAPSHOT_SCHEMA_VERSION = 1;
 
@@ -31,6 +32,8 @@ interface SyncContributorMemo {
 
 interface SyncCollectContext {
   state: AppState;
+  /** Sources whose quotes and bars never leave this device (`BrokerAdapter.localMarketData`); none when absent. */
+  isLocalMarketData?: LocalMarketDataLookup;
   /** The payload this device last pushed for this contributor, or null when it never synced. */
   baselinePayload?: unknown;
   memo?: SyncContributorMemo;

package/src/telemetry/crash-reports.ts

@@ -5,6 +5,7 @@ import {
   type CrashReportKind,
   type CrashReportSurface,
   type CrashReportsPayload,
+  type UpdateFailureReport,
 } from "../api-client";
 import type { TelemetryConfig } from "../types/config";
 import { isSleepRpcTimeout } from "../utils/rpc-timeout-error";
@@ -68,6 +69,8 @@ export interface CrashReportContext {
   pane?: string;
   /** React's component stack for a render crash; appended to the stack. */
   componentStack?: string | null;
+  /** A failed update step (update-failures.ts), sent as it is: it holds no free text. */
+  update?: UpdateFailureReport;
 }
 
 interface PendingError {
@@ -167,6 +170,7 @@ function toReportError(error: unknown, context: CrashReportContext): PendingErro
       ...(stack ? { stack } : {}),
       ...(context.plugin ? { plugin: clip(context.plugin, MAX_LABEL_LENGTH) } : {}),
       ...(context.pane ? { pane: clip(context.pane, MAX_LABEL_LENGTH) } : {}),
+      ...(context.update ? { update: context.update } : {}),
     },
   };
 }

package/src/telemetry/update-failures-node.ts

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { UpdateChannel } from "../types/config";
+import type {
+  UpdateAttempt,
+  UpdateFailureReporterHost,
+  UpdateInstallKind,
+  UpdateReportState,
+} from "./update-failures";
+
+/** Next to config.json: when each update failure was last reported, and the last update attempt. */
+const STATE_FILE = "update-reports.json";
+
+function readAttempt(value: unknown): UpdateAttempt | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const { from, to, channel, at } = value as Record<string, unknown>;
+  if (typeof from !== "string" || typeof to !== "string" || typeof at !== "number" || !Number.isFinite(at)) return undefined;
+  return { from, to, channel: (channel === "nightly" ? "nightly" : "stable") satisfies UpdateChannel, at };
+}
+
+/** The saved state, keeping only entries of the right shape. */
+function parseUpdateReportState(text: string): UpdateReportState {
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed && typeof parsed === "object" ? parsed as Record<string, unknown> : {};
+  const sent: Record<string, number> = {};
+  if (record.sent && typeof record.sent === "object") {
+    for (const [key, at] of Object.entries(record.sent as Record<string, unknown>)) {
+      if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
+    }
+  }
+  const staged = readAttempt(record.staged);
+  const applying = readAttempt(record.applying);
+  return { sent, ...(staged ? { staged } : {}), ...(applying ? { applying } : {}) };
+}
+
+/** The update failure reporter for a Bun process (the terminal app, the desktop app's main process). */
+export function createNodeUpdateFailureHost(options: {
+  installKind: UpdateInstallKind;
+  /** The profile's data folder, or null before the config is loaded. */
+  getDataDir(): string | null;
+}): UpdateFailureReporterHost {
+  return {
+    installKind: options.installKind,
+    platform: process.platform,
+    arch: process.arch,
+    load: () => {
+      const dir = options.getDataDir();
+      const path = dir ? join(dir, STATE_FILE) : null;
+      if (!path || !existsSync(path)) return { sent: {} };
+      return parseUpdateReportState(readFileSync(path, "utf-8"));
+    },
+    save: (state) => {
+      const dir = options.getDataDir();
+      if (!dir) return;
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, STATE_FILE), JSON.stringify(state), "utf-8");
+    },
+  };
+}