gloomberb 0.12.0 → 0.13.2

package/src/plugins/builtin/yield-curve/headless.ts

@@ -0,0 +1,67 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import {
+  curveAsOf,
+  isInverted,
+  loadYieldCurve,
+  parseYieldPoints,
+  spreadBasisPoints,
+  type YieldCurveLoader,
+  type YieldPoint,
+} from "./treasury-data";
+
+const COLUMNS = [
+  { key: "maturity", header: "Maturity" },
+  {
+    key: "maturityYears",
+    header: "Years",
+    align: "right" as const,
+    format: (value: unknown) => Number(value).toFixed(2).replace(/\.00$/, ""),
+  },
+  {
+    key: "yield",
+    header: "Yield",
+    align: "right" as const,
+    format: (value: unknown) => value == null ? "-" : `${Number(value).toFixed(2)}%`,
+  },
+  { key: "asOf", header: "As of" },
+];
+
+export interface YieldCurveHeadlessDependencies {
+  load(args: HeadlessPaneLoadArgs, loader: YieldCurveLoader): Promise<YieldPoint[]>;
+}
+
+const defaultDependencies: YieldCurveHeadlessDependencies = {
+  load: (_args, loader) => loadYieldCurve(loader),
+};
+
+export function createYieldCurveHeadless(
+  dependencies: YieldCurveHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: { kind: "none" },
+    options: [],
+    columns: COLUMNS,
+    describe: "US Treasury Yield Curve",
+    async load(args, ctx) {
+      const points = await dependencies.load(
+        args,
+        () => ctx.apiClient.getCloudYieldCurve(),
+      );
+      const rows = parseYieldPoints(points);
+      return {
+        rows: rows.map((point) => ({ ...point })),
+        metadata: {
+          asOf: curveAsOf(points),
+          inverted: isInverted(points),
+          spread2Y10YBasisPoints: spreadBasisPoints(points),
+        },
+      };
+    },
+  };
+}
+
+export const yieldCurveHeadless = createYieldCurveHeadless();

package/src/plugins/builtin/yield-curve/index.tsx

@@ -12,11 +12,15 @@ import {
   loadYieldCurve,
   parseYieldPoints,
   isInverted,
+  spreadBasisPoints,
   TREASURY_MATURITIES,
   type YieldPoint,
 } from "./treasury-data";
 import { usePaneStatusFooter } from "../shared/pane-footer";
 import { useAutoRefresh, useUpdatedAgo } from "../shared/auto-refresh";
+import { yieldCurveHeadless } from "./headless";
+
+export { yieldCurveHeadless } from "./headless";
 
 function formatYield(y: number | null): string {
   if (y == null) return "—";
@@ -27,13 +31,6 @@ function formatYieldAxis(value: number): string {
   return `${value.toFixed(2)}%`;
 }
 
-function spreadBp(points: YieldPoint[]): number | null {
-  const y2 = points.find((p) => p.maturity === "2Y")?.yield;
-  const y10 = points.find((p) => p.maturity === "10Y")?.yield;
-  if (y2 == null || y10 == null) return null;
-  return Math.round((y10 - y2) * 100);
-}
-
 function YieldCurvePane({ focused, width, height }: PaneProps) {
   const [points, setPoints] = useState<YieldPoint[]>([]);
   const [loading, setLoading] = useState(false);
@@ -75,7 +72,7 @@ function YieldCurvePane({ focused, width, height }: PaneProps) {
   });
 
   const inverted = isInverted(points);
-  const bp = spreadBp(points);
+  const bp = spreadBasisPoints(points);
   // Treasury series are daily closes, so which session the curve represents is
   // status the user needs; "updated Xm ago" only says when we last fetched it.
   const asOf = curveAsOf(points);
@@ -191,5 +188,6 @@ export const yieldCurveModule: PluginModule = {
     description: "US Treasury yield curve charted from FRED data.",
     keywords: ["yield", "curve", "treasury", "bonds", "rates", "gc", "interest"],
     shortcut: { prefix: "GC" },
+    headless: yieldCurveHeadless,
   }],
 };

