gloomberb 0.11.3 → 0.12.0

package/src/plugins/builtin/plugin-marketplace/pane.tsx

@@ -0,0 +1,385 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+import {
+  DataTableStackView,
+  EmptyState,
+  InputSearchBar,
+  Spinner,
+  useExternalLinkFooter,
+  type DataTableCell,
+  type DataTableColumn,
+  type DataTableKeyEvent,
+  type PaneFooterSegment,
+} from "../../../components";
+import { useShortcut } from "../../../react/input";
+import { colors } from "../../../theme/colors";
+import type { PaneProps } from "../../../types/plugin";
+import { Box, ScrollBox, Text, TextAttributes, type InputRenderable } from "../../../ui";
+import { formatCompact } from "../../../utils/format";
+import { isPlainKey } from "../../../utils/keyboard";
+import { formatRelativeAge } from "../../../utils/relative-time";
+import { canInstallPlugins, getCurrentPluginTarget } from "../../current-target";
+import { loadRegistry, registryPluginUrl } from "./feed";
+import {
+  collectCategories,
+  filterEntries,
+  mergeCatalog,
+  sortEntries,
+  unsupportedLabel,
+  isInstallable,
+  type MarketplaceEntry,
+  type RegistryPlugin,
+} from "./model";
+import { getMarketplaceHost, getPluginInstaller } from "./store";
+
+export const PLUGIN_MARKETPLACE_PANE_ID = "plugin-marketplace";
+
+type Column = DataTableColumn & { id: "name" | "tagline" | "stars" | "status" };
+
+function buildColumns(width: number): Column[] {
+  const starsWidth = 6;
+  const statusWidth = 14;
+  const nameWidth = Math.min(26, Math.max(14, Math.floor(width * 0.24)));
+  const taglineWidth = Math.max(16, width - nameWidth - starsWidth - statusWidth - 8);
+  return [
+    { id: "name", label: "PLUGIN", width: nameWidth, align: "left" },
+    { id: "tagline", label: "DESCRIPTION", width: taglineWidth, align: "left" },
+    { id: "stars", label: "STARS", width: starsWidth, align: "right" },
+    { id: "status", label: "STATUS", width: statusWidth, align: "left" },
+  ];
+}
+
+function statusOf(
+  entry: MarketplaceEntry,
+  installedNow: readonly string[],
+): { text: string; color: string } {
+  if (installedNow.includes(entry.id)) return { text: "restart to load", color: colors.warning };
+  if (entry.loadError) return { text: "failed", color: colors.negative };
+  const unsupported = unsupportedLabel(entry);
+  if (unsupported) return { text: unsupported.toLowerCase(), color: colors.warning };
+  if (entry.bundled) return { text: "included", color: colors.textDim };
+  if (entry.installed) {
+    return entry.enabled
+      ? { text: "enabled", color: colors.positive }
+      : { text: "disabled", color: colors.textDim };
+  }
+  return { text: "available", color: colors.textBright };
+}
+
+function renderCell(
+  entry: MarketplaceEntry,
+  column: Column,
+  rowState: { selected: boolean },
+  installedNow: readonly string[],
+): DataTableCell {
+  const selected = rowState.selected ? colors.selectedText : undefined;
+
+  switch (column.id) {
+    case "name":
+      return {
+        text: entry.name,
+        color: selected ?? (entry.featured ? colors.textBright : colors.text),
+        ...(entry.featured ? { attributes: TextAttributes.BOLD } : {}),
+      };
+    case "tagline":
+      return { text: entry.tagline, color: selected ?? colors.textDim };
+    case "stars":
+      return {
+        text: entry.bundled || entry.stars === 0 ? "—" : formatCompact(entry.stars),
+        color: selected ?? colors.textDim,
+      };
+    case "status": {
+      const status = statusOf(entry, installedNow);
+      return { text: status.text, color: rowState.selected ? colors.selectedText : status.color };
+    }
+  }
+}
+
+function DetailRow({ label, value }: { label: string; value: string }) {
+  return (
+    <Box flexDirection="row" height={1} gap={1}>
+      <Text fg={colors.textDim}>{`${label}:`}</Text>
+      <Text fg={colors.text}>{value}</Text>
+    </Box>
+  );
+}
+
+function EntryDetail({ entry, width }: { entry: MarketplaceEntry; width: number }) {
+  const contributes: string[] = [];
+  if (entry.contributes) {
+    const { panes, capabilities, broker } = entry.contributes;
+    if (panes.length > 0) contributes.push(`${panes.length} pane${panes.length === 1 ? "" : "s"}`);
+    if (capabilities.length > 0) contributes.push(`${capabilities.length} data source${capabilities.length === 1 ? "" : "s"}`);
+    if (broker) contributes.push("a broker integration");
+  }
+
+  return (
+    <ScrollBox flexDirection="column" width={width} paddingLeft={1} paddingRight={1}>
+      <Box flexDirection="row" gap={2} height={1}>
+        <Text fg={colors.textDim}>{entry.tier}</Text>
+        <Text fg={colors.textDim}>{entry.categories.join(", ")}</Text>
+        {entry.installedVersion ? <Text fg={colors.textDim}>{`v${entry.installedVersion}`}</Text> : null}
+        {!entry.bundled && entry.stars > 0 ? <Text fg={colors.textDim}>{`${entry.stars} stars`}</Text> : null}
+      </Box>
+
+      {entry.description ? (
+        <Box paddingTop={1} flexDirection="column">
+          <Text fg={colors.text}>{entry.description}</Text>
+        </Box>
+      ) : null}
+
+      <Box paddingTop={1} flexDirection="column">
+        {contributes.length > 0 ? <DetailRow label="Adds" value={contributes.join(", ")} /> : null}
+        {/*
+          * Declared by the plugin author and not enforced: plugins are not
+          * sandboxed, so this is a hint about intent, not a limit. Labelled
+          * "Declares" rather than "Network" so it does not read as a guarantee.
+          */}
+        {entry.hosts.length > 0 ? <DetailRow label="Declares" value={entry.hosts.join(", ")} /> : null}
+        {entry.repo ? <DetailRow label="Source" value={`github.com/${entry.repo}`} /> : null}
+        {entry.loadError ? <DetailRow label="Error" value={entry.loadError} /> : null}
+      </Box>
+
+      {!entry.installed && !entry.bundled && entry.repo ? (
+        <Box paddingTop={1} flexDirection="column">
+          <Text fg={colors.textDim}>Runs with your full permissions. Read the source first.</Text>
+          <Text fg={colors.textBright}>{`gloomberb install ${entry.repo}`}</Text>
+        </Box>
+      ) : null}
+    </ScrollBox>
+  );
+}
+
+export function PluginMarketplacePane({ focused, width, height }: PaneProps) {
+  const [query, setQuery] = useState("");
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [detailOpen, setDetailOpen] = useState(false);
+  const [searchFocused, setSearchFocused] = useState(false);
+  // null keeps the curated order: featured first, then tier, then stars.
+  const [sortColumn, setSortColumn] = useState<"name" | "stars" | null>(null);
+  const [searchFocusToken, setSearchFocusToken] = useState(0);
+  const searchInputRef = useRef<InputRenderable | null>(null);
+
+  const [registry, setRegistry] = useState<RegistryPlugin[]>([]);
+  const [status, setStatus] = useState<"loading" | "ready" | "error">("loading");
+  const [stale, setStale] = useState(false);
+  const [fetchedAt, setFetchedAt] = useState<number | null>(null);
+  // Bumped after a toggle or install so the list is re-read from the host.
+  const [localRevision, setLocalRevision] = useState(0);
+  const [installing, setInstalling] = useState<string | null>(null);
+  const [installError, setInstallError] = useState<string | null>(null);
+  // Installed during this session. A plugin is only registered at startup, so
+  // saying "enabled" here would be a lie — the pane it adds is not there yet.
+  const [installedNow, setInstalledNow] = useState<readonly string[]>([]);
+
+  const refresh = useCallback((force: boolean) => {
+    setStatus((current) => (current === "ready" ? current : "loading"));
+    void loadRegistry({ force }).then((result) => {
+      setRegistry(result.plugins);
+      setStale(result.stale);
+      setFetchedAt(result.fetchedAt);
+      setStatus(result.error && result.plugins.length === 0 ? "error" : "ready");
+    });
+  }, []);
+
+  useEffect(() => refresh(false), [refresh]);
+
+  const target = getCurrentPluginTarget();
+  const entries = useMemo(() => {
+    void localRevision;
+    const installed = getMarketplaceHost()?.listInstalled() ?? [];
+    return sortEntries(mergeCatalog({ registry, installed, target }));
+  }, [registry, target, localRevision]);
+
+  const rows = useMemo(() => {
+    const filtered = filterEntries(entries, { query, category: null });
+    if (sortColumn === "name") return [...filtered].sort((a, b) => a.name.localeCompare(b.name));
+    if (sortColumn === "stars") return [...filtered].sort((a, b) => b.stars - a.stars);
+    return filtered;
+  }, [entries, query, sortColumn]);
+
+  const selected = useMemo(
+    () => rows.find((entry) => entry.id === selectedId) ?? rows[0] ?? null,
+    [rows, selectedId],
+  );
+
+  const focusSearch = useCallback(() => {
+    setSearchFocused(true);
+    setSearchFocusToken((token) => token + 1);
+  }, []);
+  const blurSearch = useCallback(() => setSearchFocused(false), []);
+
+  const toggleSelected = useCallback(() => {
+    const host = getMarketplaceHost();
+    if (!host || !selected || !selected.installed || !selected.toggleable) return;
+    host.setPluginEnabled(selected.id, !selected.enabled);
+    setLocalRevision((value) => value + 1);
+  }, [selected]);
+
+  const installSelected = useCallback(() => {
+    const install = getPluginInstaller();
+    if (!selected || !isInstallable(selected) || !install || installing) return;
+    if (installedNow.includes(selected.id)) return;
+    // Installs address the repository, not the plugin id: there is no central
+    // name resolution, so owner/repo is the only unambiguous reference.
+    const repo = selected.repo;
+    if (!repo) return;
+    const target = selected.id;
+    setInstalling(target);
+    setInstallError(null);
+    void install(repo).then((result) => {
+      setInstalling(null);
+      if (result.ok) {
+        setInstalledNow((current) => [...current, target]);
+        setLocalRevision((value) => value + 1);
+        return;
+      }
+      setInstallError(result.error ?? "Install failed.");
+    });
+  }, [installedNow, installing, selected]);
+
+  /**
+   * Pane keys go through the table's key handler rather than a global shortcut:
+   * while the DataTable holds key focus it consumes plain letters, so a
+   * `useShortcut` for "i" never fires.
+   */
+  const handleRootKeyDown = useCallback((event: DataTableKeyEvent) => {
+    if (searchFocused) return;
+    const key = (event.name ?? "").toLowerCase();
+    if (key === "i") {
+      installSelected();
+      return true;
+    }
+    if (key === "e") {
+      toggleSelected();
+      return true;
+    }
+    if (key === "r") {
+      refresh(true);
+      return true;
+    }
+    if (key === "/") {
+      focusSearch();
+      return true;
+    }
+    return undefined;
+  }, [focusSearch, installSelected, refresh, searchFocused, toggleSelected]);
+
+  useShortcut((event) => {
+    if (!focused || searchFocused) return;
+    const key = (event.name ?? event.key ?? "").toLowerCase();
+    if (key === "r" && isPlainKey(event)) {
+      event.preventDefault?.();
+      refresh(true);
+      return;
+    }
+    if (key === "e" && isPlainKey(event)) {
+      event.preventDefault?.();
+      toggleSelected();
+      return;
+    }
+    if (key === "/" && isPlainKey(event)) {
+      event.preventDefault?.();
+      focusSearch();
+      return;
+    }
+    if (key === "i" && isPlainKey(event)) {
+      event.preventDefault?.();
+      installSelected();
+    }
+  });
+
+  const info: PaneFooterSegment[] = [];
+  if (status === "loading") info.push({ id: "loading", parts: [{ text: "loading", tone: "muted" }] });
+  if (status === "error") info.push({ id: "error", parts: [{ text: "catalog unavailable", tone: "warning" }] });
+  if (stale) info.push({ id: "stale", parts: [{ text: "stale catalog", tone: "warning" }] });
+  if (installing) {
+    info.push({ id: "installing", parts: [{ text: `installing ${installing}`, tone: "muted" }] });
+  }
+  if (installError) info.push({ id: "install-error", parts: [{ text: installError, tone: "warning" }] });
+  if (installedNow.length > 0 && !installing) {
+    info.push({ id: "restart", parts: [{ text: "restart to load new plugins", tone: "warning" }] });
+  }
+  if (status === "ready" && fetchedAt && !stale) {
+    info.push({ id: "updated", parts: [{ text: formatRelativeAge(fetchedAt), tone: "muted" }] });
+  }
+
+  useExternalLinkFooter({
+    registrationId: PLUGIN_MARKETPLACE_PANE_ID,
+    focused,
+    url: selected ? registryPluginUrl(selected.id) : null,
+    source: selected ? "gloom.sh" : null,
+    info,
+    hints: selected && isInstallable(selected) && !installedNow.includes(selected.id) && getPluginInstaller()
+      ? [{ id: "install", key: "i", label: "nstall", onPress: installSelected }]
+      : selected?.installed && selected.toggleable
+        ? [{ id: "toggle", key: "e", label: selected.enabled ? "disable" : "nable", onPress: toggleSelected }]
+        : [],
+  });
+
+  const columns = useMemo(() => buildColumns(width), [width]);
+
+  if (status === "loading" && entries.length === 0) {
+    return (
+      <Box flexDirection="column" width={width} height={height}>
+        <Box flexGrow={1} alignItems="center" justifyContent="center">
+          <Spinner />
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" width={width} height={height}>
+      <DataTableStackView<MarketplaceEntry, Column>
+        focused={focused && !searchFocused}
+        detailOpen={detailOpen && !!selected}
+        onBack={() => setDetailOpen(false)}
+        detailContent={selected ? <EntryDetail entry={selected} width={width} /> : null}
+        detailTitle={selected?.name}
+        rootBefore={(
+          <InputSearchBar
+            value={query}
+            focused={focused && !detailOpen}
+            active={searchFocused}
+            width={width}
+            focusToken={searchFocusToken}
+            inputRef={searchInputRef}
+            placeholder="name or category"
+            debounceMs={80}
+            onFocus={focusSearch}
+            onBlur={blurSearch}
+            onNavigateDown={blurSearch}
+            onQueryChange={setQuery}
+          />
+        )}
+        selection={{
+          kind: "id",
+          selectedId: selected?.id ?? null,
+          getId: (entry) => entry.id,
+          onChange: (id) => setSelectedId(typeof id === "string" ? id : null),
+        }}
+        onRootKeyDown={handleRootKeyDown}
+        onDetailKeyDown={handleRootKeyDown}
+        onActivate={() => setDetailOpen(true)}
+        rootWidth={width}
+        rootHeight={height}
+        columns={columns}
+        items={rows}
+        getItemKey={(entry) => entry.id}
+        sortColumnId={sortColumn}
+        sortDirection={sortColumn === "name" ? "asc" : "desc"}
+        onHeaderClick={(columnId) => {
+          // Only these two columns have a meaningful order; the rest keep the
+          // curated ranking rather than pretending to be sortable.
+          if (columnId === "name" || columnId === "stars") {
+            setSortColumn((current) => (current === columnId ? null : columnId));
+          }
+        }}
+        renderCell={(entry, column, _index, rowState) => renderCell(entry, column, rowState, installedNow)}
+        emptyStateTitle={status === "error" ? "Plugin catalog unavailable." : "No plugins match."}
+        emptyStateHint={status === "error" ? "Press r to retry." : undefined}
+      />
+    </Box>
+  );
+}

package/src/plugins/builtin/plugin-marketplace/store.ts

@@ -0,0 +1,46 @@
+import type { InstalledPlugin } from "./model";
+
+/**
+ * The marketplace pane needs two things no other pane does: the full plugin
+ * catalog including entries that failed to load, and the ability to enable and
+ * disable them. Neither is on the render-time plugin runtime, and widening the
+ * public plugin API for a single built-in consumer would be the wrong trade.
+ *
+ * So the app binds a host here at startup, the same way the layout manager
+ * receives its dispatch from `bindAppPanePluginRegistry`.
+ */
+
+export interface MarketplaceHost {
+  listInstalled(): InstalledPlugin[];
+  setPluginEnabled(pluginId: string, enabled: boolean): void;
+}
+
+let host: MarketplaceHost | null = null;
+
+export function setMarketplaceHost(next: MarketplaceHost | null): void {
+  host = next;
+}
+
+export function getMarketplaceHost(): MarketplaceHost | null {
+  return host;
+}
+
+/**
+ * Installing a plugin means running git and bun, which only the Bun-hosted
+ * renderers can do — and the desktop view has to ask its Bun process over RPC.
+ * Rather than let this pane reach for a renderer API and break the
+ * renderer-neutrality rule, each renderer installs its own implementation at
+ * startup. A renderer that leaves it unset (the browser) gets the install
+ * command shown instead of a button.
+ */
+export type PluginInstaller = (ref: string) => Promise<{ ok: boolean; error?: string }>;
+
+let installer: PluginInstaller | null = null;
+
+export function setPluginInstaller(next: PluginInstaller | null): void {
+  installer = next;
+}
+
+export function getPluginInstaller(): PluginInstaller | null {
+  return installer;
+}

package/src/plugins/builtin/plugin-module.ts

@@ -4,7 +4,15 @@ import type {
   GloomPluginContext,
 } from "../../types/plugin";
 
-type PluginMetadataKey = "id" | "name" | "version" | "description" | "toggleable" | "order";
+type PluginMetadataKey =
+  | "id"
+  | "name"
+  | "version"
+  | "description"
+  | "toggleable"
+  | "order"
+  | "targets"
+  | "homepage";
 type PluginMetadata = Pick<GloomPlugin, PluginMetadataKey>;
 
 export type PluginModule = Omit<GloomPlugin, PluginMetadataKey>;

package/src/plugins/builtin/research/index.tsx

@@ -50,6 +50,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 90, height: 28 },
+      tableExport: true,
     },
     {
       id: "equity-diagnostic",
@@ -68,6 +69,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 24 },
+      tableExport: true,
     },
     {
       id: "relative-valuation",
@@ -77,6 +79,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 24 },
+      tableExport: true,
     },
     {
       id: "earnings-estimates",
@@ -86,6 +89,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 22 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/research-search/command-bar-search.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudSearchHit } from "../../../api-client";
+import { hitResultDef } from "./command-bar-search";
+import { formatHitDateShort } from "./model";
+
+const NOW = new Date("2026-09-01T12:00:00").getTime();
+
+function hit(overrides: Partial<CloudSearchHit>): CloudSearchHit {
+  return {
+    id: "hit-1",
+    docType: "news",
+    sourceId: "doc-1",
+    chunkIndex: 0,
+    ticker: "NVDA",
+    publishedAt: "2026-08-30T09:00:00",
+    title: "Nvidia guides above estimates",
+    url: "https://example.com",
+    snippet: "record <mark>margin</mark> again",
+    score: 1,
+    metadata: { source: "Reuters" },
+    ...overrides,
+  };
+}
+
+describe("formatHitDateShort", () => {
+  /**
+   * Three formats hinge on two boundaries, a day and a year, and the column
+   * is too narrow to tell a mistake from a design choice.
+   */
+  test("switches from age to day to month at the day and year boundaries", () => {
+    const at = (iso: string) => formatHitDateShort(iso, NOW);
+    expect(at("2026-09-01T11:59:30")).toBe("1m");
+    expect(at("2026-09-01T08:45:00")).toBe("3h");
+    expect(at("2026-08-31T12:00:01")).toBe("23h");
+    expect(at("2026-08-31T12:00:00")).toBe("Aug 31");
+    expect(at("2026-01-01T00:00:00")).toBe("Jan 1");
+    expect(at("2025-12-31T23:59:59")).toBe("Dec 2025");
+    // A clock ahead of ours is not "in -2h".
+    expect(at("2026-09-01T14:00:00")).toBe("Sep 1");
+    expect(at("not a date")).toBe("");
+    expect(at(undefined)).toBe("");
+  });
+});
+
+describe("document hit rows", () => {
+  test("put the date on the right and the source and ticker ahead of the snippet", () => {
+    const row = hitResultDef(hit({}), () => {}, NOW);
+    expect(row.badge).toBe("NEWS");
+    expect(row.right).toBe("Aug 30");
+    expect(row.lines).toEqual([{
+      segments: [
+        { text: "Reuters · NVDA · ", emphasis: "muted" },
+        { text: "record ", emphasis: undefined },
+        { text: "margin", emphasis: "match" },
+        { text: " again", emphasis: undefined },
+      ],
+    }]);
+  });
+
+  test("lead with the speaker for a call and the section for a filing, whose form is the badge", () => {
+    const call = hitResultDef(hit({
+      docType: "transcript",
+      metadata: { speaker: "Colette Kress", role: "CFO" },
+    }), () => {}, NOW);
+    expect(call.badge).toBe("CALL");
+    expect(call.lines?.[0]?.segments[0]?.text).toBe("Colette Kress, CFO · NVDA · ");
+
+    const filing = hitResultDef(hit({
+      docType: "filing",
+      metadata: { form: "10-K", section: "Item 1A" },
+    }), () => {}, NOW);
+    expect(filing.badge).toBe("10-K");
+    expect(filing.lines?.[0]?.segments[0]?.text).toBe("Item 1A · NVDA · ");
+
+    const bare = hitResultDef(hit({ metadata: {} }), () => {}, NOW);
+    expect(bare.lines?.[0]?.segments[0]?.text).toBe("NVDA · ");
+
+    // The News section is all one kind, so a badge there would only repeat the heading.
+    expect(hitResultDef(hit({}), () => {}, NOW, { badge: false }).badge).toBeUndefined();
+  });
+});