gloomberb 0.11.3 → 0.12.0

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

@@ -0,0 +1,31 @@
+import type { PluginModule } from "../plugin-module";
+import { PluginMarketplacePane, PLUGIN_MARKETPLACE_PANE_ID } from "./pane";
+
+export { PLUGIN_MARKETPLACE_PANE_ID } from "./pane";
+export { setMarketplaceHost } from "./store";
+
+export const pluginMarketplaceModule: PluginModule = {
+  panes: [
+    {
+      id: PLUGIN_MARKETPLACE_PANE_ID,
+      name: "Plugins",
+      icon: "P",
+      component: PluginMarketplacePane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 118, height: 34 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "plugin-marketplace-pane",
+      paneId: PLUGIN_MARKETPLACE_PANE_ID,
+      label: "Plugins",
+      description: "Browse and install Gloomberb plugins, and enable or disable the ones you have.",
+      keywords: ["plugin", "plugins", "marketplace", "install", "extend", "addon", "extension"],
+      shortcut: { prefix: "PL" },
+      createInstance: () => ({ placement: "floating" }),
+    },
+  ],
+};

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

@@ -0,0 +1,200 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  collectCategories,
+  isInstallable,
+  mergeCatalog,
+  sortEntries,
+  unsupportedLabel,
+  type InstalledPlugin,
+  type RegistryPlugin,
+} from "./model";
+
+function registryPlugin(overrides: Partial<RegistryPlugin> & Pick<RegistryPlugin, "id">): RegistryPlugin {
+  return {
+    name: overrides.id,
+    repo: `gloom-sh/${overrides.id}`,
+    tagline: "",
+    author: { name: "Someone" },
+    categories: ["data"],
+    targets: ["cli", "tui", "desktop", "web"],
+    hosts: [],
+    contributes: { panes: [], capabilities: [], broker: false },
+    tier: "community",
+    bundled: false,
+    stars: 0,
+    ...overrides,
+  };
+}
+
+function installedPlugin(overrides: Partial<InstalledPlugin> & Pick<InstalledPlugin, "id">): InstalledPlugin {
+  return {
+    name: overrides.id,
+    version: "1.0.0",
+    toggleable: true,
+    enabled: true,
+    source: "external",
+    ...overrides,
+  };
+}
+
+/**
+ * The merge is the only real logic in this pane, and it reconciles three
+ * sources that disagree during normal use. Each case below is a state a user
+ * can actually reach, and getting one wrong either hides a plugin they have
+ * installed or offers an install button for something already present.
+ */
+describe("mergeCatalog", () => {
+  test("marks a bundled plugin installed even when the local catalog has not reported it", () => {
+    // Happens whenever the feed ships an entry before the user upgrades.
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "gloomberb-cloud", bundled: true, tier: "official" })],
+      installed: [],
+      target: "tui",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.enabled).toBe(true);
+  });
+
+  test("takes enabled state from the local catalog, not the registry", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [installedPlugin({ id: "hackernews", enabled: false, version: "0.2.0" })],
+      target: "tui",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.enabled).toBe(false);
+    expect(entry?.installedVersion).toBe("0.2.0");
+  });
+
+  test("keeps a side-loaded plugin the registry has never seen", () => {
+    const entries = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [installedPlugin({ id: "my-private-plugin" })],
+      target: "tui",
+    });
+
+    const sideloaded = entries.find((entry) => entry.id === "my-private-plugin");
+    expect(sideloaded?.installed).toBe(true);
+    expect(sideloaded?.categories).toEqual(["unlisted"]);
+  });
+
+  test("flags a plugin the current renderer cannot run without calling it uninstalled", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "ibkr-gateway", targets: ["cli", "tui", "desktop"] })],
+      installed: [installedPlugin({ id: "ibkr-gateway" })],
+      target: "web",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.unsupportedHere).toBe(true);
+    expect(unsupportedLabel(entry!)).toBe("Desktop only");
+  });
+
+  test("does not flag a plugin that supports the current renderer", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [],
+      target: "web",
+    });
+
+    expect(entry?.unsupportedHere).toBe(false);
+    expect(unsupportedLabel(entry!)).toBeNull();
+  });
+
+  test("surfaces a load error so a broken install is visible rather than missing", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "broken" })],
+      installed: [installedPlugin({ id: "broken", loadError: "SyntaxError" })],
+      target: "tui",
+    });
+
+    expect(entry?.loadError).toBe("SyntaxError");
+  });
+});
+
+describe("sortEntries", () => {
+  test("puts what is installed above the rest of the catalog", () => {
+    // One list rather than two tabs: acting on what you already have should not
+    // require a mode switch, and an uninstalled plugin should never outrank one
+    // that is present just because it has more stars.
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "popular-uninstalled", tier: "official", stars: 5000 }),
+        registryPlugin({ id: "quiet-installed", tier: "community", stars: 0 }),
+      ],
+      installed: [installedPlugin({ id: "quiet-installed" })],
+      target: "tui",
+    });
+
+    expect(sortEntries(entries).map((entry) => entry.id))
+      .toEqual(["quiet-installed", "popular-uninstalled"]);
+  });
+
+  test("puts the featured plugin first, then tier, then stars", () => {
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "community-popular", tier: "community", stars: 900 }),
+        registryPlugin({ id: "official-quiet", tier: "official", stars: 2 }),
+        registryPlugin({ id: "cloud", tier: "official", featured: true, bundled: true, stars: 0 }),
+        registryPlugin({ id: "verified-mid", tier: "verified", stars: 50 }),
+      ],
+      installed: [],
+      target: "tui",
+    });
+
+    // All uninstalled, so the curated order applies within that half.
+    expect(sortEntries(entries).map((entry) => entry.id)).toEqual([
+      "cloud",
+      "official-quiet",
+      "verified-mid",
+      "community-popular",
+    ]);
+  });
+});
+
+describe("collectCategories", () => {
+  test("deduplicates and sorts categories across the catalog", () => {
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "a", categories: ["news", "data"] }),
+        registryPlugin({ id: "b", categories: ["data"] }),
+      ],
+      installed: [],
+      target: "tui",
+    });
+
+    expect(collectCategories(entries)).toEqual(["data", "news"]);
+  });
+});
+
+describe("isInstallable", () => {
+  test("offers an install only for a catalog plugin that is absent", () => {
+    const [available, bundled, installed] = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "available" }),
+        registryPlugin({ id: "bundled", bundled: true }),
+        registryPlugin({ id: "installed" }),
+      ],
+      installed: [installedPlugin({ id: "installed" })],
+      target: "tui",
+    });
+
+    expect(isInstallable(available!)).toBe(true);
+    // Ships with the app; there is nothing to fetch.
+    expect(isInstallable(bundled!)).toBe(false);
+    expect(isInstallable(installed!)).toBe(false);
+  });
+
+  test("does not offer an install without a repository to clone", () => {
+    const [entry] = mergeCatalog({
+      registry: [],
+      installed: [installedPlugin({ id: "sideloaded" })],
+      target: "tui",
+    });
+
+    expect(isInstallable(entry!)).toBe(false);
+  });
+});

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";
+}