package/src/plugins/builtin/yield-curve/treasury-data.ts

@@ -20,8 +20,12 @@ export const TREASURY_MATURITIES: Array<{ maturity: string; years: number; serie
   { maturity: "30Y", years: 30,    seriesId: "DGS30" },
 ];
 
-export async function loadYieldCurve(): Promise<YieldPoint[]> {
-  return apiClient.getCloudYieldCurve();
+export type YieldCurveLoader = () => Promise<YieldPoint[]>;
+
+export async function loadYieldCurve(
+  loader: YieldCurveLoader = () => apiClient.getCloudYieldCurve(),
+): Promise<YieldPoint[]> {
+  return loader();
 }
 
 export function parseYieldPoints(points: YieldPoint[]): YieldPoint[] {
@@ -45,8 +49,14 @@ export function curveAsOf(points: readonly YieldPoint[]): string | null {
   return latest;
 }
 
-export function isInverted(points: YieldPoint[]): boolean {
-  const y2 = points.find((p) => p.maturity === "2Y")?.yield;
-  const y10 = points.find((p) => p.maturity === "10Y")?.yield;
-  return y2 != null && y10 != null && y2 > y10;
+export function spreadBasisPoints(points: readonly YieldPoint[]): number | null {
+  const y2 = points.find((point) => point.maturity === "2Y")?.yield;
+  const y10 = points.find((point) => point.maturity === "10Y")?.yield;
+  if (y2 == null || y10 == null) return null;
+  return Math.round((y10 - y2) * 100);
+}
+
+export function isInverted(points: readonly YieldPoint[]): boolean {
+  const spread = spreadBasisPoints(points);
+  return spread != null && spread < 0;
 }

package/src/plugins/bundle.test.ts

@@ -22,7 +22,13 @@ function scratchPlugin(source: string): string {
 }
 
 const fakeExports = async (specifier: string) => (
-  specifier === "gloomberb/ui" ? ["Box", "Text"] : specifier === "react" ? ["useState"] : []
+  specifier === "gloomberb/ui"
+    ? ["Box", "Text"]
+    : specifier === "react"
+      ? ["useState"]
+      : specifier === "gloomberb/broker"
+        ? ["PRESERVED_PASSWORD_HINT", "getBrokerRemoteClient"]
+        : []
 );
 
 describe("buildSharedModuleSource", () => {
@@ -97,6 +103,57 @@ describe("bundleExternalPlugin", () => {
     }
   });
 
+  test("shares gloomberb/broker rather than bundling the host's copy", async () => {
+    // That module owns the remote broker client the desktop view installs at
+    // startup. A plugin carrying its own copy reads an empty one and reports
+    // that the broker host is unavailable, which looks like a broken broker
+    // rather than a bundling mistake.
+    const dir = scratchPlugin(`
+      import { PRESERVED_PASSWORD_HINT } from "gloomberb/broker";
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", hint: PRESERVED_PASSWORD_HINT };
+    `);
+    try {
+      const result = await bundleExternalPlugin(dir, join(dir, "out"), { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(result.shared).toEqual(["gloomberb/broker"]);
+      expect(code).toContain(PLUGIN_HOST_GLOBAL);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("compiles the browser entry so a plugin with a native half still loads", async () => {
+    // Bun's browser target rejects `node:*` imports even behind a dynamic
+    // import, so without this a broker that opens a socket or resolves DNS
+    // could not ship to the desktop view at all.
+    const dir = mkdtempSync(join(tmpdir(), "gloom-bundle-browser-"));
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "scratch", main: "index.ts", browser: "index.browser.ts" }),
+    );
+    writeFileSync(join(dir, "native.ts"), `
+      import { Socket } from "node:net";
+      export const connect = () => new Socket();
+    `);
+    writeFileSync(join(dir, "index.ts"), `
+      export default { id: "scratch", name: "Scratch", version: "1.0.0", load: () => import("./native") };
+    `);
+    writeFileSync(join(dir, "index.browser.ts"), `
+      export default { id: "scratch", name: "Scratch", version: "1.0.0" };
+    `);
+    const out = join(dir, "out");
+    try {
+      const result = await bundleExternalPlugin(dir, out, { exportNamesFor: fakeExports });
+      const code = await Bun.file(result.outputPath).text();
+
+      expect(code).toContain("Scratch");
+      expect(code).not.toContain("node:net");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   test("rejects a directory with no entry file", async () => {
     const dir = mkdtempSync(join(tmpdir(), "gloom-bundle-empty-"));
     mkdirSync(join(dir, "src"), { recursive: true });

package/src/plugins/bundle.ts

@@ -1,7 +1,7 @@
 import { mkdir } from "fs/promises";
 import { join } from "path";
 
-import { resolvePluginEntry } from "./loader";
+import { resolvePluginBrowserEntry } from "./loader";
 import { PLUGIN_HOST_GLOBAL, SHARED_SPECIFIERS } from "./host-contract";
 
 /**
@@ -98,7 +98,9 @@ export async function bundleExternalPlugin(
   outDir: string,
   options: { exportNamesFor?: (specifier: string) => Promise<readonly string[]> } = {},
 ): Promise<BundlePluginResult> {
-  const entry = await resolvePluginEntry(pluginDir);
+  // The browser entry when the plugin ships one, so a plugin with a native
+  // half can still present its UI and metadata in the view.
+  const entry = await resolvePluginBrowserEntry(pluginDir);
   if (!entry) throw new Error(`No plugin entry file in ${pluginDir}`);
 
   await mkdir(outDir, { recursive: true });

package/src/plugins/catalog-backend.test.ts

@@ -18,4 +18,30 @@ describe("desktop backend plugin catalog", () => {
       expect(plugin?.slots).toBeUndefined();
     }
   });
+
+  test("includes compatible external plugins in the native desktop backend", () => {
+    const externalPlugin = {
+      id: "external-broker",
+      name: "External broker",
+      version: "1.0.0",
+      targets: ["cli", "tui", "desktop"] as const,
+    };
+    const backendPlugins = getDesktopBackendPlugins([
+      { plugin: externalPlugin, path: "/plugins/external-broker" },
+      {
+        plugin: { id: "broken", name: "Broken", version: "1.0.0" },
+        path: "/plugins/broken",
+        error: "load failed",
+      },
+      {
+        plugin: { id: "web-only", name: "Web only", version: "1.0.0" },
+        path: "/plugins/web-only",
+        unsupportedTarget: "desktop",
+      },
+    ]);
+
+    expect(backendPlugins).toContain(externalPlugin);
+    expect(backendPlugins.some((plugin) => plugin.id === "broken")).toBe(false);
+    expect(backendPlugins.some((plugin) => plugin.id === "web-only")).toBe(false);
+  });
 });

package/src/plugins/catalog-backend.ts

@@ -1,12 +1,19 @@
 import type { GloomPlugin } from "../types/plugin";
 import { tickerResearchBackendPlugin } from "./builtin/ticker-research-backend-plugin";
 import { getLoadablePlugins } from "./catalog";
+import { loadExternalPlugins, type LoadedExternalPlugin } from "./loader";
 import { predictionMarketsBackendPlugin } from "./prediction-markets/backend-plugin";
 
-export function getDesktopBackendPlugins(): GloomPlugin[] {
-  return getLoadablePlugins().map((plugin) => {
+export function getDesktopBackendPlugins(
+  externalPlugins: LoadedExternalPlugin[] = [],
+): GloomPlugin[] {
+  return getLoadablePlugins(externalPlugins).map((plugin) => {
     if (plugin.id === "ticker-research") return tickerResearchBackendPlugin;
     if (plugin.id === "prediction-markets") return predictionMarketsBackendPlugin;
     return plugin;
   });
 }
+
+export async function loadDesktopBackendPlugins(): Promise<GloomPlugin[]> {
+  return getDesktopBackendPlugins(await loadExternalPlugins("desktop"));
+}

package/src/plugins/catalog-browser.test.ts

@@ -7,19 +7,6 @@ const paneIds = browserBuiltinPlugins.flatMap((plugin) => plugin.panes?.map((pan
 const templateIds = new Set(browserBuiltinPlugins.flatMap((plugin) => plugin.paneTemplates?.map((template) => template.id) ?? []));
 
 describe("browser plugin catalog", () => {
-  test("contains the reviewed cloud, local, market, and research plugins", () => {
-    expect(ids).toEqual([
-      "gloomberb-cloud",
-      "portfolio",
-      "ticker-research",
-      "application",
-      "news",
-      "market-overview",
-      "macro",
-      "alerts",
-    ]);
-  });
-
   test("excludes native, filesystem, local AI, debug, updater, and external plugins", () => {
     for (const forbidden of [
       "broker",

package/src/plugins/catalog-browser.ts

@@ -4,6 +4,8 @@ import {
 } from "../data/fred-series";
 import type { GloomPlugin } from "../types/plugin";
 import { portfolioAnalyticsModule } from "./builtin/analytics";
+import { earningsCallsModule } from "./builtin/earnings-calls";
+import { researchSearchPlugin } from "./builtin/research-search";
 import { alertsPlugin } from "./builtin/alerts";
 import { browserGloomberbCloudPlugin } from "./builtin/cloud/browser";
 import { changelogModule } from "./builtin/changelog";
@@ -68,6 +70,7 @@ const browserTickerResearchPlugin = composeBuiltinPlugin({
     optionsModule,
     optionsCalculatorModule,
     researchModule,
+    earningsCallsModule,
   ],
 });
 
@@ -141,6 +144,7 @@ export const browserBuiltinPlugins: readonly GloomPlugin[] = [
   browserMarketOverviewPlugin,
   browserMacroPlugin,
   alertsPlugin,
+  researchSearchPlugin,
 ];
 
 export function getBrowserBuiltinPlugins(): readonly GloomPlugin[] {

package/src/plugins/catalog-manifest.test.ts

@@ -34,6 +34,21 @@ describe("built-in plugin manifest", () => {
     expect(featured.map((plugin) => plugin.id)).toEqual(["gloomberb-cloud"]);
   });
 
+  test("every declared icon exists in the repo", async () => {
+    // The directory resolves these against this repo's HEAD, so a wrong path
+    // is a broken image in the plugin grid rather than a missing file here.
+    const icons = buildBuiltinManifest()
+      .plugins.map((plugin) => plugin.icon)
+      .filter((icon): icon is string => !!icon);
+
+    expect(icons.length).toBeGreaterThan(0);
+
+    for (const icon of icons) {
+      const file = Bun.file(new URL(`../../${icon}`, import.meta.url));
+      expect(await file.exists()).toBe(true);
+    }
+  });
+
   test("describes what each plugin contributes, which is what the directory renders", () => {
     const cloud = buildBuiltinManifest().plugins.find((plugin) => plugin.id === "gloomberb-cloud");
 

package/src/plugins/catalog-manifest.ts

@@ -18,6 +18,8 @@ export interface BuiltinPluginManifestEntry {
   categories: string[];
   toggleable: boolean;
   featured?: true;
+  /** Path to artwork in this repo, resolved by the directory against HEAD. */
+  icon?: string;
   contributes: {
     panes: string[];
     capabilities: string[];
@@ -30,8 +32,15 @@ export interface BuiltinPluginManifestEntry {
  * is reported by `generate-plugin-manifest.ts` rather than silently defaulted,
  * so a new built-in cannot slip into the directory uncategorised.
  */
-const EDITORIAL: Record<string, { categories: string[]; featured?: true }> = {
-  "gloomberb-cloud": { categories: ["data", "cloud"], featured: true },
+const EDITORIAL: Record<
+  string,
+  { categories: string[]; featured?: true; icon?: string }
+> = {
+  "gloomberb-cloud": {
+    categories: ["data", "cloud"],
+    featured: true,
+    icon: "plugin-icons/gloomberb-cloud.svg",
+  },
   ai: { categories: ["ai"] },
   alerts: { categories: ["alerts"] },
   application: { categories: ["core"] },
@@ -44,10 +53,7 @@ const EDITORIAL: Record<string, { categories: string[]; featured?: true }> = {
   polls: { categories: ["data"] },
   portfolio: { categories: ["portfolio"] },
   "prediction-markets": { categories: ["markets"] },
-  public: { categories: ["broker"] },
   "research-search": { categories: ["research", "news"] },
-  robinhood: { categories: ["broker"] },
-  simplefin: { categories: ["broker"] },
   "ticker-research": { categories: ["research"] },
   yahoo: { categories: ["data"] },
 };
@@ -74,6 +80,7 @@ export function buildBuiltinManifest(): BuiltinManifest {
         categories: editorial?.categories ?? [],
         toggleable: plugin.toggleable === true,
         ...(editorial?.featured ? { featured: true as const } : {}),
+        ...(editorial?.icon ? { icon: editorial.icon } : {}),
         contributes: {
           panes: (plugin.panes ?? []).map((pane) => pane.id).sort(),
           capabilities: (plugin.capabilities ?? [])

package/src/plugins/catalog-ui.ts

@@ -4,9 +4,6 @@ import { newsPlugin } from "./builtin/news";
 import { notesPlugin } from "./builtin/notes";
 import { aiPlugin } from "./builtin/ai";
 import { gloomberbCloudPlugin } from "./builtin/cloud";
-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";
@@ -25,9 +22,6 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   portfolioPlugin,
   tickerResearchPlugin,
   brokerPlugin,
-  publicPlugin,
-  robinhoodPlugin,
-  simpleFinPlugin,
   applicationPlugin,
   newsPlugin,
   notesPlugin,

package/src/plugins/host-contract.ts

@@ -32,6 +32,15 @@ export const SHARED_SPECIFIERS = [
   "gloomberb/capabilities",
   "gloomberb/utils",
   "gloomberb/react",
+  // Modules below hold state or reach the host's services, so a bundled copy
+  // is worse than a missing one. `gloomberb/broker` is the clearest case: it
+  // owns the remote broker client the desktop view sets at startup, and a
+  // plugin carrying its own copy reads an empty one and reports that the
+  // broker host is unavailable.
+  "gloomberb/broker",
+  "gloomberb/dialog",
+  "gloomberb/market-data",
+  "gloomberb/time-series",
 ] as const;
 
 export type SharedSpecifier = (typeof SHARED_SPECIFIERS)[number];

package/src/plugins/host-modules.ts

@@ -24,6 +24,10 @@ export async function installPluginHostModules(): Promise<void> {
     capabilities,
     utils,
     pluginReact,
+    broker,
+    dialog,
+    marketData,
+    timeSeries,
   ] = await Promise.all([
     import("react"),
     import("react/jsx-runtime"),
@@ -37,6 +41,10 @@ export async function installPluginHostModules(): Promise<void> {
     import("../capabilities"),
     import("../public/utils"),
     import("../public/react"),
+    import("../public/broker"),
+    import("../ui/dialog"),
+    import("../public/market-data"),
+    import("../public/time-series"),
   ]);
 
   const registry: Record<string, unknown> = {
@@ -51,6 +59,10 @@ export async function installPluginHostModules(): Promise<void> {
     "gloomberb/capabilities": capabilities,
     "gloomberb/utils": utils,
     "gloomberb/react": pluginReact,
+    "gloomberb/broker": broker,
+    "gloomberb/dialog": dialog,
+    "gloomberb/market-data": marketData,
+    "gloomberb/time-series": timeSeries,
   };
 
   for (const specifier of SHARED_SPECIFIERS) {

package/src/plugins/loader.ts

@@ -9,6 +9,11 @@ import { linkHostPackages } from "./host-link";
 const loaderLog = debugLog.createLogger("plugin-loader");
 
 const PLUGINS_DIR = join(process.env.HOME || homedir(), ".gloomberb", "plugins");
+/**
+ * Host-owned scratch space for plugins, kept beside the plugins folder rather
+ * than inside it so nothing the host writes can be mistaken for an install.
+ */
+const PLUGIN_CACHE_DIR = join(process.env.HOME || homedir(), ".gloomberb", "plugin-cache");
 
 export interface LoadedExternalPlugin {
   plugin: GloomPlugin;
@@ -22,27 +27,70 @@ export function getPluginsDir(): string {
   return PLUGINS_DIR;
 }
 
-/** Resolves a plugin directory's entry file the way `bun install` would. */
-export async function resolvePluginEntry(pluginDir: string): Promise<string | null> {
+export function getPluginCacheDir(): string {
+  return PLUGIN_CACHE_DIR;
+}
+
+/**
+ * Whether a directory inside the plugins folder is a plugin at all.
+ *
+ * Dot-directories are bookkeeping, not plugins: the desktop bundle cache used
+ * to be written to `plugins/.cache`, and it showed up in `gloomberb plugins`
+ * as an installed plugin and in `gloomberb update` as a repo to pull. The
+ * cache has moved out, but old installs still have that directory, so this
+ * stays as the single rule every reader shares.
+ */
+export function isPluginDirectory(name: string): boolean {
+  return !name.startsWith(".");
+}
+
+async function readPluginPackageField(pluginDir: string, field: 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.
-    }
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(await Bun.file(pkgPath).text());
+    const value = pkg[field];
+    if (typeof value !== "string" || !value) return null;
+    const resolved = join(pluginDir, value);
+    return existsSync(resolved) ? resolved : null;
+  } catch {
+    // Malformed package.json falls through to the index candidates.
+    return null;
   }
-  for (const candidate of ["index.ts", "index.tsx", "index.js"]) {
-    const path = join(pluginDir, candidate);
+}
+
+function resolveIndexCandidate(pluginDir: string, prefix: string): string | null {
+  for (const extension of ["ts", "tsx", "js"]) {
+    const path = join(pluginDir, `${prefix}.${extension}`);
     if (existsSync(path)) return path;
   }
   return null;
 }
 
+/** Resolves a plugin directory's entry file the way `bun install` would. */
+export async function resolvePluginEntry(pluginDir: string): Promise<string | null> {
+  return await readPluginPackageField(pluginDir, "main")
+    ?? resolveIndexCandidate(pluginDir, "index");
+}
+
+/**
+ * Resolves the entry to compile for a browser renderer, preferring the standard
+ * `browser` field and falling back to the native entry.
+ *
+ * A plugin that touches sockets, DNS, or the filesystem cannot be compiled for
+ * the desktop view: Bun's browser target rejects `node:*` imports even behind a
+ * dynamic import. The app solves this for its own build with private alias
+ * rules that swap in stubs, which a plugin in its own repository cannot reach.
+ * The `browser` field is that same escape hatch, published: ship a
+ * renderer-safe module with the same plugin metadata and let the native half
+ * run in the Bun process, where the desktop calls it over RPC anyway.
+ */
+export async function resolvePluginBrowserEntry(pluginDir: string): Promise<string | null> {
+  return await readPluginPackageField(pluginDir, "browser")
+    ?? resolveIndexCandidate(pluginDir, "index.browser")
+    ?? await resolvePluginEntry(pluginDir);
+}
+
 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);
@@ -55,7 +103,7 @@ export async function loadExternalPlugins(target: PluginTarget = "cli"): Promise
   const entries = await readdir(PLUGINS_DIR, { withFileTypes: true });
 
   for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
+    if (!entry.isDirectory() || !isPluginDirectory(entry.name)) continue;
     const pluginDir = join(PLUGINS_DIR, entry.name);
 
     const entryFile = await resolvePluginEntry(pluginDir);