gloomberb 0.19.0 → 0.19.2

package/src/plugins/catalog-browser.ts

@@ -45,6 +45,7 @@ import { commentLettersPlugin } from "./builtin/comment-letters";
 import { openFdaPlugin } from "./builtin/openfda";
 import { browserGloomberbCloudPlugin } from "./builtin/cloud/browser";
 import { changelogModule } from "./builtin/changelog";
+import { roadmapModule } from "./builtin/roadmap";
 import { chartComposerModule } from "./builtin/chart-composer";
 import { connectionsModule } from "./builtin/connections";
 import { relativeRotationModule } from "./builtin/relative-rotation";
@@ -126,7 +127,7 @@ import { FIXED_INCOME_HOSTS } from "./builtin/fixed-income/model";
 
 const browserApplicationPlugin = composeBuiltinPlugin({
   ...applicationPluginMeta,
-  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule, docsModule],
+  modules: [layoutManagerModule, helpModule, changelogModule, connectionsModule, docsModule, roadmapModule],
 });
 
 const runtimeOnly = (module: PluginModule): PluginModule => {

package/src/plugins/host-link.ts

@@ -32,7 +32,7 @@ const LINKED_PACKAGES = ["gloomberb", "react"] as const;
 
 /**
  * The names the host is published under: `gloomberb`, which plugins import
- * as, and `@gloom-sh/terminal` once releases are also published under it.
+ * as, and `@gloom-sh/terminal`.
  */
 const HOST_PACKAGE_NAMES: ReadonlySet<string> = new Set(["gloomberb", "@gloom-sh/terminal"]);
 

package/src/plugins/installer.ts

@@ -141,7 +141,13 @@ function run(
 /** Whether a `git` command is on the PATH; plugins from GitHub need one to install or update. */
 export function gitInstalled(): boolean {
   if (typeof Bun !== "undefined") return Bun.which("git") !== null;
-  return gitSucceeds(["--version"], process.cwd());
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    // Intentional ignore: a git that does not start is the answer this asks for.
+    return false;
+  }
 }
 
 /** What a plugin install says when there is no git to run: what to install, then to try again. */
@@ -171,14 +177,9 @@ async function git(args: string[], cwd: string, quiet: boolean, failure: string)
   return result.stdout.trim();
 }
 
