gloomberb 0.7.2 → 0.7.4

package/src/data/config-store-node.ts

@@ -1,4 +1,5 @@
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
 import { dirname, join } from "path";
 import type {
   AppConfig,
@@ -20,6 +21,15 @@ import { isLayoutConfig, sanitizeLayout } from "./config-layout";
 
 const configLog = debugLog.createLogger("config");
 const LEGACY_MAIN_PORTFOLIO_COLUMN_IDS = DEFAULT_COLUMNS.map((column) => column.id);
+const PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS = [
+  ...DEFAULT_COLUMNS.map((column) => column.id),
+  "shares",
+  "avg_cost",
+  "cost_basis",
+  "mkt_value",
+  "pnl",
+  "pnl_pct",
+];
 const BUILTIN_SOURCE_IDS = new Set(["yahoo", "gloomberb-cloud"]);
 const BUILTIN_PLUGIN_GROUP_ALIASES: Record<string, string> = {
   "comparison-chart": "market-overview",
@@ -37,13 +47,25 @@ const BUILTIN_PLUGIN_GROUP_ALIASES: Record<string, string> = {
 };
 
 function getGlobalConfigDir(): string {
-  return join(process.env.HOME || "~", ".gloomberb");
+  return join(getHomeDir(), ".gloomberb");
 }
 
 function getGlobalConfigFile(): string {
   return join(getGlobalConfigDir(), "config.json");
 }
 
+function getHomeDir(): string {
+  return process.env.HOME || homedir();
+}
+
+function expandHomePath(filePath: string): string {
+  if (filePath === "~") return getHomeDir();
+  if (filePath.startsWith("~/") || filePath.startsWith("~\\")) {
+    return join(getHomeDir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
 export async function getDataDir(): Promise<string | null> {
   try {
     const raw = await readFile(getGlobalConfigFile(), "utf-8");
@@ -89,7 +111,9 @@ function normalizeConfig(saved: Record<string, unknown>, dataDir: string): { con
   const activeLayoutIndex = sanitizeActiveLayoutIndex(saved.activeLayoutIndex, layouts.length);
   const layout = cloneLayout(layouts[activeLayoutIndex]?.layout ?? directLayout);
   const syncedLayouts = layouts.map((entry, index) => (
-    index === activeLayoutIndex ? { ...entry, layout: cloneLayout(layout) } : entry
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(layout), paneState: sanitizeSavedPaneState(entry.paneState, layout) }
+      : entry
   ));
 
   const disabledPlugins = sanitizeDisabledPlugins(saved, defaults.disabledPlugins, {
@@ -138,7 +162,9 @@ export async function saveConfig(config: AppConfig): Promise<void> {
   const activeLayoutIndex = sanitizeActiveLayoutIndex(config.activeLayoutIndex, config.layouts.length || 1);
   const layout = sanitizeLayout(config.layout, createDefaultConfig(config.dataDir).layout);
   const layouts = sanitizeSavedLayouts(config.layouts, layout).map((entry, index) => (
-    index === activeLayoutIndex ? { ...entry, layout: cloneLayout(layout) } : entry
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(layout), paneState: sanitizeSavedPaneState(entry.paneState, layout) }
+      : entry
   ));
 
   const persisted: AppConfig = {
@@ -158,7 +184,14 @@ export async function saveConfig(config: AppConfig): Promise<void> {
     recentTickers: sanitizeStringArray(config.recentTickers, []),
   };
 
-  await writeFile(configPath, JSON.stringify(persisted, null, 2), "utf-8");
+  const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(persisted, null, 2), "utf-8");
+    await rename(tempPath, configPath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => {});
+    throw error;
+  }
 }
 
 export async function initDataDir(dataDir: string): Promise<AppConfig> {
@@ -177,11 +210,11 @@ export async function resetAllData(dataDir: string): Promise<void> {
 
 export async function exportConfig(config: AppConfig, destPath: string): Promise<void> {
   const { dataDir, ...rest } = config;
-  await writeFile(destPath, JSON.stringify(rest, null, 2), "utf-8");
+  await writeFile(expandHomePath(destPath), JSON.stringify(rest, null, 2), "utf-8");
 }
 
 export async function importConfig(dataDir: string, srcPath: string): Promise<AppConfig> {
-  const raw = await readFile(srcPath, "utf-8");
+  const raw = await readFile(expandHomePath(srcPath), "utf-8");
   const saved = JSON.parse(raw) as Record<string, unknown>;
   const { config } = normalizeConfig(saved, dataDir);
   await saveConfig(config);
@@ -238,6 +271,41 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function sanitizeSerializableValue(value: unknown): unknown {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => sanitizeSerializableValue(entry))
+      .filter((entry) => entry !== undefined);
+  }
+  if (isPlainRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value)
+        .map(([key, entry]) => [key, sanitizeSerializableValue(entry)])
+        .filter(([, entry]) => entry !== undefined),
+    );
+  }
+  return undefined;
+}
+
+function sanitizeSavedPaneState(
+  value: unknown,
+  layout: LayoutConfig,
+): Record<string, Record<string, unknown>> | undefined {
+  if (!isPlainRecord(value)) return undefined;
+  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
+  const paneState = Object.fromEntries(
+    Object.entries(value)
+      .filter(([paneId, entry]) => validPaneIds.has(paneId) && isPlainRecord(entry))
+      .map(([paneId, entry]) => [paneId, sanitizeSerializableValue(entry)])
+      .filter((entry): entry is [string, Record<string, unknown>] => isPlainRecord(entry[1])),
+  );
+  return paneState;
+}
+
 function isPluginConfigMap(value: unknown): value is Record<string, Record<string, unknown>> {
   if (!isPlainRecord(value)) return false;
   return Object.values(value).every((entry) => isPlainRecord(entry));
@@ -266,7 +334,8 @@ function isChartPreferences(value: unknown): value is ChartPreferences {
   return (defaultRenderMode === "area"
     || defaultRenderMode === "line"
     || defaultRenderMode === "candles"
-    || defaultRenderMode === "ohlc")
+    || defaultRenderMode === "ohlc"
+    || defaultRenderMode === "hlc")
     && (renderer === "auto" || renderer === "kitty" || renderer === "braille");
 }
 
@@ -278,6 +347,7 @@ function sanitizeChartPreferences(value: unknown, fallback: ChartPreferences): C
     || candidate.defaultRenderMode === "line"
     || candidate.defaultRenderMode === "candles"
     || candidate.defaultRenderMode === "ohlc"
+    || candidate.defaultRenderMode === "hlc"
     ? candidate.defaultRenderMode
     : fallback.defaultRenderMode;
   const renderer = candidate.renderer === "auto"
@@ -342,24 +412,31 @@ function hasExactColumnIds(value: unknown, expected: string[]): boolean {
     && value.every((entry, index) => entry === expected[index]);
 }
 
+function shouldMigratePortfolioColumnIds(value: unknown): boolean {
+  return hasExactColumnIds(value, LEGACY_MAIN_PORTFOLIO_COLUMN_IDS)
+    || hasExactColumnIds(value, PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS);
+}
+
 function migrateLegacyPortfolioDefaultColumns(layout: LayoutConfig, enabled: boolean): LayoutConfig {
   if (!enabled) return layout;
 
-  const instanceIndex = layout.instances.findIndex((instance) =>
-    instance.instanceId === "portfolio-list:main"
-    && instance.paneId === "portfolio-list"
-    && hasExactColumnIds(instance.settings?.columnIds, LEGACY_MAIN_PORTFOLIO_COLUMN_IDS)
-  );
-  if (instanceIndex < 0) return layout;
+  const instanceIndices = layout.instances.flatMap((instance, index) => (
+    instance.paneId === "portfolio-list" && shouldMigratePortfolioColumnIds(instance.settings?.columnIds)
+      ? [index]
+      : []
+  ));
+  if (instanceIndices.length === 0) return layout;
 
   const nextLayout = cloneLayout(layout);
-  nextLayout.instances[instanceIndex] = {
-    ...nextLayout.instances[instanceIndex]!,
-    settings: {
-      ...(nextLayout.instances[instanceIndex]?.settings ?? {}),
-      columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
-    },
-  };
+  for (const instanceIndex of instanceIndices) {
+    nextLayout.instances[instanceIndex] = {
+      ...nextLayout.instances[instanceIndex]!,
+      settings: {
+        ...(nextLayout.instances[instanceIndex]?.settings ?? {}),
+        columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
+      },
+    };
+  }
   return nextLayout;
 }
 
@@ -374,10 +451,21 @@ function sanitizeSavedLayouts(value: unknown, fallbackLayout: LayoutConfig): Sav
       && typeof entry === "object"
       && typeof (entry as SavedLayout).name === "string",
     )
-    .map((entry) => ({
-      name: entry.name,
-      layout: sanitizeLayout(entry.layout, fallbackLayout),
-    }));
+    .map((entry) => {
+      const layout = sanitizeLayout(entry.layout, fallbackLayout);
+      return {
+        id: typeof entry.id === "string" ? entry.id : undefined,
+        name: entry.name,
+        layout,
+        paneState: sanitizeSavedPaneState((entry as { paneState?: unknown }).paneState, layout),
+        focusedPaneId: typeof entry.focusedPaneId === "string" || entry.focusedPaneId === null
+          ? entry.focusedPaneId
+          : undefined,
+        activePanel: entry.activePanel === "right" || entry.activePanel === "left"
+          ? entry.activePanel
+          : undefined,
+      };
+    });
 
   return layouts.length > 0 ? layouts : [{ name: "Default", layout: cloneLayout(fallbackLayout) }];
 }

package/src/data/config-store.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { join } from "path";
 import { tmpdir } from "os";
-import { loadConfig, sanitizeLayout, saveConfig } from "./config-store";
+import { exportConfig, importConfig, loadConfig, sanitizeLayout, saveConfig } from "./config-store";
 import {
   CURRENT_CONFIG_VERSION,
   DEFAULT_COLUMNS,
@@ -219,7 +219,7 @@ describe("loadConfig", () => {
     await writeConfigJson(dataDir, createSavedConfig({
       configVersion: 7,
       chartPreferences: {
-        defaultRenderMode: "line",
+        defaultRenderMode: "hlc",
         renderer: "nope",
       },
     }));
@@ -227,7 +227,7 @@ describe("loadConfig", () => {
     const config = await loadConfig(dataDir);
 
     expect(config.chartPreferences).toEqual({
-      defaultRenderMode: "line",
+      defaultRenderMode: "hlc",
       renderer: "auto",
     });
     expect(config.pluginConfig).toEqual({});
@@ -342,6 +342,40 @@ describe("loadConfig", () => {
     });
   });
 
+  test("preserves saved layout pane state and focus metadata", async () => {
+    const dataDir = await createTempConfigDir();
+    await writeConfigJson(dataDir, createSavedConfig({
+      layouts: [{
+        name: "Chart",
+        layout: DEFAULT_LAYOUT,
+        paneState: {
+          "ticker-detail:main": { activeTabId: "chart" },
+          "missing:pane": { activeTabId: "overview" },
+        },
+        focusedPaneId: "ticker-detail:main",
+        activePanel: "right",
+      }],
+    }));
+
+    const config = await loadConfig(dataDir);
+
+    expect(config.layouts[0]?.paneState).toEqual({
+      "ticker-detail:main": { activeTabId: "chart" },
+    });
+    expect(config.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
+    expect(config.layouts[0]?.activePanel).toBe("right");
+
+    await saveConfig(config);
+    const persisted = JSON.parse(await readFile(join(dataDir, "config.json"), "utf-8")) as {
+      layouts: Array<{ paneState?: Record<string, unknown>; focusedPaneId?: string | null; activePanel?: string }>;
+    };
+    expect(persisted.layouts[0]?.paneState).toEqual({
+      "ticker-detail:main": { activeTabId: "chart" },
+    });
+    expect(persisted.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
+    expect(persisted.layouts[0]?.activePanel).toBe("right");
+  });
+
   test("migrates legacy main portfolio panes to the portfolio default columns", async () => {
     const dataDir = await createTempConfigDir();
     const legacyColumnIds = DEFAULT_COLUMNS.map((column) => column.id);
@@ -417,3 +451,31 @@ describe("loadConfig", () => {
     expect(persisted.layouts[1]?.layout).toEqual(DEFAULT_LAYOUT);
   });
 });
+
+describe("config backup files", () => {
+  test("expands a leading tilde when exporting and importing", async () => {
+    const originalHome = process.env.HOME;
+    const homeDir = await createTempConfigDir();
+    const dataDir = await createTempConfigDir();
+    const importDataDir = await createTempConfigDir();
+    process.env.HOME = homeDir;
+
+    try {
+      const config = await loadConfig(dataDir);
+      await exportConfig({ ...config, baseCurrency: "EUR" }, "~/gloomberb-config-backup.json");
+
+      const backupPath = join(homeDir, "gloomberb-config-backup.json");
+      const exported = JSON.parse(await readFile(backupPath, "utf-8")) as Record<string, unknown>;
+      expect(exported.baseCurrency).toBe("EUR");
+      expect(exported.dataDir).toBeUndefined();
+
+      await writeFile(backupPath, JSON.stringify({ ...exported, baseCurrency: "JPY" }), "utf-8");
+      const imported = await importConfig(importDataDir, "~/gloomberb-config-backup.json");
+
+      expect(imported.baseCurrency).toBe("JPY");
+      expect(imported.dataDir).toBe(importDataDir);
+    } finally {
+      process.env.HOME = originalHome;
+    }
+  });
+});

package/src/data/plugin-state-store.ts

@@ -10,6 +10,13 @@ export interface PluginStateRecord<T = unknown> {
   updatedAt: number;
 }
 
+export interface PluginStateSetEntry {
+  pluginId: string;
+  key: string;
+  value: unknown;
+  schemaVersion?: number;
+}
+
 interface CachedPluginStateRecord {
   value: unknown;
   schemaVersion: number;
@@ -64,22 +71,41 @@ export class PluginStateStore {
   }
 
   set(pluginId: string, key: string, value: unknown, schemaVersion = DEFAULT_PLUGIN_STATE_SCHEMA_VERSION): void {
-    const rawValue = serializeJson(value);
+    this.setMany([{ pluginId, key, value, schemaVersion }]);
+  }
+
+  setMany(entries: PluginStateSetEntry[]): void {
+    if (entries.length === 0) return;
     const updatedAt = Date.now();
+    const records = entries.map((entry) => ({
+      pluginId: entry.pluginId,
+      key: entry.key,
+      value: entry.value,
+      schemaVersion: entry.schemaVersion ?? DEFAULT_PLUGIN_STATE_SCHEMA_VERSION,
+      rawValue: serializeJson(entry.value),
+    }));
+
     withSqliteBusyRetry("save plugin state", () => {
-      this.db
-        .query(
-          `INSERT OR REPLACE INTO plugin_state (plugin_id, key, schema_version, value, updated_at)
-           VALUES (?, ?, ?, ?, ?)`,
-        )
-        .run(pluginId, key, schemaVersion, rawValue, updatedAt);
-    });
-    this.cache.set(`${pluginId}:${key}`, {
-      value,
-      schemaVersion,
-      updatedAt,
-      rawValue,
+      const insert = this.db.query(
+        `INSERT OR REPLACE INTO plugin_state (plugin_id, key, schema_version, value, updated_at)
+         VALUES (?, ?, ?, ?, ?)`,
+      );
+      const tx = this.db.transaction(() => {
+        for (const record of records) {
+          insert.run(record.pluginId, record.key, record.schemaVersion, record.rawValue, updatedAt);
+        }
+      });
+      tx();
     });
+
+    for (const record of records) {
+      this.cache.set(`${record.pluginId}:${record.key}`, {
+        value: record.value,
+        schemaVersion: record.schemaVersion,
+        updatedAt,
+        rawValue: record.rawValue,
+      });
+    }
   }
 
   delete(pluginId: string, key: string): void {

package/src/data/sqlite-cache.test.ts

@@ -127,6 +127,19 @@ describe("AppPersistence", () => {
     persistence.close();
   });
 
+  test("stores multiple plugin state records in one batch", () => {
+    const dbPath = createTempDbPath("plugin-state-batch");
+    const persistence = new AppPersistence(dbPath);
+    persistence.pluginState.setMany([
+      { pluginId: "ai", key: "provider", value: "openai", schemaVersion: 1 },
+      { pluginId: "news", key: "resume:read", value: { ids: ["1"] }, schemaVersion: 2 },
+    ]);
+
+    expect(persistence.pluginState.get<string>("ai", "provider", 1)?.value).toBe("openai");
+    expect(persistence.pluginState.get<{ ids: string[] }>("news", "resume:read", 2)?.value.ids).toEqual(["1"]);
+    persistence.close();
+  });
+
   test("stores and returns session snapshots", () => {
     const dbPath = createTempDbPath("session-snapshot");
     const persistence = new AppPersistence(dbPath);

package/src/market-data/coordinator-subscriptions.test.ts

@@ -43,6 +43,79 @@ async function flushCoordinator(): Promise<void> {
 }
 
 describe("MarketDataCoordinator key subscriptions", () => {
+  test("subscribes active quote targets as one provider batch", () => {
+    const subscriptions: QuoteSubscriptionTarget[][] = [];
+    const provider = createTestDataProvider({
+      id: "test-provider",
+      subscribeQuotes: (targets) => {
+        subscriptions.push(targets);
+        return () => {};
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    coordinator.subscribeQuotes([
+      {
+        instrument: { symbol: "AAPL", exchange: "NASDAQ" },
+        priority: { surface: "portfolio", visible: true, selected: true, weight: 100 },
+      },
+      { instrument: { symbol: "MSFT", exchange: "NASDAQ" } },
+    ]);
+
+    expect(subscriptions).toHaveLength(1);
+    expect(subscriptions[0]?.map((target) => target.symbol).sort()).toEqual(["AAPL", "MSFT"]);
+    expect(subscriptions[0]?.find((target) => target.symbol === "AAPL")).toMatchObject({
+      surface: "portfolio",
+      visible: true,
+      selected: true,
+      weight: 100,
+    });
+  });
+
+  test("keeps the highest-priority target when duplicate surfaces subscribe", () => {
+    const subscriptions: QuoteSubscriptionTarget[][] = [];
+    let disposals = 0;
+    const provider = createTestDataProvider({
+      id: "test-provider",
+      subscribeQuotes: (targets) => {
+        subscriptions.push(targets);
+        return () => {
+          disposals += 1;
+        };
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    const unsubscribeDetail = coordinator.subscribeQuotes([{
+      instrument,
+      priority: { surface: "detail", visible: true, selected: true, weight: 100 },
+    }]);
+    coordinator.subscribeQuotes([{
+      instrument,
+      priority: { surface: "portfolio", visible: false, selected: false, weight: 10 },
+    }]);
+
+    expect(subscriptions).toHaveLength(1);
+    expect(subscriptions[0]?.[0]).toMatchObject({
+      surface: "detail",
+      visible: true,
+      selected: true,
+      weight: 100,
+    });
+
+    unsubscribeDetail();
+
+    expect(subscriptions).toHaveLength(2);
+    expect(disposals).toBe(1);
+    expect(subscriptions[1]?.[0]).toMatchObject({
+      surface: "portfolio",
+      visible: false,
+      selected: false,
+      weight: 10,
+    });
+  });
+
   test("notifies listeners for changed keys only", async () => {
     const { provider, emitQuote } = createProvider();
     const coordinator = new MarketDataCoordinator(provider);
@@ -97,29 +170,40 @@ describe("MarketDataCoordinator key subscriptions", () => {
     expect(coordinator.getVersion()).toBe(1);
   });
 
-  test("ignores repeated stream quotes that only refresh timestamp noise", async () => {
+  test("applies repeated stream quotes that refresh quote freshness", async () => {
+    const realDateNow = Date.now;
     const { provider, emitQuote } = createProvider();
     const coordinator = new MarketDataCoordinator(provider);
     const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
     let calls = 0;
 
-    coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { calls += 1; });
-    coordinator.subscribeQuotes([{ instrument: aapl }]);
-
     const firstTimestamp = 1_700_000_000_000;
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
-    await flushCoordinator();
-
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
-    await flushCoordinator();
-
-    expect(calls).toBe(1);
-    expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp);
-
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 20_000 }));
-    await flushCoordinator();
-
-    expect(calls).toBe(2);
-    expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
+    try {
+      coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { calls += 1; });
+      coordinator.subscribeQuotes([{ instrument: aapl }]);
+
+      Date.now = () => firstTimestamp;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
+      await flushCoordinator();
+
+      Date.now = () => firstTimestamp + 10_000;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
+      await flushCoordinator();
+
+      expect(calls).toBe(2);
+      expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp + 10_000);
+      expect(coordinator.getQuoteEntry(aapl).data?.receivedAt).toBe(firstTimestamp + 10_000);
+
+      Date.now = () => firstTimestamp + 20_000;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 10_000 }));
+      await flushCoordinator();
+
+      expect(calls).toBe(3);
+      expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
+      expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp + 10_000);
+      expect(coordinator.getQuoteEntry(aapl).data?.receivedAt).toBe(firstTimestamp + 20_000);
+    } finally {
+      Date.now = realDateNow;
+    }
   });
 });