gloomberb 0.11.2 → 0.12.0

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

@@ -0,0 +1,204 @@
+import type { PluginTarget } from "../../../types/plugin";
+
+export type PluginTier = "official" | "verified" | "community";
+
+/** One record from https://plugins.gloom.sh/registry.json. */
+export interface RegistryPlugin {
+  id: string;
+  name: string;
+  tagline: string;
+  description?: string;
+  repo?: string;
+  ref?: string;
+  commit?: string;
+  author: { name: string; github?: string };
+  categories: string[];
+  targets: PluginTarget[];
+  hosts: string[];
+  contributes: { panes: string[]; capabilities: string[]; broker: boolean };
+  minGloomberb?: string;
+  tier: PluginTier;
+  bundled: boolean;
+  featured?: boolean;
+  stars: number;
+  updatedAt?: string;
+  readme?: string;
+}
+
+export interface RegistryFeed {
+  version: number;
+  generatedAt: string;
+  plugins: RegistryPlugin[];
+}
+
+/** What the app knows about a plugin it has actually loaded. */
+export interface InstalledPlugin {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  toggleable: boolean;
+  enabled: boolean;
+  source: "builtin" | "external";
+  /** Set when the plugin is installed but cannot run on this renderer. */
+  unsupportedTarget?: PluginTarget;
+  loadError?: string;
+}
+
+export interface MarketplaceEntry {
+  id: string;
+  name: string;
+  tagline: string;
+  description?: string;
+  categories: string[];
+  tier: PluginTier;
+  targets: PluginTarget[];
+  hosts: string[];
+  repo?: string;
+  stars: number;
+  featured: boolean;
+  /** Ships inside Gloomberb; there is nothing to install or remove. */
+  bundled: boolean;
+  installed: boolean;
+  enabled: boolean;
+  toggleable: boolean;
+  installedVersion?: string;
+  /** The registry's tag, when the plugin is installable. */
+  availableVersion?: string;
+  contributes?: RegistryPlugin["contributes"];
+  loadError?: string;
+  /**
+   * The plugin cannot run on the current renderer — IBKR Gateway in a browser,
+   * for example. Distinct from "not installed": the user may have it installed
+   * and working elsewhere.
+   */
+  unsupportedHere: boolean;
+}
+
+const TIER_RANK: Record<PluginTier, number> = { official: 0, verified: 1, community: 2 };
+
+/**
+ * Merges the remote catalog with what is actually loaded.
+ *
+ * Three sources disagree in normal operation and all three matter: the registry
+ * knows about plugins the user has not installed, the app knows about plugins
+ * the registry has never heard of (installed straight from a git URL), and a
+ * plugin can be installed but inert because this renderer cannot run it. The
+ * merge keeps all three visible rather than showing whichever list is handy.
+ */
+export function mergeCatalog(options: {
+  registry: readonly RegistryPlugin[];
+  installed: readonly InstalledPlugin[];
+  target: PluginTarget;
+}): MarketplaceEntry[] {
+  const { registry, installed, target } = options;
+  const installedById = new Map(installed.map((entry) => [entry.id, entry]));
+  const entries: MarketplaceEntry[] = [];
+
+  for (const plugin of registry) {
+    const local = installedById.get(plugin.id);
+    installedById.delete(plugin.id);
+
+    entries.push({
+      id: plugin.id,
+      name: plugin.name,
+      tagline: plugin.tagline,
+      description: plugin.description,
+      categories: plugin.categories,
+      tier: plugin.tier,
+      targets: plugin.targets,
+      hosts: plugin.hosts,
+      repo: plugin.repo,
+      stars: plugin.stars,
+      featured: plugin.featured === true,
+      bundled: plugin.bundled,
+      // A bundled plugin is present whether or not the local catalog reports it,
+      // which matters when the feed is newer than the running build.
+      installed: plugin.bundled || !!local,
+      enabled: local ? local.enabled : plugin.bundled,
+      toggleable: local ? local.toggleable : true,
+      installedVersion: local?.version,
+      availableVersion: plugin.ref,
+      contributes: plugin.contributes,
+      loadError: local?.loadError,
+      unsupportedHere: !plugin.targets.includes(target),
+    });
+  }
+
+  // Installed but unlisted: side-loaded from a git URL, or listed under a
+  // different id. Still needs to be manageable.
+  for (const local of installedById.values()) {
+    entries.push({
+      id: local.id,
+      name: local.name,
+      tagline: local.description ?? "Installed outside the registry",
+      description: local.description,
+      categories: ["unlisted"],
+      tier: "community",
+      targets: local.unsupportedTarget ? [] : [target],
+      hosts: [],
+      stars: 0,
+      featured: false,
+      bundled: local.source === "builtin",
+      installed: true,
+      enabled: local.enabled,
+      toggleable: local.toggleable,
+      installedVersion: local.version,
+      loadError: local.loadError,
+      unsupportedHere: !!local.unsupportedTarget,
+    });
+  }
+
+  return entries;
+}
+
+/**
+ * One ordered list rather than an installed/available split.
+ *
+ * What you already have is what you act on most, so it sorts to the top; the
+ * rest of the catalog continues below without a mode switch to find it. Within
+ * each half the order is the curated one: featured, then tier, then stars.
+ */
+export function sortEntries(entries: readonly MarketplaceEntry[]): MarketplaceEntry[] {
+  return [...entries].sort((a, b) => {
+    if (a.installed !== b.installed) return a.installed ? -1 : 1;
+    if (a.featured !== b.featured) return a.featured ? -1 : 1;
+    if (a.tier !== b.tier) return TIER_RANK[a.tier] - TIER_RANK[b.tier];
+    if (a.stars !== b.stars) return b.stars - a.stars;
+    return a.name.localeCompare(b.name);
+  });
+}
+
+export function filterEntries(
+  entries: readonly MarketplaceEntry[],
+  options: { query: string; category: string | null },
+): MarketplaceEntry[] {
+  const query = options.query.trim().toLowerCase();
+
+  return entries.filter((entry) => {
+    if (options.category && !entry.categories.includes(options.category)) return false;
+    if (!query) return true;
+    return [entry.name, entry.id, entry.tagline, entry.description, ...entry.categories]
+      .some((field) => typeof field === "string" && field.toLowerCase().includes(query));
+  });
+}
+
+export function collectCategories(entries: readonly MarketplaceEntry[]): string[] {
+  const seen = new Set<string>();
+  for (const entry of entries) {
+    for (const category of entry.categories) seen.add(category);
+  }
+  return [...seen].sort();
+}
+
+/** Whether this entry can be installed from inside the app right now. */
+export function isInstallable(entry: MarketplaceEntry): boolean {
+  return !entry.installed && !entry.bundled && !!entry.repo;
+}
+
+/** Short label for a plugin that cannot run on the current renderer. */
+export function unsupportedLabel(entry: MarketplaceEntry): string | null {
+  if (!entry.unsupportedHere) return null;
+  if (entry.targets.length === 0) return "Unavailable here";
+  return entry.targets.includes("desktop") ? "Desktop only" : "Terminal only";
+}

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.test.ts