-function isOnBranch(dir: string): boolean {
-  try {
-    execFileSync("git", ["symbolic-ref", "-q", "HEAD"], { cwd: dir, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Detached HEAD is expected after a pinned install.
-    return false;
-  }
+/** False on a detached HEAD, which a pinned install leaves. */
+function isOnBranch(dir: string): Promise<boolean> {
+  return gitSucceedsAsync(["symbolic-ref", "-q", "HEAD"], dir);
 }
 
 function pinMatches(commit: string | null, expected: string | undefined): boolean {
@@ -208,27 +209,27 @@ async function checkoutCommit(targetDir: string, commit: string, quiet: boolean)
   await git(["checkout", "--detach", "--force", commit], targetDir, quiet, `Could not check out ${commit.slice(0, 7)}`);
 }
 
-function gitSucceeds(args: string[], cwd: string): boolean {
-  try {
-    execFileSync("git", args, { cwd, stdio: "ignore" });
-    return true;
-  } catch {
-    // Intentional ignore: Non-ancestor and shallow histories use package versions and commit dates instead.
-    return false;
-  }
+
+/*
+ * The update path runs in the app (the terminal, the desktop's Bun process),
+ * where a sync git call holds the thread for the whole process start: tens of
+ * milliseconds each on Windows, several per plugin. These never block it.
+ */
+async function gitSucceedsAsync(args: string[], cwd: string): Promise<boolean> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0;
 }
 
-function gitOutput(args: string[], cwd: string): string | null {
-  try {
-    return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString("utf-8").trim();
-  } catch {
-    // Intentional ignore: Shallow or manifest-free checkouts may lack historical metadata.
-    return null;
-  }
+/** Null when git fails: shallow or manifest-free checkouts may lack historical metadata. */
+async function gitOutputAsync(args: string[], cwd: string): Promise<string | null> {
+  const result = await run("git", args, cwd, { stdout: "pipe", stderr: "pipe" })
+    .catch(logFailure("plugin-installer", "Could not run git", null));
+  return result?.code === 0 ? result.stdout.trim() : null;
 }
 
-function versionAt(dir: string, commit: string): string | null {
-  const text = gitOutput(["show", `${commit}:package.json`], dir);
+async function versionAt(dir: string, commit: string): Promise<string | null> {
+  const text = await gitOutputAsync(["show", `${commit}:package.json`], dir);
   if (!text) return null;
   try {
     const version = JSON.parse(text).version;
@@ -247,15 +248,15 @@ function versionAt(dir: string, commit: string): string | null {
  * it; otherwise the versions the two commits declare decide, then, when
  * those match, their commit dates.
  */
-export function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): string | null {
-  if (installed === candidate || gitSucceeds(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
-  const installedVersion = versionAt(dir, installed);
-  const byVersion = compareSemver(versionAt(dir, candidate), installedVersion);
+export async function describeOlderCommit(dir: string, installed: string, candidate: string, label = candidate.slice(0, 7)): Promise<string | null> {
+  if (installed === candidate || await gitSucceedsAsync(["merge-base", "--is-ancestor", installed, candidate], dir)) return null;
+  const installedVersion = await versionAt(dir, installed);
+  const byVersion = compareSemver(await versionAt(dir, candidate), installedVersion);
   const older = () => `the registry's ${label} is older than the installed ${byVersion ? installedVersion : installed.slice(0, 7)}`;
-  if (gitSucceeds(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
+  if (await gitSucceedsAsync(["merge-base", "--is-ancestor", candidate, installed], dir)) return older();
   if (byVersion !== null && byVersion !== 0) return byVersion < 0 ? older() : null;
-  const candidateTime = Number(gitOutput(["show", "-s", "--format=%ct", candidate], dir));
-  const installedTime = Number(gitOutput(["show", "-s", "--format=%ct", installed], dir));
+  const candidateTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", candidate], dir));
+  const installedTime = Number(await gitOutputAsync(["show", "-s", "--format=%ct", installed], dir));
   return candidateTime > 0 && installedTime > 0 && candidateTime < installedTime ? older() : null;
 }
 
@@ -403,19 +404,29 @@ export interface PluginUpdateResult extends PluginDirectoryInfo {
   kept?: string;
 }
 
+function githubRepoFromUrl(url: string): string | null {
+  const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url.trim());
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+
 /** `owner/repo` from the checkout's origin remote, or null for anything that is not a GitHub clone. */
 export function readPluginRemote(pluginDir: string): string | null {
   try {
-    const url = execFileSync("git", ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
-      .toString("utf-8").trim();
-    const match = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/i.exec(url);
-    return match ? `${match[1]}/${match[2]}` : null;
+    return githubRepoFromUrl(execFileSync("git", ["config", "--get", "remote.origin.url"], { cwd: pluginDir, stdio: ["ignore", "pipe", "ignore"] })
+      .toString("utf-8"));
   } catch {
     // Intentional ignore: Hand-copied plugins and local repositories may have no origin remote.
     return null;
   }
 }
 
+/** `readPluginRemote` without holding the thread, for the app's own update check. */
+export async function readPluginRemoteAsync(pluginDir: string): Promise<string | null> {
+  // No origin remote (a hand-copied plugin, a local repository) is a failed git, and no repo.
+  const url = await gitOutputAsync(["config", "--get", "remote.origin.url"], pluginDir);
+  return url ? githubRepoFromUrl(url) : null;
+}
+
 /** The sha from `git ls-remote origin HEAD`; null when the answer is not one. */
 export function parseRemoteHead(output: string): string | null {
   const sha = output.trim().split(/\s+/)[0] ?? "";
@@ -500,7 +511,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     const commit = await fetchPin(targetDir, pin, quiet);
     // Updates only move forward: a checkout installed from the default
     // branch can be ahead of the tag the registry reviewed.
-    const kept = before ? describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
+    const kept = before ? await describeOlderCommit(targetDir, before, commit, pin.ref ?? commit.slice(0, 7)) : null;
     if (kept) {
       if (!quiet) console.log(cliStyles.muted(`Kept ${name}: ${kept}.`));
       return { ...describe(targetDir, name, null), before, changed: false, kept };
@@ -510,7 +521,7 @@ export async function updatePlugin(name: string, options: PluginInstallOptions =
     // Not in the registry, so there is nothing reviewed to land on: follow the
     // remote's default branch, whether the checkout is on a branch or detached
     // from an earlier pin.
-    if (isOnBranch(targetDir)) {
+    if (await isOnBranch(targetDir)) {
       await git(["pull", "--ff-only"], targetDir, quiet, `Failed to update ${name}`);
     } else {
       await git(["fetch", "--depth", "1", "origin", "HEAD"], targetDir, quiet, `Failed to fetch ${name}`);

package/src/portfolio/column-values.ts

@@ -185,15 +185,19 @@ function positionSideLabel(ticker: TickerRecord, activeTab: string | undefined):
   return "MIX";
 }
 
-/** The currency a row is listed in: its position's, else its quote's; an index's level is in points and has none. */
+/**
+ * The currency a row is listed in: its position's, else its quote's or the one saved with it. An index's level is in
+ * points and has none, and a row whose currency no source gave (a coin pair before its quote) shows none, never the
+ * dollars it is valued in meanwhile: a row not held has no position currency, only that fallback.
+ */
 function listedCurrency(
-  positionCurrency: string | undefined,
-  quoteCurrency: string,
+  metrics: Pick<PortfolioPositionMetrics, "positionCount" | "positionCurrency">,
   ticker: TickerRecord,
   quote: TickerFinancials["quote"],
 ): string {
-  if (!positionCurrency && isIndexLevel(quote?.instrumentType || ticker.metadata.assetCategory)) return "";
-  return (positionCurrency || quoteCurrency || ticker.metadata.currency || "").toUpperCase();
+  const held = metrics.positionCount > 0 ? metrics.positionCurrency : "";
+  if (!held && isIndexLevel(quote?.instrumentType || ticker.metadata.assetCategory)) return "";
+  return (held || quote?.currency || ticker.metadata.currency || "").toUpperCase();
 }
 
 function compactText(value: string | null | undefined): string {
@@ -458,7 +462,7 @@ export function getColumnValue(
         ),
       };
     case "currency":
-      return { text: compactText(currencyCodeLabel(listedCurrency(positionCurrency, quoteCurrency, ticker, quote))) };
+      return { text: compactText(currencyCodeLabel(listedCurrency(positionMetrics, ticker, quote))) };
     case "sector":
       return { text: compactText(ticker.metadata.sector || financials?.profile?.sector) };
     case "industry":
@@ -713,7 +717,7 @@ export function getSortValue(
         ?? ticker.metadata.exchange
         ?? null;
     case "currency":
-      return listedCurrency(positionCurrency, quoteCurrency, ticker, quote) || null;
+      return listedCurrency(positionMetrics, ticker, quote) || null;
     case "sector":
       return ticker.metadata.sector || financials?.profile?.sector || null;
     case "industry":

package/src/renderers/dom/desktop/icons.tsx

@@ -165,6 +165,13 @@ const ICONS: Record<IconName, ReactNode> = {
       <path d="M7.3 2.9l1.8 1.8" stroke="currentColor" strokeWidth="1.1" />
     </>
   ),
+  // An envelope: a message written to you.
+  mail: (
+    <>
+      <rect x="1.5" y="2.75" width="9" height="6.5" rx="1.1" stroke="currentColor" strokeWidth="1.1" />
+      <path d="M2 3.4 6 6.5l4-3.1" stroke="currentColor" strokeWidth="1.1" strokeLinecap="round" strokeLinejoin="round" />
+    </>
+  ),
   restore: (
     <>
       <rect x="2" y="4" width="6" height="6" rx="0.8" stroke="currentColor" strokeWidth="1.1" />
@@ -173,7 +180,7 @@ const ICONS: Record<IconName, ReactNode> = {
   ),
 };
 
-export function WebIcon({ name, size = 12, color }: IconProps) {
+export function WebIcon({ name, size = 12, color, fullHeight }: IconProps) {
   return (
     <svg
       viewBox="0 0 12 12"
@@ -182,7 +189,8 @@ export function WebIcon({ name, size = 12, color }: IconProps) {
       fill="none"
       aria-hidden="true"
       data-gloom-icon={name}
-      style={{ flex: "none", display: "block", color }}
+      // The viewBox keeps its size and sits in the middle of the taller box (preserveAspectRatio's default).
+      style={{ flex: "none", display: "block", color, ...(fullHeight ? { height: "100%" } : {}) }}
     >
       {ICONS[name]}
     </svg>

package/src/renderers/electrobun/bun/desktop/backend.ts

@@ -352,16 +352,14 @@ export class DesktopBackend {
       execPath: process.execPath,
       argv: process.argv,
     });
-    try {
-      scheduleDesktopRelaunch();
-    } catch (error) {
-      this.restartInProgress = false;
-      console.error("[desktop-recovery] failed to schedule restart", summarizeError(error));
-      throw error;
-    }
-    this.detachedWindows.closeAll();
-    this.teardownServices();
-    Utils.quit();
+    scheduleDesktopRelaunch().then(
+      // As a quit does: an app whose windows are gone ends at once on Windows.
+      () => this.quit(),
+      (error: unknown) => {
+        this.restartInProgress = false;
+        console.error("[desktop-recovery] failed to schedule restart", summarizeError(error));
+      },
+    );
   }
 
   private syncConfigAccessors(): void {
@@ -566,6 +564,7 @@ export class DesktopBackend {
       case "host.exit":
       case "host.windowControl":
       case "host.windowFullscreen":
+      case "host.startWindowDrag":
       case "host.openExternal":
       case "host.copyText":
       case "host.focusWindow":

package/src/renderers/electrobun/bun/desktop/detached-windows.ts

@@ -18,6 +18,8 @@ import type { DesktopBackend } from "./backend";
 
 const INITIAL_DOCK_SUPPRESSION_MS = 800;
 const WINDOW_CONTROL_DOCK_SUPPRESSION_MS = 5_000;
+/** How long after the main window has its data the popped-out windows of the last session open. */
+const LAUNCH_WINDOWS_DELAY_MS = 300;
 
 export class DesktopDetachedWindowManager {
   private readonly windows = new Map<string, BrowserWindow>();
@@ -27,9 +29,29 @@ export class DesktopDetachedWindowManager {
   private readonly pendingMoveFlush = new Set<string>();
   private readonly suppressDockUntil = new Map<string, number>();
   private readonly windowControlDockSuppressed = new Set<string>();
+  /**
+   * At launch, popped-out windows wait for the main window. Opening a window
+   * holds this process until the system has made it (on Windows, its
+   * browser too), and the main window's `init` used to wait behind each one.
+   */
+  private windowsAllowed = false;
+  private windowsTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor(private readonly backend: DesktopBackend) {}
 
+  /**
+   * The main window has its data: the popped-out windows open shortly
+   * after, once it has had a moment to draw and ask for what it shows.
+   */
+  openAfterMainWindow(): void {
+    if (this.windowsAllowed || this.windowsTimer) return;
+    this.windowsTimer = setTimeout(() => {
+      this.windowsTimer = null;
+      this.windowsAllowed = true;
+      this.reconcile();
+    }, LAUNCH_WINDOWS_DELAY_MS);
+  }
+
   focusDetachedPane(instanceId: string): boolean {
     return this.focusWindowForRpcKey(detachedRpcKey(instanceId));
   }
@@ -88,7 +110,7 @@ export class DesktopDetachedWindowManager {
     for (const [instanceId, entry] of desiredEntries) {
       const existingWindow = this.windows.get(instanceId);
       if (!existingWindow) {
-        this.createWindow(instanceId, entry);
+        if (this.windowsAllowed) this.createWindow(instanceId, entry);
         continue;
       }
 

package/src/renderers/electrobun/bun/desktop/host-requests.ts

@@ -10,6 +10,7 @@ import { safeExternalUrl } from "../../../../utils/external-url";
 import { getContextMenuRequestId, normalizeContextMenuItems } from "../context-menu/normalize";
 import { MAIN_WINDOW_RPC_KEY } from "../window/focus";
 import { applyDesktopWindowControl } from "../window/controls";
+import { startSystemWindowMove } from "../window/windows-native";
 import { saveTextFileToDownloads } from "../../../../utils/save-text-file";
 import { setAppBadge } from "./app-badge";
 import { desktopBootFramePath, saveDesktopBootFrame } from "../window/boot-frame";
@@ -111,6 +112,13 @@ export async function handleDesktopHostRequest(
     }
     case "host.windowFullscreen":
       return isWindowFullscreen(backend, backend.rpcs.getRpcWindowKey(rpc));
+    case "host.startWindowDrag": {
+      const targetWindow = windowForRpcKey(backend, backend.rpcs.getRpcWindowKey(rpc));
+      if (!targetWindow?.ptr || !startSystemWindowMove(targetWindow.ptr)) {
+        throw new Error("This window cannot be moved by the system.");
+      }
+      return null;
+    }
     case "host.openExternal": {
       if (typeof request.payload.url !== "string") {
         throw new Error("host.openExternal requires a URL.");

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -25,6 +25,7 @@ import { telemetryOptedOut } from "../../../../telemetry/crash-reports";
 import { describeNodeOs, readOrCreateInstallId } from "../../../../telemetry/crash-reports-node";
 import type { DesktopBackend, DesktopRpc } from "./backend";
 import { readDesktopViewIds } from "./view-ids";
+import { markStartupComplete } from "../../../../utils/main-thread-stall";
 
 interface DesktopWindowTarget {
   kind: "main" | "detached";
@@ -194,5 +195,12 @@ export async function initializeDesktopBackend(
     backend.workspace = createDesktopWorkspace(config, backend.getSessionSnapshot());
     backend.detachedWindows.reconcile();
   }
-  return buildInitializationPayload(backend, config, services, windowTarget);
+  const init = buildInitializationPayload(backend, config, services, windowTarget);
+  // The main window has what it needs to draw: this process is up, and the
+  // popped-out windows open next.
+  if (windowTarget.kind === "main") {
+    markStartupComplete();
+    backend.detachedWindows.openAfterMainWindow();
+  }
+  return init;
 }