gloomberb 0.11.2 → 0.12.0

package/src/plugins/catalog-ui.ts

@@ -1,16 +1,16 @@
 import type { GloomPlugin } from "../types/plugin";
+import type { LoadedExternalPlugin } from "./loader";
 import { newsPlugin } from "./builtin/news";
 import { notesPlugin } from "./builtin/notes";
-import { substackPlugin } from "./builtin/substack";
 import { aiPlugin } from "./builtin/ai";
 import { gloomberbCloudPlugin } from "./builtin/cloud";
-import { ibkrPlugin } from "./ibkr";
 import { publicPlugin } from "./broker-sync/public";
 import { robinhoodPlugin } from "./broker-sync/robinhood";
 import { simpleFinPlugin } from "./broker-sync/simplefin";
 import { predictionMarketsPlugin } from "./prediction-markets";
 import { pollsPlugin } from "./builtin/polls";
 import { alertsPlugin } from "./builtin/alerts";
+import { researchSearchPlugin } from "./builtin/research-search";
 import {
   applicationPlugin,
   brokerPlugin,
@@ -25,13 +25,11 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   portfolioPlugin,
   tickerResearchPlugin,
   brokerPlugin,
-  ibkrPlugin,
   publicPlugin,
   robinhoodPlugin,
   simpleFinPlugin,
   applicationPlugin,
   newsPlugin,
-  substackPlugin,
   notesPlugin,
   aiPlugin,
   predictionMarketsPlugin,
@@ -39,8 +37,26 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   marketOverviewPlugin,
   macroPlugin,
   alertsPlugin,
+  researchSearchPlugin,
 ];
 
 export function getRendererBuiltinPlugins(): GloomPlugin[] {
   return uiBuiltinPlugins;
 }
+
+/**
+ * The plugin list for a UI renderer: the built-ins it ships with, plus any
+ * external plugins that loaded and support this renderer.
+ *
+ * Deliberately not `getLoadablePlugins`, which is the CLI catalog and also
+ * carries the Yahoo fallback provider and the debug plugin. Routing the desktop
+ * through it would quietly change which plugins the app runs.
+ */
+export function getRendererPlugins(externalPlugins: readonly LoadedExternalPlugin[] = []): GloomPlugin[] {
+  return [
+    ...uiBuiltinPlugins,
+    ...externalPlugins
+      .filter((entry) => !entry.error && !entry.unsupportedTarget)
+      .map((entry) => entry.plugin),
+  ];
+}

package/src/plugins/catalog.ts

@@ -1,4 +1,4 @@
-import type { GloomPlugin } from "../types/plugin";
+import type { GloomPlugin, PluginTarget } from "../types/plugin";
 import type { LoadedExternalPlugin } from "./loader";
 import { debugPlugin } from "./builtin/debug";
 import { yahooPlugin } from "./builtin/yahoo";
@@ -9,6 +9,12 @@ export interface PluginCatalogEntry {
   source: "builtin" | "external";
   path?: string;
   error?: string;
+  /**
+   * Set when the plugin installed cleanly but cannot run here — IBKR Gateway on
+   * the web build, for example. The catalog still lists it so the marketplace
+   * can explain why it is inert instead of leaving the user wondering.
+   */
+  unsupportedTarget?: PluginTarget;
 }
 
 const builtinPlugins: GloomPlugin[] = [
@@ -28,12 +34,13 @@ export function getPluginCatalog(externalPlugins: LoadedExternalPlugin[] = []):
       source: "external" as const,
       path: entry.path,
       error: entry.error,
+      unsupportedTarget: entry.unsupportedTarget,
     })),
   ];
 }
 
 export function getLoadablePlugins(externalPlugins: LoadedExternalPlugin[] = []): GloomPlugin[] {
   return getPluginCatalog(externalPlugins)
-    .filter((entry) => !entry.error)
+    .filter((entry) => !entry.error && !entry.unsupportedTarget)
     .map((entry) => entry.plugin);
 }

package/src/plugins/current-target.ts

