gloomberb 0.10.4 → 0.11.0

package/src/app/global-shortcuts.ts

@@ -48,6 +48,26 @@ export function useAppGlobalShortcuts({
       return;
     }
 
+    // Terminals send Ctrl; the browser and the desktop webview send Cmd on
+    // macOS, which the OpenTUI host also reports as `super` under the kitty
+    // protocol. Alt stays out so Alt-digit keeps its terminal meaning. While a
+    // dialog, the command bar or an editable field owns the keyboard the digit
+    // must not move layouts, but it still has to be swallowed there or the
+    // webview hands Cmd-digit to the browser's own tab switcher.
+    if (!isDetachedWindow
+      && /^[1-9]$/.test(event.name ?? "")
+      && (event.ctrl || event.meta || event.super)) {
+      const layouts = state.config.layouts ?? [];
+      const idx = parseInt(event.name!, 10) - 1;
+      const uiOwnsKeyboard = dialogOpen || state.commandBarOpen || event.targetEditable === true;
+      if (!uiOwnsKeyboard && idx < layouts.length && idx !== state.config.activeLayoutIndex) {
+        dispatch({ type: "SWITCH_LAYOUT", index: idx });
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      return;
+    }
+
     if (dialogOpen) return;
 
     if (!isDetachedWindow && (
@@ -70,16 +90,8 @@ export function useAppGlobalShortcuts({
       });
       return;
     }
-    if (!isDetachedWindow && /^[1-9]$/.test(event.name ?? "") && event.ctrl && (state.config.layouts ?? []).length > 1) {
-      const idx = parseInt(event.name!, 10) - 1;
-      const layouts = state.config.layouts ?? [];
-      if (idx < layouts.length && idx !== state.config.activeLayoutIndex) {
-        dispatch({ type: "SWITCH_LAYOUT", index: idx });
-      }
-      event.preventDefault();
-      event.stopPropagation();
-      return;
-    }
+
+    const hasShortcutModifier = event.ctrl || event.meta || event.super || event.alt;
 
     if (state.commandBarOpen) return;
 
@@ -103,7 +115,17 @@ export function useAppGlobalShortcuts({
 
     if (state.inputCaptured) return;
 
-    const hasShortcutModifier = event.ctrl || event.meta || event.super || event.alt;
+    const isQuestionMark = event.name === "?"
+      || event.key === "?"
+      || event.sequence === "?"
+      || (event.name === "/" && event.shift);
+    if (!isDetachedWindow && !hasShortcutModifier && isQuestionMark) {
+      event.preventDefault();
+      event.stopPropagation();
+      pluginRegistry.showPane("help");
+      return;
+    }
+
     if (!hasShortcutModifier && !isDetachedWindow && event.name === "q") {
       rendererHost.requestExit();
     } else if (!hasShortcutModifier && event.name === "r") {

package/src/app/runtime/broker-import.ts

@@ -12,11 +12,26 @@ export interface AppBrokerImportRuntime {
   importBrokerPositions: (
     instanceId: string,
     tickerMap?: Map<string, TickerRecord>,
-    options?: { refreshImportedTickers?: boolean; config?: AppConfig },
+    options?: BrokerImportOptions,
   ) => Promise<SyncBrokerInstanceResult>;
   autoImportBrokerPositions: (tickerMap: Map<string, TickerRecord>) => Promise<void>;
 }
 
+export interface BrokerImportOptions {
+  refreshImportedTickers?: boolean;
+  config?: AppConfig;
+  persistResolvedBrokerConfig?: boolean;
+  signal?: AbortSignal;
+  onCommitStart?: () => void;
+  onCommitEnd?: () => void;
+}
+
+function throwIfBrokerImportCancelled(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw new Error("Broker import was cancelled.");
+  }
+}
+
 export function useBrokerImportRuntime({
   dispatch,
   pluginRegistry,
@@ -34,24 +49,30 @@ export function useBrokerImportRuntime({
     instanceId: string,
     result: SyncBrokerInstanceResult,
     baseConfig: AppConfig,
-    options?: { refreshImportedTickers?: boolean },
+    options?: Pick<BrokerImportOptions, "refreshImportedTickers" | "signal">,
   ) => {
+    throwIfBrokerImportCancelled(options?.signal);
     dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
 
     if (result.config !== baseConfig) {
+      throwIfBrokerImportCancelled(options?.signal);
       dispatch({ type: "SET_CONFIG", config: result.config });
       await saveConfigImmediately(result.config);
+      throwIfBrokerImportCancelled(options?.signal);
       pluginRegistry.events.emit("config:changed", { config: result.config });
     }
 
     for (const ticker of result.addedTickers) {
+      throwIfBrokerImportCancelled(options?.signal);
       pluginRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
     }
     for (const ticker of [...result.addedTickers, ...result.updatedTickers]) {
+      throwIfBrokerImportCancelled(options?.signal);
       dispatch({ type: "UPDATE_TICKER", ticker: { ...ticker } });
     }
 
     for (const position of result.positions) {
+      throwIfBrokerImportCancelled(options?.signal);
       // Skip Yahoo Finance for broker option symbols; position marks are already available.
       // Position data (markPrice, marketValue, unrealizedPnl) is used directly.
       if (options?.refreshImportedTickers !== false && position.assetCategory !== "OPT") {
@@ -63,7 +84,7 @@ export function useBrokerImportRuntime({
   const importBrokerPositions = useCallback(async (
     instanceId: string,
     tickerMap?: Map<string, TickerRecord>,
-    options?: { refreshImportedTickers?: boolean; config?: AppConfig },
+    options?: BrokerImportOptions,
   ) => {
     const baseConfig = options?.config ?? stateRef.current.config;
     const result = await syncBrokerInstance({
@@ -73,11 +94,24 @@ export function useBrokerImportRuntime({
       tickerRepository,
       existingTickers: tickerMap ?? new Map(stateRef.current.tickers),
       resources: pluginRegistry.persistence.resources,
+      persistResolvedBrokerConfig: options?.persistResolvedBrokerConfig,
+      signal: options?.signal,
+      deferPersistence: true,
     });
 
-    await applyBrokerImportResult(instanceId, result, baseConfig, options);
+    let commitStarted = false;
+    try {
+      throwIfBrokerImportCancelled(options?.signal);
+      options?.onCommitStart?.();
+      commitStarted = true;
+      await result.commit();
+      throwIfBrokerImportCancelled(options?.signal);
+      await applyBrokerImportResult(instanceId, result, baseConfig, options);
 
-    return result;
+      return result;
+    } finally {
+      if (commitStarted) options?.onCommitEnd?.();
+    }
   }, [applyBrokerImportResult, pluginRegistry.brokers, pluginRegistry.persistence.resources, stateRef, tickerRepository]);
 
   const autoImportBrokerPositions = useCallback(async (tickerMap: Map<string, TickerRecord>) => {

package/src/app/runtime/startup.ts

@@ -73,7 +73,13 @@ export function useAppStartupRuntime({
             state.config.brokerInstances,
             pluginRegistry.brokers,
           );
-        } catch {}
+        } catch (error) {
+          console.error("[startup] Failed to load persisted broker accounts:", error);
+          pluginRegistry.notify({
+            body: "Failed to load saved broker account data. Check local storage permissions.",
+            type: "error",
+          });
+        }
         await measurePerfAsync("startup.app.initialize-state", () => initializeAppState({
           config: state.config,
           tickerRepository,

package/src/app/runtime/update.ts

@@ -1,5 +1,7 @@
 import { useCallback, useEffect, type Dispatch } from "react";
-import type { AppAction } from "../../state/app/context";
+import type { PluginRegistry } from "../../plugins/registry";
+import { saveConfigImmediately } from "../../state/config-save-scheduler";
+import type { AppAction, AppState } from "../../state/app/context";
 import {
   canSelfUpdate,
   checkForUpdateDetailed,
@@ -8,15 +10,21 @@ import {
 } from "../../updater";
 import { VERSION } from "../../version";
 
+const UPDATE_CHECK_INTERVAL_MS = 60 * 60_000; // hourly
+
 export function useAppUpdateRuntime({
   dispatch,
   isDetachedWindow,
+  pluginRegistry,
+  stateRef,
   updateAvailable,
   updateCheckInProgress,
   updateProgress,
 }: {
   dispatch: Dispatch<AppAction>;
   isDetachedWindow: boolean;
+  pluginRegistry: PluginRegistry;
+  stateRef: { current: AppState };
   updateAvailable: ReleaseInfo | null;
   updateCheckInProgress: boolean;
   updateProgress: unknown;
@@ -70,8 +78,25 @@ export function useAppUpdateRuntime({
   useEffect(() => {
     if (isDetachedWindow) return;
     void runUpdateCheck(false);
+    const interval = setInterval(() => { void runUpdateCheck(false); }, UPDATE_CHECK_INTERVAL_MS);
+    return () => { clearInterval(interval); };
   }, [isDetachedWindow, runUpdateCheck]);
 
+  // First launch on a new version: show that release's notes, then remember the version.
+  useEffect(() => {
+    if (isDetachedWindow) return;
+    const config = stateRef.current.config;
+    if (config.lastLaunchedVersion === VERSION) return;
+    const isUpgrade = !!config.lastLaunchedVersion;
+    const nextConfig = { ...config, lastLaunchedVersion: VERSION };
+    dispatch({ type: "SET_CONFIG", config: nextConfig });
+    void saveConfigImmediately(nextConfig).catch(() => {});
+    if (!isUpgrade) return;
+    void pluginRegistry.createPaneFromTemplateAsyncFn("changelog-pane", {
+      values: { version: VERSION },
+    }).catch(() => {});
+  }, [dispatch, isDetachedWindow, pluginRegistry, stateRef]);
+
   useEffect(() => {
     if (isDetachedWindow) return;
     if (!updateAvailable || updateProgress || updateCheckInProgress) return;

package/src/app.tsx

@@ -21,7 +21,7 @@ import { useDialog } from "./ui/dialog";
 import { PluginRegistry } from "./plugins/registry";
 import type { LoadedExternalPlugin } from "./plugins/loader";
 import type { AppServicesFactory, AppTickerRepositoryPort } from "./core/app-service-ports";
-import { ThemeProvider, useThemeColors } from "./theme/theme-context";
+import { useThemeColors } from "./theme/theme-context";
 import type { AppConfig } from "./types/config";
 import type { DesktopDeepLinkBridge } from "./types/desktop-deeplink";
 import type { CliLaunchRequest } from "./types/plugin";
@@ -68,6 +68,8 @@ interface AppInnerProps {
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
   desktopDeepLinkBridge?: DesktopDeepLinkBridge;
   remoteControlAdapter?: RemoteControlAdapter;
+  onboardingActive?: boolean;
+  onOnboardingComplete?: (config: AppConfig) => void | Promise<void>;
 }
 
 function ThemedAppRoot({ children }: { children: ReactNode }) {
@@ -98,6 +100,8 @@ function AppInner({
   desktopApplicationMenuBridge,
   desktopDeepLinkBridge,
   remoteControlAdapter,
+  onboardingActive = false,
+  onOnboardingComplete,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
@@ -219,6 +223,8 @@ function AppInner({
   const { runUpdateCheck, startUpdate } = useAppUpdateRuntime({
     dispatch,
     isDetachedWindow,
+    pluginRegistry,
+    stateRef,
     updateAvailable: state.updateAvailable,
     updateCheckInProgress: state.updateCheckInProgress,
     updateProgress: state.updateProgress,
@@ -277,7 +283,11 @@ function AppInner({
     dispatch,
     tickerRepository,
     pluginRegistry,
-    initialized: state.initialized && desktopWindowBridge?.kind !== "detached",
+    // Keep a first-run workspace stable while the local guide is active. Once
+    // onboarding finishes, the normal pull-before-push sync starts immediately.
+    initialized: state.initialized
+      && desktopWindowBridge?.kind !== "detached"
+      && !onboardingActive,
   });
 
   useAppPaneRuntime({
@@ -359,7 +369,14 @@ function AppInner({
         desktopWindowBridge={desktopWindowBridge}
       >
         <ThemedAppRoot>
-          <Header />
+          <Header
+            onOpenHelp={() => pluginRegistry.showPane("help")}
+            onOpenChangelog={(version) => {
+              void pluginRegistry.createPaneFromTemplateAsyncFn("changelog-pane", {
+                values: { version },
+              }).catch(() => {});
+            }}
+          />
           <TransientLayoutProvider>
             <Shell
               pluginRegistry={pluginRegistry}
@@ -369,6 +386,13 @@ function AppInner({
             />
             <StatusBar />
           </TransientLayoutProvider>
+          {onboardingActive && onOnboardingComplete ? (
+            <OnboardingWizard
+              pluginRegistry={pluginRegistry}
+              importBrokerPositions={importBrokerPositions}
+              onComplete={onOnboardingComplete}
+            />
+          ) : null}
           {state.commandBarOpen && (
             <CommandBar
               dataProvider={dataProvider}
@@ -434,7 +458,10 @@ export function App({
   const [config, setConfig] = useState(() => {
     return initialCliLaunch.config;
   });
-  const [showOnboarding, setShowOnboarding] = useState(!effectiveInitialConfig.onboardingComplete);
+  const [showOnboarding, setShowOnboarding] = useState(() => (
+    desktopWindowBridge?.kind !== "detached"
+    && (!effectiveInitialConfig.onboardingComplete || !!effectiveInitialConfig.onboardingProgress)
+  ));
 
   useEffect(() => bindAppActivity(renderer), [renderer]);
 
@@ -466,21 +493,6 @@ export function App({
     });
   }, [cliLaunchRequest, config, desktopSnapshot, desktopWindowBridge?.kind, services.persistence.sessions]);
 
-  if (showOnboarding) {
-    return (
-      <ThemeProvider themeId={config.theme}>
-        <OnboardingWizard
-          config={config}
-          pluginRegistry={services.pluginRegistry}
-          onComplete={(updatedConfig) => {
-            setConfig(updatedConfig);
-            setShowOnboarding(false);
-          }}
-        />
-      </ThemeProvider>
-    );
-  }
-
   return (
     <RemoteUiRegistryProvider>
       <AppProvider
@@ -502,6 +514,11 @@ export function App({
           desktopApplicationMenuBridge={desktopApplicationMenuBridge}
           desktopDeepLinkBridge={desktopDeepLinkBridge}
           remoteControlAdapter={remoteControlAdapter}
+          onboardingActive={showOnboarding}
+          onOnboardingComplete={(updatedConfig) => {
+            setConfig(updatedConfig);
+            setShowOnboarding(false);
+          }}
         />
       </AppProvider>
     </RemoteUiRegistryProvider>

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

@@ -107,19 +107,17 @@ function updateExistingTicker(
   };
 }
 
-export async function upsertBrokerPositionTicker({
-  tickerRepository,
+export function upsertBrokerPositionTicker({
   tickers,
   instance,
   portfolioId,
   position,
 }: {
-  tickerRepository: AppTickerRepositoryPort;
   tickers: Map<string, TickerRecord>;
   instance: BrokerInstanceConfig;
   portfolioId: string;
   position: BrokerPosition;
-}): Promise<{ ticker: TickerRecord; created: boolean }> {
+}): { ticker: TickerRecord; created: boolean } {
   const brokerContract = position.brokerContract
     ? {
       ...position.brokerContract,
@@ -132,14 +130,11 @@ export async function upsertBrokerPositionTicker({
 
   if (!existingTicker) {
     return {
-      ticker: await tickerRepository.createTicker(
-        createTickerMetadata(position, portfolioId, positionEntry, brokerContract),
-      ),
+      ticker: { metadata: createTickerMetadata(position, portfolioId, positionEntry, brokerContract) },
       created: true,
     };
   }
 
   const ticker = updateExistingTicker(existingTicker, instance, portfolioId, position, positionEntry, brokerContract);
-  await tickerRepository.saveTicker(ticker);
   return { ticker, created: false };
 }

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

@@ -166,6 +166,30 @@ describe("syncBrokerInstance", () => {
     ]);
   });
 
+  test("fails cleanly when the broker account cache cannot be persisted", async () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-persistence-error"),
+      portfolios: [],
+      brokerInstances: [createBrokerInstance()],
+    };
+    const tickerRepository = createTickerRepository();
+
+    await expect(syncBrokerInstance({
+      config,
+      instanceId: "demo-broker",
+      brokers: new Map([["demo", createDemoBroker()]]),
+      tickerRepository: tickerRepository as any,
+      resources: {
+        get: () => null,
+        list: () => [],
+        set: () => { throw new Error("disk full"); },
+        delete: () => {},
+      } as any,
+    })).rejects.toThrow("disk full");
+
+    expect(await tickerRepository.loadTicker("AAPL")).toBeNull();
+  });
+
   test("imports account and position data from one broker portfolio snapshot", async () => {
     const instance = createBrokerInstance();
     const config = {
@@ -228,6 +252,41 @@ describe("syncBrokerInstance", () => {
     }
   });
 
+  test("stages broker cache and ticker writes until a cancellation-safe commit", async () => {
+    const instance = createBrokerInstance();
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-cancel"),
+      portfolios: [],
+      brokerInstances: [instance],
+    };
+    const tickerRepository = createTickerRepository();
+    const persistence = new AppPersistence(":memory:");
+    const abortController = new AbortController();
+
+    try {
+      const result = await syncBrokerInstance({
+        config,
+        instanceId: instance.id,
+        brokers: new Map([["demo", createDemoBroker()]]),
+        tickerRepository: tickerRepository as any,
+        resources: persistence.resources,
+        signal: abortController.signal,
+        deferPersistence: true,
+      });
+
+      expect(await tickerRepository.loadAllTickers()).toEqual([]);
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, createDemoBroker())).toBeNull();
+
+      abortController.abort();
+      await expect(result.commit()).rejects.toThrow("Broker import was cancelled.");
+
+      expect(await tickerRepository.loadAllTickers()).toEqual([]);
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, createDemoBroker())).toBeNull();
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("preserves the last account snapshot when a broker portfolio snapshot fails", async () => {
     const instance = createBrokerInstance();
     const config = {

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

@@ -26,6 +26,8 @@ export interface SyncBrokerInstanceArgs {
   existingTickers?: Map<string, TickerRecord>;
   resources?: AppResourceStorePort;
   persistResolvedBrokerConfig?: boolean;
+  signal?: AbortSignal;
+  deferPersistence?: boolean;
 }
 
 export interface SyncBrokerInstanceResult {
@@ -36,6 +38,7 @@ export interface SyncBrokerInstanceResult {
   portfolioIds: string[];
   addedTickers: TickerRecord[];
   updatedTickers: TickerRecord[];
+  commit(): Promise<void>;
 }
 
 export interface SyncBrokerInstancesArgs {
@@ -68,6 +71,12 @@ function markBrokerInstanceSynced(
   };
 }
 
+function throwIfBrokerImportCancelled(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw new Error("Broker import was cancelled.");
+  }
+}
+
 async function maybePersistResolvedBrokerConfig(
   config: AppConfig,
   instance: BrokerInstanceConfig,
@@ -108,6 +117,8 @@ export async function syncBrokerInstance({
   existingTickers,
   resources,
   persistResolvedBrokerConfig = false,
+  signal,
+  deferPersistence = false,
 }: SyncBrokerInstanceArgs): Promise<SyncBrokerInstanceResult> {
   const instance = getBrokerInstance(config.brokerInstances, instanceId);
   if (!instance) {
@@ -123,37 +134,32 @@ export async function syncBrokerInstance({
   }
 
   const valid = await broker.validate(instance).catch(() => false);
+  throwIfBrokerImportCancelled(signal);
   if (!valid) {
     throw new Error(`${broker.name} setup is incomplete.`);
   }
 
   const tickers = await loadTickerMap(tickerRepository, existingTickers);
+  throwIfBrokerImportCancelled(signal);
 
   let brokerAccounts: BrokerAccount[] = [];
   let positions: BrokerPosition[];
   if (broker.importPortfolioSnapshot) {
     const snapshot = await broker.importPortfolioSnapshot(instance);
+    throwIfBrokerImportCancelled(signal);
     brokerAccounts = snapshot.accounts;
     positions = snapshot.positions;
-    if (resources) {
-      try {
-        persistBrokerAccounts(resources, instance, broker, brokerAccounts);
-      } catch {}
-    }
   } else {
     if (broker.listAccounts) {
       try {
         brokerAccounts = await broker.listAccounts(instance);
-        if (resources) {
-          try {
-            persistBrokerAccounts(resources, instance, broker, brokerAccounts);
-          } catch {}
-        }
+        throwIfBrokerImportCancelled(signal);
       } catch (error) {
         throw error;
       }
     }
     positions = await broker.importPositions(instance);
+    throwIfBrokerImportCancelled(signal);
   }
 
   const accountMetadata = new Map(
@@ -231,15 +237,16 @@ export async function syncBrokerInstance({
   }
 
   nextConfig = await maybePersistResolvedBrokerConfig(nextConfig, instance, broker, persistResolvedBrokerConfig);
+  throwIfBrokerImportCancelled(signal);
   nextConfig = markBrokerInstanceSynced(nextConfig, instance.id, syncedAt);
 
   const addedTickers = new Map<string, TickerRecord>();
   const updatedTickers = new Map<string, TickerRecord>();
 
   for (const position of positions) {
+    throwIfBrokerImportCancelled(signal);
     const portfolioId = findReusableBrokerPortfolioId(nextConfig, instance, position.accountId);
-    const { ticker, created } = await upsertBrokerPositionTicker({
-      tickerRepository,
+    const { ticker, created } = upsertBrokerPositionTicker({
       tickers,
       instance,
       portfolioId,
@@ -263,12 +270,28 @@ export async function syncBrokerInstance({
   }
 
   for (const ticker of cleanedTickers.values()) {
-    await tickerRepository.saveTicker(ticker);
     if (!addedTickers.has(ticker.metadata.ticker) && !updatedTickers.has(ticker.metadata.ticker)) {
       updatedTickers.set(ticker.metadata.ticker, ticker);
     }
   }
 
+  let committed = false;
+  const commit = async () => {
+    if (committed) return;
+    throwIfBrokerImportCancelled(signal);
+    if (resources) {
+      persistBrokerAccounts(resources, instance, broker, brokerAccounts);
+    }
+    await Promise.all([...addedTickers.values(), ...updatedTickers.values()].map((ticker) => (
+      tickerRepository.saveTicker(ticker)
+    )));
+    committed = true;
+  };
+
+  if (!deferPersistence) {
+    await commit();
+  }
+
   return {
     config: nextConfig,
     tickers,
@@ -277,6 +300,7 @@ export async function syncBrokerInstance({
     portfolioIds,
     addedTickers: [...addedTickers.values()],
     updatedTickers: [...updatedTickers.values()],
+    commit,
   };
 }