gloomberb 0.9.1 → 0.9.3

package/src/cli/commands/ticker.ts

@@ -17,6 +17,7 @@ import type { FinancialStatement, TickerFinancials } from "../../types/financial
 import type { SecFilingItem } from "../../types/data-provider";
 import type { NewsArticle } from "../../news/types";
 import type { TickerRecord } from "../../types/ticker";
+import type { CliCommandContext } from "../../types/plugin";
 import { createBaseConverter } from "../base-converter";
 import { initMarketData } from "../context";
 import { closeAndFail } from "../errors";
@@ -40,6 +41,7 @@ const SEC_FILING_LIMIT = 5;
 interface TickerCommandDependencies {
   initMarketData?: () => Promise<MarketContext>;
   closeAndFail?: typeof closeAndFail;
+  printResult?: CliCommandContext["printResult"];
 }
 
 function appendMetricSection(lines: string[], title: string, metrics: Array<[string, string]>) {
@@ -367,6 +369,78 @@ export async function buildTickerReport({
   return lines.join("\n");
 }
 
+function buildTickerStructuredData({
+  symbol,
+  tickerFile,
+  financials,
+  config,
+  notes,
+  recentNews,
+  recentSecFilings,
+}: {
+  symbol: string;
+  tickerFile: TickerRecord | null;
+  financials: TickerFinancials;
+  config: AppConfig;
+  notes: string;
+  recentNews: NewsArticle[];
+  recentSecFilings: SecFilingItem[];
+}) {
+  const quote = financials.quote;
+  return {
+    symbol,
+    quote: quote ? {
+      symbol: quote.symbol,
+      name: quote.name,
+      price: quote.price,
+      change: quote.change,
+      changePercent: quote.changePercent,
+      currency: quote.currency,
+      marketCap: quote.marketCap ?? null,
+      volume: quote.volume ?? null,
+      exchangeName: quote.exchangeName ?? "",
+      fullExchangeName: quote.fullExchangeName ?? "",
+      marketState: quote.marketState ?? "",
+      dataSource: quote.dataSource ?? "",
+      providerId: quote.providerId ?? "",
+      lastUpdated: quote.lastUpdated ? new Date(quote.lastUpdated).toISOString() : "",
+    } : null,
+    ticker: tickerFile ? {
+      ticker: tickerFile.metadata.ticker,
+      name: tickerFile.metadata.name ?? "",
+      exchange: tickerFile.metadata.exchange ?? "",
+      assetCategory: tickerFile.metadata.assetCategory ?? "",
+      sector: tickerFile.metadata.sector ?? "",
+      industry: tickerFile.metadata.industry ?? "",
+      portfolios: formatPortfolioNames(config, tickerFile.metadata.portfolios),
+      watchlists: formatWatchlistNames(config, tickerFile.metadata.watchlists),
+      positions: tickerFile.metadata.positions,
+    } : null,
+    fundamentals: financials.fundamentals,
+    profile: financials.profile,
+    latestAnnual: financials.annualStatements.at(-1) ?? null,
+    latestQuarter: financials.quarterlyStatements.at(-1) ?? null,
+    annualStatementCount: financials.annualStatements.length,
+    quarterlyStatementCount: financials.quarterlyStatements.length,
+    notes,
+    recentNews: recentNews.map((item) => ({
+      title: item.title,
+      source: item.source,
+      publishedAt: item.publishedAt instanceof Date ? item.publishedAt.toISOString() : item.publishedAt,
+      url: item.url,
+      summary: item.summary ?? "",
+    })),
+    recentSecFilings: recentSecFilings.map((filing) => ({
+      form: filing.form,
+      filingDate: filing.filingDate instanceof Date ? filing.filingDate.toISOString() : filing.filingDate,
+      accessionNumber: filing.accessionNumber,
+      filingUrl: filing.filingUrl,
+      primaryDocumentUrl: filing.primaryDocumentUrl ?? "",
+      description: getFilingDescription(filing) ?? "",
+    })),
+  };
+}
+
 export async function ticker(symbol: string, dependencies: TickerCommandDependencies = {}) {
   const initMarketDataFn = dependencies.initMarketData ?? initMarketData;
   const closeAndFailCommand = dependencies.closeAndFail ?? closeAndFail;
@@ -379,8 +453,12 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
   let financials: TickerFinancials | null = null;
   try {
     financials = await dataProvider.getTickerFinancials(normalized, exchange);
-  } catch (err: any) {
-    closeAndFailCommand(persistence, `Failed to fetch data for ${normalized}.`, err?.message);
+  } catch (error) {
+    closeAndFailCommand(
+      persistence,
+      `Failed to fetch data for ${normalized}.`,
+      error instanceof Error ? error.message : String(error),
+    );
   }
 
   if (!financials?.quote) {
@@ -409,16 +487,30 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
   const recentNews = newsResult.status === "fulfilled" ? newsResult.value : [];
   const recentSecFilings = secFilingsResult.status === "fulfilled" ? secFilingsResult.value : [];
 
-  console.log(await buildTickerReport({
-    symbol: normalized,
-    tickerFile,
-    financials: resolvedFinancials,
-    config,
-    toBase,
-    notes,
-    recentNews,
-    recentSecFilings,
-  }));
+  if (dependencies.printResult) {
+    dependencies.printResult({
+      data: buildTickerStructuredData({
+        symbol: normalized,
+        tickerFile,
+        financials: resolvedFinancials,
+        config,
+        notes,
+        recentNews,
+        recentSecFilings,
+      }),
+    });
+  } else {
+    console.log(await buildTickerReport({
+      symbol: normalized,
+      tickerFile,
+      financials: resolvedFinancials,
+      config,
+      toBase,
+      notes,
+      recentNews,
+      recentSecFilings,
+    }));
+  }
 
   persistence.close();
 }

package/src/cli/context.ts

@@ -4,10 +4,13 @@ import { getDataDir, loadConfig } from "../data/config/store";
 import { AppPersistence } from "../data/app-persistence";
 import { TickerRepository } from "../data/ticker-repository";
 import { AssetDataRouter } from "../sources/provider-router";
+import { createAppServices } from "../core/app-services";
 import type { PluginCapability } from "../capabilities";
 import type { AppConfig } from "../types/config";
 import type { GloomPlugin } from "../types/plugin";
 import { getLoadablePlugins } from "../plugins/catalog";
+import type { PluginRegistry } from "../plugins/registry";
+import type { LoadedExternalPlugin } from "../plugins/loader";
 import { fail } from "./errors";
 import type { ConfigContext, MarketContext } from "./types";
 
@@ -15,6 +18,10 @@ interface CliContextOptions {
   plugins?: GloomPlugin[];
 }
 
+interface CliServicesOptions {
+  externalPlugins?: LoadedExternalPlugin[];
+}
+
 function resolveCliCapabilities(config: AppConfig, plugins: GloomPlugin[]): PluginCapability[] {
   const disabledPlugins = new Set(config.disabledPlugins ?? []);
   const disabledSources = new Set(config.disabledSources ?? []);
@@ -55,9 +62,35 @@ export async function initMarketData(options: CliContextOptions = {}): Promise<M
   const plugins = options.plugins ?? getLoadablePlugins();
   const capabilities = resolveCliCapabilities(context.config, plugins);
   const dataProvider = new AssetDataRouter(null, [], context.persistence.resources);
-  dataProvider.attachRegistry({
+  const registryAdapter: Pick<PluginRegistry, "brokers" | "getEnabledCapabilities"> = {
     brokers: new Map(),
     getEnabledCapabilities: (kind?: string) => capabilities.filter((capability) => !kind || capability.kind === kind),
-  } as any);
+  };
+  dataProvider.attachRegistry(registryAdapter as PluginRegistry);
+  dataProvider.setConfigAccessor(() => context.config);
   return { ...context, dataProvider };
 }
+
+export async function initCliServices(options: CliServicesOptions = {}) {
+  const dataDir = await getDataDir();
+  if (!dataDir || !existsSync(dataDir)) {
+    fail("No data directory configured.", "Run gloomberb once to initialize your local data.");
+  }
+
+  const config = await loadConfig(dataDir);
+  const services = createAppServices({
+    config,
+    externalPlugins: options.externalPlugins ?? [],
+  });
+  services.providerRouter.setConfigAccessor(() => config);
+  await services.ready;
+  return {
+    config,
+    dataDir,
+    services,
+    dataProvider: services.providerRouter,
+    persistence: services.persistence,
+    store: services.tickerRepository,
+    destroy: () => services.destroy(),
+  };
+}

package/src/cli/entry.ts

@@ -0,0 +1,51 @@
+import { dispatchCli } from "./index";
+import { fail, inferCliErrorOptions, printCliError } from "./errors";
+import { loadExternalPlugins } from "../plugins/loader";
+import type { CliLaunchRequest } from "../types/plugin";
+
+async function launchOpenTuiApp(options: {
+  externalPlugins: Awaited<ReturnType<typeof loadExternalPlugins>>;
+  cliLaunchRequest?: CliLaunchRequest | null;
+  cliArgs?: string[];
+}): Promise<void> {
+  const { startOpenTuiApp } = await import("../renderers/opentui/start");
+  await startOpenTuiApp({
+    externalPlugins: options.externalPlugins,
+    cliArgs: options.cliArgs ?? [],
+    skipCliDispatch: true,
+    cliLaunchRequest: options.cliLaunchRequest ?? null,
+  });
+}
+
+export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise<void> {
+  const externalPlugins = await loadExternalPlugins();
+  const command = rawArgs[0];
+
+  if (!command) {
+    await launchOpenTuiApp({ externalPlugins });
+    return;
+  }
+
+  if (command === "launch-ui" || command === "ui") {
+    await launchOpenTuiApp({ externalPlugins, cliArgs: rawArgs.slice(1) });
+    return;
+  }
+
+  const dispatchResult = await dispatchCli(rawArgs, { externalPlugins });
+  if (dispatchResult.kind === "handled") return;
+  if (dispatchResult.kind === "launch-ui") {
+    await launchOpenTuiApp({
+      externalPlugins,
+      cliLaunchRequest: dispatchResult.request,
+      cliArgs: [],
+    });
+    return;
+  }
+
+  fail(`Unknown command "${command}".`, "Run gloomberb help to list available commands.");
+}
+
+runCliEntrypoint().catch((error) => {
+  printCliError(error, inferCliErrorOptions(process.argv.slice(2)));
+  process.exitCode = 1;
+});

package/src/cli/errors.ts

@@ -1,13 +1,64 @@
-import { cliStyles } from "../utils/cli-output";
 import type { AppPersistence } from "../data/app-persistence";
+import { DEFAULT_CLI_OPTIONS, type CliGlobalOptions } from "./options";
+import { serializeCliError, type CliErrorObject } from "./result";
 
-export function fail(message: string, details?: string): never {
-  console.error(cliStyles.danger(message));
-  if (details) console.error(cliStyles.muted(details));
-  process.exit(1);
+export class CliFailure extends Error {
+  readonly code: string;
+  readonly details?: unknown;
+  readonly retryable?: boolean;
+
+  constructor(message: string, details?: unknown, code = "cli_error", retryable?: boolean) {
+    super(message);
+    this.name = "CliFailure";
+    this.code = code;
+    this.details = details;
+    this.retryable = retryable;
+  }
+}
+
+export function fail(message: string, details?: unknown, code?: string): never {
+  throw new CliFailure(message, details, code);
 }
 
 export function closeAndFail(persistence: AppPersistence, message: string, details?: string): never {
   persistence.close();
   fail(message, details);
 }
+
+export function isCliFailure(error: unknown): error is CliFailure {
+  return error instanceof CliFailure;
+}
+
+export function cliErrorObject(error: unknown): CliErrorObject {
+  if (isCliFailure(error)) {
+    return {
+      code: error.code,
+      message: error.message,
+      details: error.details,
+      retryable: error.retryable,
+    };
+  }
+  return {
+    code: "unexpected_error",
+    message: error instanceof Error ? error.message : String(error),
+  };
+}
+
+export function inferCliErrorOptions(rawArgs: string[]): CliGlobalOptions {
+  const options: CliGlobalOptions = { ...DEFAULT_CLI_OPTIONS };
+  for (const arg of rawArgs) {
+    if (arg === "--") break;
+    if (arg === "--json") options.format = "json";
+    if (arg === "--csv") options.format = "csv";
+    if (arg === "--ndjson") options.format = "ndjson";
+    if (arg === "--quiet" || arg === "-q") options.quiet = true;
+    if (arg === "--no-color") options.color = false;
+    if (arg === "--color") options.color = true;
+  }
+  return options;
+}
+
+export function printCliError(error: unknown, options: CliGlobalOptions): void {
+  if (options.quiet && options.format === "text") return;
+  console.error(serializeCliError(cliErrorObject(error), options));
+}

package/src/cli/index.ts

@@ -1,7 +1,8 @@
 import { VERSION } from "../version";
-import type { CliCommandDef, CliDispatchResult } from "../types/plugin";
+import type { CliCommandDef, CliDispatchResult, CliLaunchRequest } from "../types/plugin";
 import type { LoadedExternalPlugin } from "../plugins/loader";
 import { loadCliConfigIfAvailable } from "./context";
+import { parseCliGlobalArgs } from "./options";
 import {
   buildCliCommandRegistry,
   createCliCommandContext,
@@ -10,9 +11,21 @@ import {
   renderCliHelp,
   type CliCommandRegistry,
 } from "./registry";
-import { fail } from "./errors";
+import { fail, inferCliErrorOptions, printCliError } from "./errors";
+import { setCliColorEnabledOverride } from "../utils/cli-output";
 import { search, searchCandidatesForCli, buildSearchReport } from "./commands/search";
 import { ticker, buildTickerReport } from "./commands/ticker";
+import { apiCliCommand } from "./commands/api";
+import { marketDataCliCommands } from "./commands/market";
+import { overviewCliCommands } from "./commands/overview";
+import { createSystemCliCommands } from "./commands/system";
+import {
+  aiCliCommand,
+  brokerCliCommand,
+  cloudCliCommands,
+  ibkrCliCommand,
+  rssCliCommand,
+} from "./commands/automation";
 import {
   installPlugin,
   listPlugins,
@@ -22,7 +35,11 @@ import {
 import { runPaneCatalog, runPaneFunction, runPaneScreenshot } from "./pane-functions";
 
 function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
-  return [
+  let commands: CliCommandDef[] = [];
+  const launchUiRequest: CliLaunchRequest = {
+    applyConfig: (config) => ({ config }),
+  };
+  commands = [
     {
       name: "help",
       aliases: ["--help", "-h"],
@@ -30,10 +47,28 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
       help: {
         usage: ["help"],
       },
-      execute: () => {
-        console.log(renderHelp());
+      execute: (_args, ctx) => {
+        if (ctx.cliOptions.format === "text") {
+          console.log(renderHelp());
+          return;
+        }
+        ctx.printResult({ data: commands.map((command) => ({
+          name: command.name,
+          aliases: command.aliases ?? [],
+          description: command.description,
+          usage: command.help?.usage ?? [],
+        })) });
       },
     },
+    {
+      name: "launch-ui",
+      aliases: ["ui"],
+      description: "Launch the terminal UI explicitly",
+      help: {
+        usage: ["launch-ui"],
+      },
+      execute: () => ({ kind: "launch-ui", request: launchUiRequest }),
+    },
     {
       name: "search",
       description: "Search tickers and company names",
@@ -45,6 +80,7 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
         await search(query, {
           initMarketData: ctx.initMarketData,
           fail: ctx.fail,
+          ...(ctx.cliOptions.format === "text" ? {} : { printResult: ctx.printResult }),
         });
       },
     },
@@ -62,6 +98,7 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
         await ticker(symbol!, {
           initMarketData: ctx.initMarketData,
           closeAndFail: ctx.closeAndFail,
+          ...(ctx.cliOptions.format === "text" ? {} : { printResult: ctx.printResult }),
         });
       },
     },
@@ -148,7 +185,17 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
         listPlugins();
       },
     },
+    apiCliCommand,
+    ...marketDataCliCommands,
+    ...overviewCliCommands,
+    ...createSystemCliCommands(() => commands),
+    brokerCliCommand,
+    ibkrCliCommand,
+    aiCliCommand,
+    rssCliCommand,
+    ...cloudCliCommands,
   ];
+  return commands;
 }
 
 export interface DispatchCliOptions {
@@ -170,7 +217,16 @@ async function createRegistry(options: DispatchCliOptions = {}): Promise<CliComm
 export { buildSearchReport, buildTickerReport, searchCandidatesForCli };
 
 export async function dispatchCli(args: string[], options: DispatchCliOptions = {}): Promise<CliDispatchResult> {
-  const command = args[0];
+  let parsed;
+  try {
+    parsed = parseCliGlobalArgs(args);
+  } catch (error) {
+    printCliError(error, inferCliErrorOptions(args));
+    process.exitCode = 1;
+    return { kind: "handled" };
+  }
+  setCliColorEnabledOverride(parsed.options.color);
+  const command = parsed.args[0];
   if (!command) {
     return { kind: "unhandled" };
   }
@@ -181,11 +237,17 @@ export async function dispatchCli(args: string[], options: DispatchCliOptions =
     return { kind: "unhandled" };
   }
 
-  const result = await resolved.command.execute(
-    args.slice(1),
-    createCliCommandContext(resolved.ownerId, registry.plugins),
-  );
-  return normalizeCliDispatchResult(result);
+  try {
+    const result = await resolved.command.execute(
+      parsed.args.slice(1),
+      createCliCommandContext(resolved.ownerId, registry, parsed.options),
+    );
+    return normalizeCliDispatchResult(result);
+  } catch (error) {
+    printCliError(error, parsed.options);
+    process.exitCode = 1;
+    return { kind: "handled" };
+  }
 }
 
 export async function runCli(args: string[], options: DispatchCliOptions = {}): Promise<boolean> {

package/src/cli/options.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { parseCliGlobalArgs } from "./options";
+
+describe("parseCliGlobalArgs", () => {
+  test("extracts global output and execution flags anywhere before --", () => {
+    const parsed = parseCliGlobalArgs([
+      "quote",
+      "--json",
+      "AAPL",
+      "--limit",
+      "2",
+      "--refresh",
+      "--dry-run",
+      "--yes",
+      "--no-color",
+    ]);
+
+    expect(parsed.args).toEqual(["quote", "AAPL"]);
+    expect(parsed.options).toMatchObject({
+      format: "json",
+      limit: 2,
+      refresh: true,
+      dryRun: true,
+      yes: true,
+      color: false,
+    });
+  });
+
+  test("leaves arguments after -- untouched", () => {
+    const parsed = parseCliGlobalArgs(["ai", "ask", "--", "--json"]);
+    expect(parsed.args).toEqual(["ai", "ask", "--json"]);
+    expect(parsed.options.format).toBe("text");
+  });
+
+  test("rejects invalid limits", () => {
+    expect(() => parseCliGlobalArgs(["quote", "AAPL", "--limit=0"])).toThrow("--limit");
+  });
+});

package/src/cli/options.ts

@@ -0,0 +1,95 @@
+export type CliOutputFormat = "text" | "json" | "csv" | "ndjson";
+
+export interface CliGlobalOptions {
+  format: CliOutputFormat;
+  quiet: boolean;
+  color: boolean | null;
+  limit?: number;
+  refresh: boolean;
+  dryRun: boolean;
+  yes: boolean;
+}
+
+export interface ParsedCliArgs {
+  args: string[];
+  options: CliGlobalOptions;
+}
+
+export const DEFAULT_CLI_OPTIONS: CliGlobalOptions = {
+  format: "text",
+  quiet: false,
+  color: null,
+  refresh: false,
+  dryRun: false,
+  yes: false,
+};
+
+function parseLimit(value: string | undefined): number {
+  if (!value) throw new Error("Missing value for --limit.");
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error("--limit must be a positive integer.");
+  }
+  return parsed;
+}
+
+export function parseCliGlobalArgs(rawArgs: string[]): ParsedCliArgs {
+  const options: CliGlobalOptions = { ...DEFAULT_CLI_OPTIONS };
+  const args: string[] = [];
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index]!;
+    if (arg === "--") {
+      args.push(...rawArgs.slice(index + 1));
+      break;
+    }
+    if (arg === "--json") {
+      options.format = "json";
+      continue;
+    }
+    if (arg === "--csv") {
+      options.format = "csv";
+      continue;
+    }
+    if (arg === "--ndjson") {
+      options.format = "ndjson";
+      continue;
+    }
+    if (arg === "--quiet" || arg === "-q") {
+      options.quiet = true;
+      continue;
+    }
+    if (arg === "--no-color") {
+      options.color = false;
+      continue;
+    }
+    if (arg === "--color") {
+      options.color = true;
+      continue;
+    }
+    if (arg === "--refresh") {
+      options.refresh = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+      continue;
+    }
+    if (arg === "--limit") {
+      index += 1;
+      options.limit = parseLimit(rawArgs[index]);
+      continue;
+    }
+    if (arg.startsWith("--limit=")) {
+      options.limit = parseLimit(arg.slice("--limit=".length));
+      continue;
+    }
+    args.push(arg);
+  }
+
+  return { args, options };
+}

package/src/cli/pane-functions/index.ts

@@ -76,11 +76,20 @@ export async function runPaneScreenshot(args: string[], ctx: CliCommandContext)
 export async function runPaneCatalog(args: string[], ctx: CliCommandContext) {
   await runPaneCliCommand(ctx, async () => {
     const parsed = parsePaneCatalogArgs(args);
+    const effectiveParsed = {
+      ...parsed,
+      limit: ctx.cliOptions.limit ?? parsed.limit,
+    };
     const context = await ctx.initMarketData();
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
       const entries = await buildPaneCatalogEntries(registry, context);
-      console.log(renderPaneCatalogReport(filterPaneCatalogEntries(entries, parsed.query), parsed));
+      const filtered = filterPaneCatalogEntries(entries, parsed.query);
+      if (ctx.cliOptions.format === "text") {
+        console.log(renderPaneCatalogReport(filtered, effectiveParsed));
+      } else {
+        ctx.printResult({ data: filtered.slice(0, effectiveParsed.limit) });
+      }
     } finally {
       registry.destroy();
       context.persistence.close();

package/src/cli/registry.test.ts

@@ -18,6 +18,7 @@ const originalHome = process.env.HOME;
 
 afterEach(async () => {
   process.env.HOME = originalHome;
+  process.exitCode = 0;
   await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
 });
 
@@ -182,6 +183,45 @@ describe("CLI dispatch", () => {
     expect(stdout).toContain("ok:hello world");
   });
 
+  test("renders plugin command failures through structured output", async () => {
+    process.env.HOME = await createTempHome("gloomberb-cli-registry-failure-home-");
+    const originalExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+      const { result, stderr } = await captureConsole(() => dispatchCli(
+        ["fail-example", "--json"],
+        {
+          externalPlugins: [{
+            plugin: {
+              id: "failing-cli",
+              name: "Failing CLI",
+              version: "1.0.0",
+              cliCommands: [{
+                name: "fail-example",
+                description: "Fail on purpose",
+                execute: (_args, ctx) => ctx.fail("Synthetic failure.", "Synthetic details."),
+              }],
+            },
+            path: "/tmp/failing-cli",
+          }],
+        },
+      ));
+
+      expect(result).toEqual({ kind: "handled" });
+      expect(process.exitCode).toBe(1);
+      expect(JSON.parse(stderr)).toEqual({
+        ok: false,
+        error: {
+          code: "cli_error",
+          message: "Synthetic failure.",
+          details: "Synthetic details.",
+        },
+      });
+    } finally {
+      process.exitCode = originalExitCode ?? 0;
+    }
+  });
+
   test("routes prediction market commands and aliases through launch-ui requests", async () => {
     process.env.HOME = await createTempHome("gloomberb-cli-prediction-home-");