@@ -0,0 +1,28 @@
+import type { PluginTarget } from "../types/plugin";
+
+/**
+ * Which renderer is running.
+ *
+ * Renderers declare this at startup rather than having it sniffed from globals:
+ * the Electrobun view and the hosted browser app are both browser contexts and
+ * are otherwise hard to tell apart, yet they differ in what a plugin can do
+ * (the desktop app can shell out to git; term.gloom.sh cannot).
+ */
+let currentTarget: PluginTarget = "cli";
+
+export function setCurrentPluginTarget(target: PluginTarget): void {
+  currentTarget = target;
+}
+
+export function getCurrentPluginTarget(): PluginTarget {
+  return currentTarget;
+}
+
+/**
+ * Whether this renderer can install plugins itself. Installing means cloning a
+ * repository and running `bun install`, so only the Bun-hosted renderers can;
+ * elsewhere the marketplace shows the command to run instead.
+ */
+export function canInstallPlugins(): boolean {
+  return currentTarget === "cli" || currentTarget === "tui";
+}

package/src/plugins/host-contract.ts

@@ -0,0 +1,37 @@
+/**
+ * The contract shared between the plugin bundler and the renderers that load
+ * its output.
+ *
+ * Kept in its own module with no imports on purpose. The bundler runs in Bun
+ * and reaches the filesystem; the renderers that consume it are browser
+ * contexts. Pulling these two constants from `bundle.ts` dragged the whole
+ * bundler — and through it `plugins/loader.ts`, which reads `process.env.HOME`
+ * at module scope — into the desktop view, where it threw on load.
+ */
+
+export const PLUGIN_HOST_GLOBAL = "__GLOOM_PLUGIN_HOST__";
+
+/**
+ * Specifiers a plugin may import that must resolve to the host's copy. Anything
+ * else is a plugin's own dependency and gets bundled normally.
+ *
+ * Deliberately no `react-dom`: it is a renderer package, and plugins are
+ * required to be renderer-neutral so the same code runs in the terminal. A
+ * plugin reaching for it should fail to bundle rather than quietly work on the
+ * desktop and break in the TUI.
+ */
+export const SHARED_SPECIFIERS = [
+  "react",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "gloomberb/types/plugin",
+  "gloomberb/types/persistence",
+  "gloomberb/ui",
+  "gloomberb/components",
+  "gloomberb/theme",
+  "gloomberb/capabilities",
+  "gloomberb/utils",
+  "gloomberb/react",
+] as const;
+
+export type SharedSpecifier = (typeof SHARED_SPECIFIERS)[number];

package/src/plugins/host-link.ts

