gloomberb 0.9.9 → 0.10.0

package/src/cli/commands/automation.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+import type { PiCatalog, PiProviderSummary } from "../../plugins/builtin/ai/pi";
+import type { AiProviderId } from "../../plugins/builtin/ai/providers";
+import { createDefaultConfig } from "../../types/config";
+import type { CliCommandContext } from "../../types/plugin";
+import { createAiCliCommand } from "./automation";
+
+function piProvider(
+  id: AiProviderId,
+  connection: PiProviderSummary["connection"],
+): PiProviderSummary {
+  return {
+    id,
+    label: id,
+    name: id,
+    authMethods: [],
+    connection,
+    models: [],
+  };
+}
+
+function createHarness(options: {
+  catalog: PiCatalog;
+  configuredProviderId?: string;
+  configuredModelId?: string;
+  response?: string;
+}) {
+  const config = createDefaultConfig("/tmp/gloomberb-ai-cli");
+  config.pluginConfig.ai = {
+    ...(options.configuredProviderId
+      ? { defaultProviderId: options.configuredProviderId }
+      : {}),
+    ...(options.configuredModelId
+      ? { defaultModelId: options.configuredModelId }
+      : {}),
+  };
+  const output: unknown[] = [];
+  const runs: Array<{ providerId: string; modelId?: string; prompt: string }> = [];
+  let closed = 0;
+  let runtimeDataDir = "";
+  const command = createAiCliCommand({
+    createRuntime(dataDir) {
+      runtimeDataDir = dataDir;
+      return {
+        getCatalog: async () => options.catalog,
+        runText(request) {
+          runs.push(request);
+          return {
+            done: Promise.resolve(options.response ?? "answer"),
+            cancel() {},
+          };
+        },
+      };
+    },
+  });
+  const context = {
+    initConfigData: async () => ({
+      config,
+      dataDir: config.dataDir,
+      persistence: { close: () => { closed += 1; } },
+      store: {},
+    }),
+    printResult: (result: { data: unknown }) => { output.push(result.data); },
+    fail(message: string): never {
+      throw new Error(message);
+    },
+  } as unknown as CliCommandContext;
+
+  return {
+    command,
+    context,
+    output,
+    runs,
+    closed: () => closed,
+    runtimeDataDir: () => runtimeDataDir,
+  };
+}
+
+describe("headless Pi AI command", () => {
+  test("lists canonical Pi providers and their connection state", async () => {
+    const harness = createHarness({
+      catalog: {
+        providers: [
+          piProvider("anthropic", {
+            state: "connected",
+            type: "oauth",
+            source: "Claude Pro/Max",
+            origin: "stored",
+            disconnectable: true,
+          }),
+          piProvider("openai-codex", { state: "not_connected" }),
+        ],
+        refreshErrors: {},
+      },
+    });
+
+    await harness.command.execute(["providers"], harness.context);
+
+    expect(harness.runtimeDataDir()).toBe("/tmp/gloomberb-ai-cli");
+    expect(harness.output[0]).toEqual([
+      {
+        id: "anthropic",
+        name: "anthropic",
+        connectionState: "connected",
+        connectionSource: "Claude Pro/Max",
+        connectionError: "",
+        availableModels: 0,
+      },
+      {
+        id: "openai-codex",
+        name: "openai-codex",
+        connectionState: "not_connected",
+        connectionSource: "",
+        connectionError: "",
+        availableModels: 0,
+      },
+    ]);
+    expect(harness.closed()).toBe(1);
+  });
+
+  test("uses the configured connected provider and model through Pi", async () => {
+    const harness = createHarness({
+      catalog: {
+        providers: [
+          piProvider("google", {
+            state: "connected",
+            type: "oauth",
+            origin: "stored",
+            disconnectable: true,
+          }),
+          piProvider("anthropic", {
+            state: "connected",
+            type: "oauth",
+            origin: "stored",
+            disconnectable: true,
+          }),
+        ],
+        refreshErrors: {},
+      },
+      configuredProviderId: "claude",
+      configuredModelId: "claude-opus-4-8",
+      response: "Pi answer",
+    });
+
+    await harness.command.execute(["ask", "Explain", "cash", "flow"], harness.context);
+
+    expect(harness.runs).toEqual([{
+      providerId: "anthropic",
+      modelId: "claude-opus-4-8",
+      prompt: "Explain cash flow",
+    }]);
+    expect(harness.output[0]).toEqual({
+      provider: "anthropic",
+      model: "claude-opus-4-8",
+      text: "Pi answer",
+    });
+    expect(harness.closed()).toBe(1);
+  });
+
+  test("supports explicit canonicalized overrides and rejects disconnected accounts", async () => {
+    const connected = createHarness({
+      catalog: {
+        providers: [piProvider("google", {
+          state: "connected",
+          type: "oauth",
+          origin: "stored",
+          disconnectable: true,
+        })],
+        refreshErrors: {},
+      },
+    });
+
+    await connected.command.execute([
+      "ask",
+      "--provider",
+      "gemini",
+      "--model",
+      "gemini-2.5-pro",
+      "Find",
+      "compounders",
+    ], connected.context);
+
+    expect(connected.runs).toEqual([{
+      providerId: "google",
+      modelId: "gemini-2.5-pro",
+      prompt: "Find compounders",
+    }]);
+
+    const disconnected = createHarness({
+      catalog: {
+        providers: [piProvider("anthropic", { state: "not_connected" })],
+        refreshErrors: {},
+      },
+    });
+    await expect(disconnected.command.execute(
+      ["ask", "--provider", "claude", "Hello"],
+      disconnected.context,
+    )).rejects.toThrow("is not connected");
+    expect(disconnected.runs).toEqual([]);
+    expect(disconnected.closed()).toBe(1);
+  });
+});