@@ -19,8 +19,7 @@ describe("composeBuiltinPlugin", () => {
   test("combines every declarative contribution under the parent plugin", async () => {
     const registeredBrokers: string[] = [];
     const first: PluginModule = {
-      cliCommands: [{ name: "legacy", description: "Legacy", execute: () => {} }],
-      cli: { commands: [{ name: "typed", summary: "Typed" }] },
+      cliCommands: [{ name: "example", description: "Example", execute: () => {} }],
       panes: [{ id: "one", name: "One", component: () => null, defaultPosition: "right" }],
       paneTemplates: [{ id: "one-pane", paneId: "one", label: "One", description: "One" }],
       capabilities: [{ id: "capability-one" } as never],
@@ -40,8 +39,7 @@ describe("composeBuiltinPlugin", () => {
       modules: [first, second],
     });
 
-    expect(plugin.cliCommands?.map((command) => command.name)).toEqual(["legacy"]);
-    expect(plugin.cli?.commands?.map((command) => command.name)).toEqual(["typed"]);
+    expect(plugin.cliCommands?.map((command) => command.name)).toEqual(["example"]);
     expect(plugin.panes?.map((pane) => pane.id)).toEqual(["one", "two"]);
     expect(plugin.paneTemplates?.map((template) => template.id)).toEqual(["one-pane"]);
     expect(plugin.capabilities?.map((capability) => capability.id)).toEqual(["capability-one"]);