@@ -0,0 +1,158 @@
+import { existsSync, lstatSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+/**
+ * External plugins live in `~/.gloomberb/plugins/<name>/`, outside any
+ * `node_modules` chain that could reach the running Gloomberb install. Left
+ * alone, `import { Box } from "gloomberb/ui"` does not resolve, and a plugin
+ * that lists `react` as a real dependency gets its *own* copy — two React
+ * instances in one process, which throws on the first hook.
+ *
+ * So the host links itself and its React into each plugin's `node_modules`.
+ * Plugins declare both as peer dependencies and never install them. This keeps
+ * one module instance per process and makes plugin imports resolve exactly the
+ * way they do for first-party code.
+ *
+ * Links are rebuilt after every install and update, because `bun install`
+ * prunes entries it does not know about, and repaired at load time so a plugin
+ * copied in by hand still works.
+ */
+
+const LINKED_PACKAGES = ["gloomberb", "react", "react-dom"] as const;
+
+let cachedHostRoot: string | null | undefined;
+
+/** Walks up from this module to the directory holding the `gloomberb` package.json. */
+export function findHostPackageRoot(startDir: string = import.meta.dir): string | null {
+  if (cachedHostRoot !== undefined && startDir === import.meta.dir) return cachedHostRoot;
+  let dir = resolve(startDir);
+  for (let depth = 0; depth < 12; depth += 1) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(require("fs").readFileSync(pkgPath, "utf-8")) as { name?: string };
+        if (pkg.name === "gloomberb") {
+          if (startDir === import.meta.dir) cachedHostRoot = dir;
+          return dir;
+        }
+      } catch {
+        // Unreadable package.json — keep walking rather than giving up.
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (startDir === import.meta.dir) cachedHostRoot = null;
+  return null;
+}
+
+function linkTarget(hostRoot: string, pkg: string): string | null {
+  if (pkg === "gloomberb") return hostRoot;
+  const candidate = join(hostRoot, "node_modules", pkg);
+  return existsSync(candidate) ? candidate : null;
+}
+
+/** True when `path` is already a symlink pointing at `target`. */
+function alreadyLinked(path: string, target: string): boolean {
+  try {
+    return lstatSync(path).isSymbolicLink() && resolve(dirname(path), readlinkSync(path)) === resolve(target);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Links sibling plugins a plugin declares as peer dependencies.
+ *
+ * A plugin can legitimately extend another — IBKR Gateway builds on the Flex
+ * plugin, which owns the broker id and the shared bridge. Those live in separate
+ * install directories with no path between them, so the peer is linked the same
+ * way the host is. A missing sibling is not an error here: the plugin reports it
+ * at load, which is more useful than failing the install.
+ */
+function linkPeerPlugins(pluginDir: string, pluginsDir: string): string[] {
+  const linked: string[] = [];
+  let peers: string[] = [];
+  try {
+    const pkg = JSON.parse(require("fs").readFileSync(join(pluginDir, "package.json"), "utf-8"));
+    peers = Object.keys(pkg.peerDependencies ?? {}).filter((name) => name.startsWith("gloomberb-"));
+  } catch {
+    return linked;
+  }
+
+  for (const peer of peers) {
+    // Installed directories are named after the repository, which is the package
+    // name for every plugin in the registry.
+    const target = join(pluginsDir, peer);
+    if (!existsSync(target)) continue;
+    const linkPath = join(pluginDir, "node_modules", peer);
+    if (alreadyLinked(linkPath, target)) {
+      linked.push(peer);
+      continue;
+    }
+    try {
+      mkdirSync(join(pluginDir, "node_modules"), { recursive: true });
+      if (existsSync(linkPath) || lstatSync(linkPath, { throwIfNoEntry: false })) {
+        rmSync(linkPath, { recursive: true, force: true });
+      }
+      symlinkSync(target, linkPath, "dir");
+      linked.push(peer);
+    } catch {
+      // Reported by the plugin's own load failure if it actually needed it.
+    }
+  }
+  return linked;
+}
+
+export interface HostLinkResult {
+  linked: string[];
+  skipped: string[];
+  error?: string;
+}
+
+/**
+ * Points `<pluginDir>/node_modules/{gloomberb,react,react-dom}` at the running
+ * install. Safe to call repeatedly.
+ */
+export function linkHostPackages(
+  pluginDir: string,
+  hostRoot = findHostPackageRoot(),
+  pluginsDir = dirname(pluginDir),
+): HostLinkResult {
+  if (!hostRoot) return { linked: [], skipped: [...LINKED_PACKAGES], error: "Could not locate the Gloomberb install." };
+
+  const modulesDir = join(pluginDir, "node_modules");
+  const linked: string[] = [];
+  const skipped: string[] = [];
+
+  for (const pkg of LINKED_PACKAGES) {
+    const target = linkTarget(hostRoot, pkg);
+    if (!target) {
+      skipped.push(pkg);
+      continue;
+    }
+    const linkPath = join(modulesDir, pkg);
+    if (alreadyLinked(linkPath, target)) {
+      linked.push(pkg);
+      continue;
+    }
+    try {
+      mkdirSync(modulesDir, { recursive: true });
+      // A real directory here means `bun install` fetched a second copy; replacing
+      // it is the whole point, otherwise the plugin runs against a duplicate React.
+      if (existsSync(linkPath) || lstatSync(linkPath, { throwIfNoEntry: false })) {
+        rmSync(linkPath, { recursive: true, force: true });
+      }
+      symlinkSync(target, linkPath, "dir");
+      linked.push(pkg);
+    } catch (err) {
+      skipped.push(pkg);
+      if (pkg === "gloomberb") return { linked, skipped, error: String(err) };
+    }
+  }
+
+  linked.push(...linkPeerPlugins(pluginDir, pluginsDir));
+
+  return { linked, skipped };
+}

package/src/plugins/host-modules.ts

@@ -0,0 +1,61 @@
+import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS } from "./host-contract";
+
+/**
+ * Publishes the host's shared modules for compiled plugin bundles to read.
+ *
+ * Browser-context renderers load plugins as separate ES modules, so the bundler
+ * rewrites their `react` and `gloomberb/*` imports to read from this registry
+ * (see `bundle.ts`). This must run before any plugin bundle is imported, and
+ * the modules here must be the same instances the app itself uses — importing
+ * them normally is what guarantees that.
+ */
+export async function installPluginHostModules(): Promise<void> {
+  const globals = globalThis as Record<string, unknown>;
+  if (globals[PLUGIN_HOST_GLOBAL]) return;
+
+  const [
+    react,
+    jsxRuntime,
+    typesPlugin,
+    typesPersistence,
+    ui,
+    components,
+    theme,
+    capabilities,
+    utils,
+    pluginReact,
+  ] = await Promise.all([
+    import("react"),
+    import("react/jsx-runtime"),
+    // Type-only modules still need an entry: a plugin may import a runtime
+    // value from them, and a missing key throws a clearer error than undefined.
+    import("../types/plugin"),
+    import("../types/persistence"),
+    import("../ui"),
+    import("../components"),
+    import("../theme/colors"),
+    import("../capabilities"),
+    import("../public/utils"),
+    import("../public/react"),
+  ]);
+
+  const registry: Record<string, unknown> = {
+    "react": react,
+    "react/jsx-runtime": jsxRuntime,
+    "react/jsx-dev-runtime": jsxRuntime,
+    "gloomberb/types/plugin": typesPlugin,
+    "gloomberb/types/persistence": typesPersistence,
+    "gloomberb/ui": ui,
+    "gloomberb/components": components,
+    "gloomberb/theme": theme,
+    "gloomberb/capabilities": capabilities,
+    "gloomberb/utils": utils,
+    "gloomberb/react": pluginReact,
+  };
+
+  for (const specifier of SHARED_SPECIFIERS) {
+    if (!registry[specifier]) throw new Error(`Plugin host registry is missing "${specifier}"`);
+  }
+
+  globals[PLUGIN_HOST_GLOBAL] = registry;
+}

package/src/plugins/loader.ts

@@ -2,8 +2,9 @@ import { readdir } from "fs/promises";
 import { join } from "path";
 import { existsSync } from "fs";
 import { homedir } from "os";
-import type { GloomPlugin } from "../types/plugin";
+import type { GloomPlugin, PluginTarget } from "../types/plugin";
 import { debugLog } from "../utils/debug-log";
+import { linkHostPackages } from "./host-link";
 
 const loaderLog = debugLog.createLogger("plugin-loader");
 
@@ -13,13 +14,41 @@ export interface LoadedExternalPlugin {
   plugin: GloomPlugin;
   path: string;
   error?: string;
+  /** Set when the plugin loaded but does not support the running renderer. */
+  unsupportedTarget?: PluginTarget;
 }
 
 export function getPluginsDir(): string {
   return PLUGINS_DIR;
 }
 
-export async function loadExternalPlugins(): Promise<LoadedExternalPlugin[]> {
+/** Resolves a plugin directory's entry file the way `bun install` would. */
+export async function resolvePluginEntry(pluginDir: string): Promise<string | null> {
+  const pkgPath = join(pluginDir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await Bun.file(pkgPath).text());
+      if (pkg.main) {
+        const main = join(pluginDir, pkg.main);
+        if (existsSync(main)) return main;
+      }
+    } catch {
+      // Malformed package.json falls through to the index candidates.
+    }
+  }
+  for (const candidate of ["index.ts", "index.tsx", "index.js"]) {
+    const path = join(pluginDir, candidate);
+    if (existsSync(path)) return path;
+  }
+  return null;
+}
+
+export function pluginSupportsTarget(plugin: GloomPlugin, target: PluginTarget): boolean {
+  // No declaration means "everywhere"; the registry fills this in for listed plugins.
+  return !plugin.targets || plugin.targets.length === 0 || plugin.targets.includes(target);
+}
+
+export async function loadExternalPlugins(target: PluginTarget = "cli"): Promise<LoadedExternalPlugin[]> {
   if (!existsSync(PLUGINS_DIR)) return [];
 
   const results: LoadedExternalPlugin[] = [];
@@ -29,32 +58,22 @@ export async function loadExternalPlugins(): Promise<LoadedExternalPlugin[]> {
     if (!entry.isDirectory()) continue;
     const pluginDir = join(PLUGINS_DIR, entry.name);
 
-    // Look for entry file
-    let entryFile: string | null = null;
-
-    // Check package.json first
-    const pkgPath = join(pluginDir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(await Bun.file(pkgPath).text());
-        if (pkg.main) entryFile = join(pluginDir, pkg.main);
-      } catch { /* ignore malformed package.json */ }
-    }
-
-    // Fall back to index files
-    if (!entryFile) {
-      for (const candidate of ["index.ts", "index.tsx", "index.js"]) {
-        const p = join(pluginDir, candidate);
-        if (existsSync(p)) { entryFile = p; break; }
-      }
-    }
-
+    const entryFile = await resolvePluginEntry(pluginDir);
     if (!entryFile) continue;
 
+    // Repairs `gloomberb`/`react` links for plugins copied in by hand or left
+    // behind by a `bun install` that pruned them.
+    linkHostPackages(pluginDir);
+
     try {
       const mod = await import(entryFile);
       const plugin: GloomPlugin = mod.default ?? mod.plugin;
       if (plugin && plugin.id && plugin.name) {
+        if (!pluginSupportsTarget(plugin, target)) {
+          loaderLog.info(`Skipped ${plugin.id}: does not support "${target}"`);
+          results.push({ plugin, path: pluginDir, unsupportedTarget: target });
+          continue;
+        }
         loaderLog.info(`Loaded external plugin: ${plugin.id} v${plugin.version ?? "0.0.0"}`);
         results.push({ plugin, path: pluginDir });
       }

package/src/plugins/ownership.ts

@@ -7,6 +7,7 @@ const BUILTIN_PLUGIN_OWNER_ALIASES: Record<string, string> = {
   "comparison-chart": "ticker-research",
   correlation: "market-overview",
   "earnings-calendar": "macro",
+  "earnings-calls": "macro",
   "ipo-calendar": "macro",
   "fear-greed": "market-overview",
   "fx-matrix": "market-overview",

package/src/plugins/prediction-markets/index.tsx

@@ -43,6 +43,7 @@ export const predictionMarketsPlugin: GloomPlugin = {
       defaultPosition: "left",
       defaultMode: "floating",
       defaultFloatingSize: { width: 132, height: 36 },
+      tableExport: true,
       settings: (context) =>
         buildPredictionMarketsPaneSettingsDef(
           context.config,

package/src/plugins/registry/context.ts

@@ -142,6 +142,9 @@ export function createRegistryPluginContext({
     registerPane: (pane) => contributions.registerPane(pluginId, pane, items),
     registerPaneTemplate: (template) => contributions.registerPaneTemplate(pluginId, template, items),
     registerCommand: (command) => contributions.registerCommand(pluginId, command, items),
+    registerCommandBarSearchProvider: (provider) => (
+      contributions.registerCommandBarSearchProvider(pluginId, provider, items)
+    ),
     registerColumn: (column) => contributions.registerColumn(pluginId, column, items),
     registerBroker: (broker) => contributions.registerBroker(pluginId, broker, items),
     registerCapability: (capability) => {

package/src/plugins/registry/contributions.ts

@@ -1,5 +1,6 @@
 import type { BrokerAdapter } from "../../types/broker";
 import type {
+  CommandBarSearchProvider,
   CommandDef,
   ContextMenuProviderDef,
   CustomColumnDef,
@@ -19,6 +20,7 @@ export interface PluginItems {
   panes: string[];
   paneTemplates: string[];
   commands: string[];
+  commandBarSearchProviders: string[];
   columns: string[];
   brokers: string[];
   capabilities: string[];
@@ -45,6 +47,7 @@ function setUnique<T>(map: Map<string, T>, id: string, value: T): void {
 export class RegistryContributions {
   readonly pluginItems = new Map<string, PluginItems>();
   readonly commandOwners = new Map<string, string>();
+  readonly commandBarSearchProviderOwners = new Map<string, string>();
   readonly paneOwners = new Map<string, string>();
   readonly paneTemplateOwners = new Map<string, string>();
   readonly shortcutOwners = new Map<string, string>();
@@ -54,6 +57,7 @@ export class RegistryContributions {
   readonly panesMap = new Map<string, PaneDef>();
   readonly paneTemplatesMap = new Map<string, PaneTemplateDef>();
   readonly commandsMap = new Map<string, CommandDef>();
+  readonly commandBarSearchProvidersMap = new Map<string, CommandBarSearchProvider>();
   readonly columnsMap = new Map<string, CustomColumnDef>();
   readonly brokersMap = new Map<string, BrokerAdapter>();
   readonly tickerResearchTabsMap = new Map<string, TickerResearchTabDef>();
@@ -71,6 +75,7 @@ export class RegistryContributions {
       panes: [],
       paneTemplates: [],
       commands: [],
+      commandBarSearchProviders: [],
       columns: [],
       brokers: [],
       capabilities: [],
@@ -104,6 +109,24 @@ export class RegistryContributions {
     items.commands.push(command.id);
   }
 
+  registerCommandBarSearchProvider(
+    pluginId: string,
+    provider: CommandBarSearchProvider,
+    items = this.getOrCreatePluginItems(pluginId),
+  ): () => void {
+    setUnique(this.commandBarSearchProvidersMap, provider.id, provider);
+    this.commandBarSearchProviderOwners.set(provider.id, pluginId);
+    items.commandBarSearchProviders.push(provider.id);
+    return () => {
+      // Only the registration still in place may be withdrawn: a re-registered
+      // provider under the same id belongs to whoever registered it last.
+      if (this.commandBarSearchProvidersMap.get(provider.id) !== provider) return;
+      this.commandBarSearchProvidersMap.delete(provider.id);
+      this.commandBarSearchProviderOwners.delete(provider.id);
+      items.commandBarSearchProviders = items.commandBarSearchProviders.filter((id) => id !== provider.id);
+    };
+  }
+
   registerColumn(_pluginId: string, column: CustomColumnDef, items: PluginItems): void {
     setUnique(this.columnsMap, column.id, column);
     items.columns.push(column.id);
@@ -158,6 +181,10 @@ export class RegistryContributions {
       this.commandsMap.delete(commandId);
       this.commandOwners.delete(commandId);
     }
+    for (const providerId of items.commandBarSearchProviders) {
+      this.commandBarSearchProvidersMap.delete(providerId);
+      this.commandBarSearchProviderOwners.delete(providerId);
+    }
     for (const columnId of items.columns) this.columnsMap.delete(columnId);
     for (const brokerId of items.brokers) this.brokersMap.delete(brokerId);
     for (const capabilityId of items.capabilities) this.capabilityOwners.delete(capabilityId);

package/src/plugins/registry/index.test.ts

@@ -317,6 +317,31 @@ describe("PluginRegistry ticker research tabs", () => {
   });
 });
 
+describe("PluginRegistry command bar search providers", () => {
+  test("withdraws providers on dispose and on plugin unregister", async () => {
+    const registry = createRegistry();
+    const provider = (id: string) => ({
+      id,
+      category: "Documents",
+      provide: async () => [],
+    });
+    let disposeSelfRegistered: (() => void) | null = null;
+
+    await registry.register(plugin("research-search", (ctx) => {
+      ctx.registerCommandBarSearchProvider(provider("documents"));
+      disposeSelfRegistered = ctx.registerCommandBarSearchProvider(provider("self-withdrawn"));
+    }));
+
+    expect(registry.getCommandBarSearchProviderPluginId("documents")).toBe("research-search");
+    disposeSelfRegistered!();
+    expect(registry.commandBarSearchProviders.has("self-withdrawn")).toBe(false);
+
+    registry.unregister("research-search");
+    expect(registry.commandBarSearchProviders.size).toBe(0);
+    expect(registry.getCommandBarSearchProviderPluginId("documents")).toBeUndefined();
+  });
+});
+
 describe("PluginRegistry pane settings", () => {
   test("resolves effective pane setting values from settings definitions", async () => {
     const registry = createRegistry();

package/src/plugins/registry/index.ts

@@ -19,6 +19,7 @@ import type {
   AppNotificationDelivery,
   AppNotificationRequest,
   BrokerInstanceUpdateOptions,
+  CommandBarSearchProvider,
   CommandDef,
   CustomColumnDef,
   GloomPlugin,
@@ -258,6 +259,9 @@ export class PluginRegistry implements PluginRuntimeAccess {
   get panes(): ReadonlyMap<string, PaneDef> { return this.contributions.panesMap; }
   get paneTemplates(): ReadonlyMap<string, PaneTemplateDef> { return this.contributions.paneTemplatesMap; }
   get commands(): ReadonlyMap<string, CommandDef> { return this.contributions.commandsMap; }
+  get commandBarSearchProviders(): ReadonlyMap<string, CommandBarSearchProvider> {
+    return this.contributions.commandBarSearchProvidersMap;
+  }
   get columns(): ReadonlyMap<string, CustomColumnDef> { return this.contributions.columnsMap; }
   get brokers(): ReadonlyMap<string, BrokerAdapter> { return this.contributions.brokersMap; }
   get tickerResearchTabs(): ReadonlyMap<string, TickerResearchTabDef> { return this.contributions.tickerResearchTabsMap; }
@@ -430,6 +434,10 @@ export class PluginRegistry implements PluginRuntimeAccess {
     return this.contributions.commandOwners.get(commandId);
   }
 
+  getCommandBarSearchProviderPluginId(providerId: string): string | undefined {
+    return this.contributions.commandBarSearchProviderOwners.get(providerId);
+  }
+
   getPanePluginId(paneId: string): string | undefined {
     return this.contributions.paneOwners.get(paneId);
   }