package/src/cli/commands/automation.ts

@@ -1,5 +1,13 @@
-import { detectProviders, getAiProvider } from "../../plugins/builtin/ai/providers";
-import { runAiPrompt } from "../../plugins/builtin/ai/runner";
+import {
+  PiAiRuntime,
+  type PiCatalog,
+  type PiTextRunController,
+} from "../../plugins/builtin/ai/pi";
+import {
+  isAiProviderId,
+  migrateLegacyAiProviderId,
+  type AiProviderId,
+} from "../../plugins/builtin/ai/providers";
 import { createRssNewsCapability } from "../../plugins/builtin/news/wire/rss/source";
 import type { CliCommandDef } from "../../types/plugin";
 import { requireArg, takeOption } from "./command-utils";
@@ -84,42 +92,151 @@ export const ibkrCliCommand: CliCommandDef = {
   },
 };
 
-export const aiCliCommand: CliCommandDef = {
-  name: "ai",
-  description: "Inspect AI providers and run guarded headless AI prompts",
-  help: { usage: ["ai providers", "ai ask [--provider id] <prompt>", "ai screen list|show|delete|refresh|export"] },
-  execute: async (args, ctx) => {
-    const action = args[0] ?? "providers";
-    if (action === "providers") {
-      ctx.printResult({ data: detectProviders().map((provider) => ({
-        id: provider.id,
-        name: provider.name,
-        command: provider.command,
-        available: provider.available,
-      })) });
-      return;
-    }
-    if (action === "ask") {
+interface HeadlessPiRuntime {
+  getCatalog(): Promise<PiCatalog>;
+  runText(options: {
+    providerId: AiProviderId;
+    modelId?: string;
+    prompt: string;
+  }): PiTextRunController;
+}
+
+interface CreateAiCliCommandOptions {
+  createRuntime?: (dataDir: string) => HeadlessPiRuntime;
+}
+
+function configuredAiSelection(config: Record<string, unknown> | undefined): {
+  providerId: AiProviderId | null;
+  modelId: string | null;
+} {
+  const rawProviderId = typeof config?.defaultProviderId === "string"
+    ? config.defaultProviderId.trim()
+    : "";
+  const providerId = migrateLegacyAiProviderId(rawProviderId);
+  const modelId = typeof config?.defaultModelId === "string"
+    ? config.defaultModelId.trim()
+    : "";
+  return {
+    providerId: isAiProviderId(providerId) ? providerId : null,
+    modelId: modelId || null,
+  };
+}
+
+function connectionFailure(provider: PiCatalog["providers"][number]): string {
+  if (provider.connection.state === "error") {
+    return `${provider.label} could not connect: ${provider.connection.message}`;
+  }
+  return `${provider.label} is not connected. Connect it from AI pane settings first.`;
+}
+
+export function createAiCliCommand(options: CreateAiCliCommandOptions = {}): CliCommandDef {
+  const createRuntime = options.createRuntime ?? ((dataDir: string) => new PiAiRuntime({ dataDir }));
+  return {
+    name: "ai",
+    description: "Inspect AI providers and run guarded headless AI prompts",
+    help: {
+      usage: [
+        "ai providers",
+        "ai ask [--provider id] [--model id] <prompt>",
+        "ai screen list|show|delete|refresh|export",
+      ],
+    },
+    execute: async (args, ctx) => {
+      const action = args[0] ?? "providers";
+      if (action === "screen") {
+        ctx.printResult({
+          data: deferredResult("ai screen", "not_implemented", "AI screener tabs are still pane-state backed; expose them through a shared non-UI screener store before headless mutation."),
+        });
+        return;
+      }
+      if (action !== "providers" && action !== "ask") {
+        ctx.fail("Usage: gloomberb ai providers|ask|screen");
+      }
+
       const rawArgs = args.slice(1);
-      const providerId = takeOption(rawArgs, "--provider") ?? detectProviders().find((provider) => provider.available)?.id;
-      const selectedProvider = getAiProvider(providerId) ?? ctx.fail("Unknown AI provider.");
-      if (!selectedProvider.available) ctx.fail(`${selectedProvider.name} is not installed or not available in PATH.`);
+      const requestedProvider = takeOption(rawArgs, "--provider")?.trim();
+      const requestedModel = takeOption(rawArgs, "--model")?.trim();
       const prompt = rawArgs.join(" ").trim();
-      if (!prompt) ctx.fail("Usage: gloomberb ai ask [--provider id] <prompt>");
-      const controller = runAiPrompt({ provider: selectedProvider, prompt, cwd: process.cwd() });
-      const text = await controller.done;
-      ctx.printResult({ data: { provider: selectedProvider.id, text } });
-      return;
-    }
-    if (action === "screen") {
-      ctx.printResult({
-        data: deferredResult("ai screen", "not_implemented", "AI screener tabs are still pane-state backed; expose them through a shared non-UI screener store before headless mutation."),
-      });
-      return;
-    }
-    ctx.fail("Usage: gloomberb ai providers|ask|screen");
-  },
-};
+      if (action === "ask" && !prompt) {
+        ctx.fail("Usage: gloomberb ai ask [--provider id] [--model id] <prompt>");
+      }
+
+      const context = await ctx.initConfigData();
+      try {
+        const runtime = createRuntime(context.dataDir);
+        const catalog = await runtime.getCatalog();
+        if (action === "providers") {
+          ctx.printResult({
+            data: catalog.providers.map((provider) => ({
+              id: provider.id,
+              name: provider.label,
+              connectionState: provider.connection.state,
+              connectionSource: provider.connection.state === "connected"
+                ? provider.connection.source ?? ""
+                : "",
+              connectionError: provider.connection.state === "error"
+                ? provider.connection.message
+                : "",
+              availableModels: provider.models.filter((model) => model.available).length,
+            })),
+          });
+          return;
+        }
+
+        const configured = configuredAiSelection(context.config.pluginConfig.ai);
+        const canonicalRequestedId = requestedProvider
+          ? migrateLegacyAiProviderId(requestedProvider)
+          : null;
+        const requestedProviderId = canonicalRequestedId && isAiProviderId(canonicalRequestedId)
+          ? canonicalRequestedId
+          : null;
+        const requested = requestedProviderId
+          ? catalog.providers.find((provider) => provider.id === requestedProviderId)
+          : null;
+        if (requestedProvider && (!requestedProviderId || !requested)) {
+          ctx.fail(`Unknown AI provider: ${requestedProvider}.`);
+        }
+
+        const configuredProvider = configured.providerId
+          ? catalog.providers.find((provider) => (
+            provider.id === configured.providerId
+            && provider.connection.state === "connected"
+          ))
+          : null;
+        const selected = requested
+          ?? configuredProvider
+          ?? catalog.providers.find((provider) => provider.connection.state === "connected");
+        if (!selected) {
+          ctx.fail("No AI provider is connected. Connect an account from AI pane settings first.");
+          throw new Error("AI provider selection failed.");
+        }
+        if (selected.connection.state !== "connected") {
+          ctx.fail(connectionFailure(selected));
+        }
+
+        const modelId = requestedModel
+          || (selected.id === configured.providerId ? configured.modelId : null)
+          || undefined;
+        const text = await runtime.runText({
+          providerId: selected.id,
+          modelId,
+          prompt,
+        }).done;
+        ctx.printResult({
+          data: {
+            provider: selected.id,
+            model: modelId ?? null,
+            text,
+          },
+        });
+      } finally {
+        context.persistence.close();
+      }
+    },
+  };
+}
+
+export const aiCliCommand = createAiCliCommand();
 
 export const rssCliCommand: CliCommandDef = {
   name: "rss",

package/src/cli/commands/market.ts

@@ -466,20 +466,7 @@ async function runEarnings(rawArgs: string[], ctx: Parameters<CliCommandDef["exe
   if (symbols.length === 0) ctx.fail("Usage: gloomberb earnings <symbol...>");
   const services = await ctx.initServices();
   try {
-    let events: EarningsEvent[] = [];
-    for (const { capability } of services.services.pluginRegistry.capabilities.list("asset-data")) {
-      if (!capability.operations.getEarningsCalendar?.handler) continue;
-      try {
-        events = await services.services.pluginRegistry.capabilities.invoke<EarningsEvent[]>(
-          capability.id,
-          "getEarningsCalendar",
-          { symbols },
-        );
-      } catch {
-        continue;
-      }
-      if (events.length > 0) break;
-    }
+    const events = await services.dataProvider.getEarningsCalendar(symbols);
     ctx.printResult({ data: events }, {
       rows: earningsRows,
       columns: [

package/src/cli/commands/system.ts

@@ -242,6 +242,9 @@ export function createSystemCliCommands(allCommands: () => CliCommandDef[]): Cli
         }
         if (action === "enable" || action === "disable") {
           const id = requireArg(args[1], `Usage: gloomberb plugin ${action} <id>`, ctx);
+          const plugin = services.services.pluginRegistry.allPlugins.get(id);
+          if (!plugin) ctx.fail(`Plugin "${id}" is not available.`);
+          if (plugin?.toggleable !== true) ctx.fail(`Plugin "${id}" is part of the application and cannot be disabled.`);
           const disabled = new Set(services.config.disabledPlugins ?? []);
           const before = disabled.has(id);
           if (action === "enable") disabled.delete(id);
@@ -291,7 +294,7 @@ export function createSystemCliCommands(allCommands: () => CliCommandDef[]): Cli
             kind: "pane",
             id,
             name: pane.name,
-            owner: "",
+            owner: services.services.pluginRegistry.getPanePluginId(id) ?? "",
           })),
           ...[...services.services.pluginRegistry.paneTemplates.entries()].map(([id, template]) => ({
             kind: "template",

package/src/cli/context.ts

@@ -80,7 +80,7 @@ export async function initCliServices(options: CliServicesOptions = {}) {
   const config = await loadConfig(dataDir);
   const services = createAppServices({
     config,
-    externalPlugins: options.externalPlugins ?? [],
+    plugins: getLoadablePlugins(options.externalPlugins ?? []),
   });
   services.providerRouter.setConfigAccessor(() => config);
   await services.ready;

package/src/cli/desktop-pane-shot.ts

@@ -6,6 +6,8 @@ import type { AppConfig } from "../types/config";
 import type { OptionsChain, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import type { PaneRuntimeState } from "../core/state/app/state";
+import type { RemoteUiNodeSnapshot } from "../remote/types";
+import type { FredSeriesCacheEntry } from "../data/fred-series";
 import {
   electrobunViewPath,
   writeElectrobunViewPage,
@@ -21,9 +23,17 @@ export interface DesktopPaneShotPayload {
   tickers: TickerRecord[];
   financials: Array<[string, TickerFinancials]>;
   optionsChains: Array<[string, OptionsChain]>;
+  fredSeries: Array<[string, FredSeriesCacheEntry]>;
   paneState: Record<string, PaneRuntimeState>;
 }
 
+export interface DesktopPaneShotRenderResult {
+  visibleText: string;
+  emptyStateDetected: boolean;
+  emptyStateMarkers: string[];
+  semanticUi: RemoteUiNodeSnapshot[];
+}
+
 type CdpResponse = {
   id?: number;
   result?: unknown;
@@ -43,14 +53,14 @@ const SHOT_DEVICE_SCALE_FACTOR = 2;
 export async function renderDesktopPaneScreenshot(
   payload: DesktopPaneShotPayload,
   outputPath: string,
-): Promise<void> {
+): Promise<DesktopPaneShotRenderResult> {
   const tempDir = await mkdtemp(join(tmpdir(), "gloom-pane-shot-"));
   try {
     const outdir = join(tempDir, "assets");
     await mkdir(outdir, { recursive: true });
     const htmlPath = await buildShotPage(outdir, payload);
     const chrome = await findChromeExecutable();
-    await capturePageScreenshot({
+    return await capturePageScreenshot({
       chrome,
       url: pathToFileURL(htmlPath).href,
       outputPath,
@@ -119,7 +129,7 @@ async function capturePageScreenshot({
   widthPx: number;
   heightPx: number;
   userDataDir: string;
-}): Promise<void> {
+}): Promise<DesktopPaneShotRenderResult> {
   await mkdir(userDataDir, { recursive: true });
   const port = 43000 + Math.floor(Math.random() * 10000);
   const proc = Bun.spawn([
@@ -158,13 +168,15 @@ async function capturePageScreenshot({
       mobile: false,
     });
     await waitForShotReady(session);
+    const rendered = await readRenderedPaneState(session);
     const screenshot = await session.send("Page.captureScreenshot", {
       format: "png",
       fromSurface: true,
       captureBeyondViewport: false,
     }) as { data?: string };
     if (!screenshot.data) throw new Error("Chrome did not return screenshot data.");
-    await writeFile(outputPath, Buffer.from(screenshot.data, "base64"));
+    await writeFile(outputPath, Uint8Array.from(Buffer.from(screenshot.data, "base64")));
+    return rendered;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(message);
@@ -175,6 +187,55 @@ async function capturePageScreenshot({
   }
 }
 
+const EMPTY_STATE_PATTERNS = [
+  /\bNo chart data\b/gi,
+  /\bNo graph data\b/gi,
+  /\bNo historical prices\b/gi,
+  /\bNo financial statement rows\b/gi,
+  /\bNo comparison tickers configured\b/gi,
+  /\bNo relationship tickers configured\b/gi,
+  /\bNo overlapping price history\b/gi,
+  /\bLoading chart\.{0,3}\b/gi,
+  /\bRendering pane\.{0,3}\b/gi,
+  /\bNo tickers selected\b/gi,
+  /\bMarket data unavailable\b/gi,
+  /\bNo data(?: available)?\b/gi,
+];
+
+async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneShotRenderResult> {
+  const result = await session.send("Runtime.evaluate", {
+    expression: `(() => {
+      const root = document.getElementById("root") || document.body;
+      return {
+        visibleText: root.innerText || root.textContent || "",
+        error: window.__GLOOM_CLI_SHOT_ERROR__ || "",
+        semanticUi: window.__GLOOM_CLI_SHOT_SEMANTIC_UI__ || [],
+      };
+    })()`,
+    returnByValue: true,
+  }) as {
+    result?: {
+      value?: {
+        visibleText?: string;
+        error?: string;
+        semanticUi?: RemoteUiNodeSnapshot[];
+      };
+    };
+  };
+  const value = result.result?.value;
+  if (value?.error) throw new Error(value.error);
+  const visibleText = (value?.visibleText ?? "").replace(/\s+/g, " ").trim();
+  const emptyStateMarkers = [...new Set(EMPTY_STATE_PATTERNS.flatMap((pattern) => (
+    [...visibleText.matchAll(pattern)].map((match) => match[0])
+  )))];
+  return {
+    visibleText,
+    emptyStateDetected: emptyStateMarkers.length > 0,
+    emptyStateMarkers,
+    semanticUi: Array.isArray(value?.semanticUi) ? value.semanticUi : [],
+  };
+}
+
 async function waitForPageWebSocket(port: number, targetUrl: string): Promise<string> {
   for (let attempt = 0; attempt < CHROME_POLL_ATTEMPTS; attempt += 1) {
     try {

package/src/cli/entry.ts

@@ -23,7 +23,7 @@ export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise
 
   if (command === OPEN_TUI_NATIVE_SMOKE_COMMAND) {
     await smokeOpenTuiNative();
-    return;
+    process.exit(0);
   }
 
   const externalPlugins = await loadExternalPlugins();