gloomberb 0.9.8 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/api-client/index.test.ts

@@ -415,7 +415,7 @@ describe("apiClient chat timestamps", () => {
       seenCreatedAts.push(message.createdAt);
     });
 
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.message",
       channelId: "everyone",
       data: {
@@ -531,11 +531,11 @@ describe("apiClient chat timestamps", () => {
       seenNotifications.push(`${notification.id}:${notification.message.createdAt}`);
     });
 
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.presence",
       onlineCount: 5,
     }));
-    await (apiClient as any).handleSocketMessage(JSON.stringify({
+    await (apiClient as any).socket.handleSocketMessage(JSON.stringify({
       type: "chat.notification",
       data: {
         id: "n1",

package/src/api-client/index.ts

@@ -39,8 +39,6 @@ import type {
   CloudCongressHousePayload,
   CloudNewsPayload,
   CloudNewsListResponse,
-  CloudTweetPayload,
-  CloudTweetQueryType,
   CloudTweetSearchResponse,
   CloudMarketResponse,
   CloudMarketBatchTarget,
@@ -158,10 +156,6 @@ class GloomApiClient {
     return this.transport.getSocketAuthToken();
   }
 
-  private async handleSocketMessage(raw: string): Promise<void> {
-    await this.socket.handleSocketMessage(raw);
-  }
-
   async ensureVerifiedSession(): Promise<AuthUser | null> {
     return this.auth.ensureVerifiedSession();
   }

package/src/api-client/request.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { CloudApiRequestTransport } from "./request";
+
+function responseWithBody(body: () => Promise<string>): Response {
+  return {
+    ok: true,
+    status: 200,
+    headers: new Headers(),
+    text: body,
+  } as Response;
+}
+
+describe("CloudApiRequestTransport market deadlines", () => {
+  test("aborts when response headers never arrive", async () => {
+    let signal: AbortSignal | null | undefined;
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 10,
+      fetchTransport: async (_url, init) => {
+        signal = init?.signal;
+        return new Promise<Response>(() => {});
+      },
+    });
+
+    await expect(transport.request("/market/quote?symbol=AAPL")).rejects.toThrow(
+      "Cloud market request timed out after 10ms",
+    );
+    expect(signal?.aborted).toBe(true);
+  });
+
+  test("keeps the deadline active while reading the response body", async () => {
+    let signal: AbortSignal | null | undefined;
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 10,
+      fetchTransport: async (_url, init) => {
+        signal = init?.signal;
+        return responseWithBody(async () => new Promise<string>(() => {}));
+      },
+    });
+
+    await expect(transport.request("/market/history?symbol=AAPL")).rejects.toThrow(
+      "Cloud market request timed out after 10ms",
+    );
+    expect(signal?.aborted).toBe(true);
+  });
+
+  test("preserves a caller abort instead of replacing it with the market deadline", async () => {
+    let fetchCalls = 0;
+    const controller = new AbortController();
+    controller.abort(new Error("cancelled by caller"));
+    const transport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 100,
+      fetchTransport: async () => {
+        fetchCalls += 1;
+        return responseWithBody(async () => "{}");
+      },
+    });
+
+    await expect(transport.request("/market/quote?symbol=AAPL", {
+      signal: controller.signal,
+    })).rejects.toThrow("cancelled by caller");
+    expect(fetchCalls).toBe(0);
+  });
+});

package/src/api-client/request.ts

@@ -1,7 +1,9 @@
 import { httpFetch } from "../utils/http-transport";
+import { withDeadline } from "../utils/async-deadline";
 import { ApiRequestError, parseApiErrorMessage } from "./errors";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
+const DEFAULT_MARKET_REQUEST_TIMEOUT_MS = 10_000;
 const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
 
 type CloudApiResponse = Pick<Response, "ok" | "status" | "headers" | "text">;
@@ -21,13 +23,28 @@ function getCloudApiBaseUrl(): string {
   return process.env.GLOOMBERB_API_URL ?? DEFAULT_API_URL;
 }
 
+function throwIfRequestAborted(signal: AbortSignal | null | undefined): void {
+  if (!signal?.aborted) return;
+  throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+
 export class CloudApiRequestTransport {
   private sessionToken: string | null = null;
   private sessionCookieName: SessionCookieName | null = null;
   private websocketToken: string | null = null;
+  private readonly fetchTransport: CloudApiFetchTransport | null;
+  private readonly marketRequestTimeoutMs: number;
 
   readonly baseUrl = getCloudApiBaseUrl();
 
+  constructor(options: {
+    fetchTransport?: CloudApiFetchTransport;
+    marketRequestTimeoutMs?: number;
+  } = {}) {
+    this.fetchTransport = options.fetchTransport ?? null;
+    this.marketRequestTimeoutMs = options.marketRequestTimeoutMs ?? DEFAULT_MARKET_REQUEST_TIMEOUT_MS;
+  }
+
   getSessionToken(): string | null {
     return this.sessionToken;
   }
@@ -61,6 +78,37 @@ export class CloudApiRequestTransport {
   }
 
   async request<T>(path: string, options?: RequestInit): Promise<T> {
+    if (!path.startsWith("/market/")) {
+      return this.performRequest<T>(path, options);
+    }
+
+    const controller = new AbortController();
+    const callerSignal = options?.signal;
+    const abortFromCaller = () => controller.abort(callerSignal?.reason);
+    if (callerSignal?.aborted) {
+      abortFromCaller();
+    } else {
+      callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
+    }
+
+    try {
+      const request = this.performRequest<T>(path, {
+        ...options,
+        signal: controller.signal,
+      });
+      return await withDeadline(
+        request,
+        this.marketRequestTimeoutMs,
+        `Cloud market request timed out after ${this.marketRequestTimeoutMs}ms: ${path}`,
+        (error) => controller.abort(error),
+      );
+    } finally {
+      callerSignal?.removeEventListener("abort", abortFromCaller);
+    }
+  }
+
+  private async performRequest<T>(path: string, options?: RequestInit): Promise<T> {
+    throwIfRequestAborted(options?.signal);
     const headers = new Headers(options?.headers);
     if (!headers.has("Content-Type") && options?.method && options.method !== "GET") {
       headers.set("Content-Type", "application/json");
@@ -68,21 +116,21 @@ export class CloudApiRequestTransport {
     this.setSessionCookieHeader(headers);
     headers.set("Origin", this.baseUrl);
 
-    const res = await cloudApiFetchTransport(`${this.baseUrl}${path}`, {
+    const res = await (this.fetchTransport ?? cloudApiFetchTransport)(`${this.baseUrl}${path}`, {
       ...options,
       headers,
       credentials: "include",
     });
-
+    throwIfRequestAborted(options?.signal);
     this.extractSessionCookie(res);
+    const text = await res.text();
+    throwIfRequestAborted(options?.signal);
 
     if (!res.ok) {
-      const body = await res.text();
-      const msg = parseApiErrorMessage(body);
+      const msg = parseApiErrorMessage(text);
       throw new ApiRequestError(msg, res.status);
     }
 
-    const text = await res.text();
     if (!text) return undefined as T;
     const parsed = JSON.parse(text) as T & { token?: string };
     if (typeof parsed?.token === "string" && parsed.token.length > 0) {

package/src/api-client/types.ts

@@ -6,9 +6,7 @@ import type {
   HolderData,
   HolderRecord,
   OptionsChain,
-  PricePoint,
   Quote,
-  TickerFinancials,
 } from "../types/financials";
 import type { SyncSettings, SyncSnapshot } from "../sync/types";
 

package/src/app/pane-runtime/layout-placement.ts

@@ -1,6 +1,5 @@
 import type { PluginRegistry } from "../../plugins/registry";
 import {
-  findDockLeaf,
   getDockLeafLayouts,
   getLeafRect,
 } from "../../plugins/pane-manager";

package/src/brokers/account-cache.ts

@@ -3,6 +3,7 @@ import type { BrokerAdapter } from "../types/broker";
 import type { BrokerInstanceConfig } from "../types/config";
 import type { CachePolicy } from "../types/persistence";
 import type { BrokerAccount } from "../types/trading";
+import { fnv1aHashString } from "../utils/hash";
 
 const BROKER_ACCOUNT_SNAPSHOT_KIND = "account-snapshot";
 const BROKER_ACCOUNT_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -16,15 +17,6 @@ interface PersistedBrokerAccountSnapshot {
   brokerType?: string;
 }
 
-function hashString(input: string): string {
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return `fnv1a:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-}
-
 function brokerAccountNamespace(instance: BrokerInstanceConfig): string {
   return `plugin:${instance.brokerType}`;
 }
@@ -36,7 +28,7 @@ export function getBrokerAccountCacheSourceKey(
   if (broker?.getAccountCacheSourceKey) {
     return broker.getAccountCacheSourceKey(instance);
   }
-  return hashString(JSON.stringify({
+  return fnv1aHashString(JSON.stringify({
     brokerType: instance.brokerType,
     config: broker?.toConfigValues?.(instance) ?? instance.config,
   }));

package/src/brokers/broker-portfolio-sync.ts

@@ -1,5 +1,4 @@
 import type { AppConfig, BrokerInstanceConfig } from "../types/config";
-import type { BrokerContractRef } from "../types/instrument";
 import type { Portfolio, TickerPosition, TickerRecord } from "../types/ticker";
 import { buildBrokerPortfolioId, getBrokerInstance, isBrokerPortfolioId } from "../utils/broker-instances";
 

package/src/brokers/broker-ticker-sync.ts

@@ -78,29 +78,33 @@ function updateExistingTicker(
   positionEntry: TickerPosition,
   brokerContract?: BrokerContractRef,
 ): TickerRecord {
-  if (position.name && ticker.metadata.name === ticker.metadata.ticker) {
-    ticker.metadata.name = position.name;
-  }
-  if (position.assetCategory && !ticker.metadata.assetCategory) {
-    ticker.metadata.assetCategory = position.assetCategory;
-  }
-  if (position.isin && !ticker.metadata.isin) {
-    ticker.metadata.isin = position.isin;
-  }
-
   const otherPositions = ticker.metadata.positions.filter(
     (entry) => !(entry.portfolio === portfolioId && entry.broker === instance.brokerType),
   );
-  ticker.metadata.positions = [...otherPositions, positionEntry];
-  ticker.metadata.broker_contracts = mergeBrokerContracts(
+  const brokerContracts = mergeBrokerContracts(
     ticker.metadata.broker_contracts ?? [],
     brokerContract ? [brokerContract] : [],
   );
-  if (!ticker.metadata.portfolios.includes(portfolioId)) {
-    ticker.metadata.portfolios.push(portfolioId);
-  }
+  const portfolios = ticker.metadata.portfolios.includes(portfolioId)
+    ? ticker.metadata.portfolios
+    : [...ticker.metadata.portfolios, portfolioId];
 
-  return ticker;
+  return {
+    ...ticker,
+    metadata: {
+      ...ticker.metadata,
+      name: position.name && ticker.metadata.name === ticker.metadata.ticker
+        ? position.name
+        : ticker.metadata.name,
+      assetCategory: position.assetCategory && !ticker.metadata.assetCategory
+        ? position.assetCategory
+        : ticker.metadata.assetCategory,
+      isin: position.isin && !ticker.metadata.isin ? position.isin : ticker.metadata.isin,
+      positions: [...otherPositions, positionEntry],
+      broker_contracts: brokerContracts,
+      portfolios,
+    },
+  };
 }
 
 export async function upsertBrokerPositionTicker({

package/src/brokers/remote-broker-adapter.ts

@@ -44,6 +44,9 @@ export function createRemoteBrokerAdapter(adapter: BrokerAdapter): BrokerAdapter
     ...adapter,
     validate: (instance) => invoke<boolean>(instance, "validate"),
     importPositions: (instance) => invoke(instance, "importPositions"),
+    importPortfolioSnapshot: adapter.importPortfolioSnapshot
+      ? (instance) => invoke(instance, "importPortfolioSnapshot")
+      : undefined,
     connect: (instance) => invoke<void>(instance, "connect"),
     disconnect: (instance) => invoke<void>(instance, "disconnect"),
     getStatus: (instance) => getBrokerRemoteClient()?.getStatus(instance.id) ?? adapter.getStatus?.(instance) ?? disconnectedStatus(),

package/src/capabilities/registry.test.ts

@@ -47,6 +47,10 @@ describe("CapabilityRegistry", () => {
 
     dispose();
     expect(registry.list()).toEqual([]);
+
+    registry.register("plugin-b", testCapability());
+    dispose();
+    expect(registry.list()).toHaveLength(1);
   });
 
   test("filters disabled plugins and disabled capabilities", () => {
@@ -134,4 +138,25 @@ describe("CapabilityRegistry", () => {
     expect(disposed).toBe(2);
     expect(registry.list()).toEqual([]);
   });
+
+  test("disposes subscriptions that finish after their capability is removed", async () => {
+    const registry = new CapabilityRegistry();
+    let finishSubscribe!: (dispose: () => void) => void;
+    let disposed = 0;
+    const disposeCapability = registry.register("plugin-a", testCapability({
+      operations: {
+        ticks: {
+          kind: "stream",
+          subscribe: () => new Promise((resolve) => { finishSubscribe = resolve; }),
+        },
+      },
+    }));
+
+    const subscribing = registry.subscribe("plugin-service.test", "ticks", {}, () => {});
+    disposeCapability();
+    finishSubscribe(() => { disposed += 1; });
+
+    await expect(subscribing).rejects.toThrow("not available");
+    expect(disposed).toBe(1);
+  });
 });

package/src/capabilities/registry.ts

@@ -24,15 +24,22 @@ export class CapabilityRegistry {
     if (existing) {
       throw new Error(`Capability "${capability.id}" already registered by plugin "${existing.pluginId}".`);
     }
-    this.capabilities.set(capability.id, { pluginId, capability });
+    const registration = { pluginId, capability };
+    this.capabilities.set(capability.id, registration);
     return () => {
+      if (this.capabilities.get(capability.id) !== registration) return;
       this.capabilities.delete(capability.id);
+      let firstError: unknown;
       for (const [subscriptionId, entry] of this.subscriptions) {
         if (entry.capabilityId === capability.id) {
-          entry.dispose();
-          this.subscriptions.delete(subscriptionId);
+          try {
+            this.unsubscribe(subscriptionId);
+          } catch (error) {
+            firstError ??= error;
+          }
         }
       }
+      if (firstError) throw firstError;
     };
   }
 
@@ -97,6 +104,10 @@ export class CapabilityRegistry {
     const subscriptionId = options.subscriptionId ?? `${capabilityId}:${operationId}:${this.nextSubscriptionId++}`;
     this.unsubscribe(subscriptionId);
     const dispose = await operation.subscribe(input, emit, { capability, operationId });
+    if (this.capabilities.get(capabilityId)?.capability !== capability) {
+      dispose();
+      throw new Error(`Capability "${capabilityId}" is not available.`);
+    }
     this.subscriptions.set(subscriptionId, { capabilityId, dispose });
     return subscriptionId;
   }
@@ -104,12 +115,18 @@ export class CapabilityRegistry {
   unsubscribe(subscriptionId: string): void {
     const entry = this.subscriptions.get(subscriptionId);
     if (!entry) return;
-    entry.dispose();
     this.subscriptions.delete(subscriptionId);
+    entry.dispose();
   }
 
   destroy(): void {
-    for (const subscriptionId of [...this.subscriptions.keys()]) this.unsubscribe(subscriptionId);
+    for (const subscriptionId of [...this.subscriptions.keys()]) {
+      try {
+        this.unsubscribe(subscriptionId);
+      } catch {
+        // Continue releasing the remaining subscriptions.
+      }
+    }
     this.capabilities.clear();
   }
 

package/src/cli/commands/automation.ts

@@ -102,9 +102,7 @@ export const aiCliCommand: CliCommandDef = {
     if (action === "ask") {
       const rawArgs = args.slice(1);
       const providerId = takeOption(rawArgs, "--provider") ?? detectProviders().find((provider) => provider.available)?.id;
-      const provider = getAiProvider(providerId);
-      if (!provider) ctx.fail("Unknown AI provider.");
-      const selectedProvider = provider;
+      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 prompt = rawArgs.join(" ").trim();
       if (!prompt) ctx.fail("Usage: gloomberb ai ask [--provider id] <prompt>");

package/src/cli/commands/command-utils.ts

@@ -15,13 +15,6 @@ export function takeOption(args: string[], name: string): string | undefined {
   return value;
 }
 
-export function takeFlag(args: string[], name: string): boolean {
-  const index = args.indexOf(name);
-  if (index < 0) return false;
-  args.splice(index, 1);
-  return true;
-}
-
 export function parseJsonPayload(value: string | undefined, ctx: CliCommandContext): unknown {
   if (!value) return {};
   try {

package/src/cli/commands/overview.ts

@@ -211,8 +211,8 @@ async function runCorrelation(args: string[], ctx: Parameters<CliCommandDef["exe
 
 export const overviewCliCommands: CliCommandDef[] = [
   { name: "movers", description: "Fetch gainers, losers, active, or trending market movers", help: { usage: ["movers [gainers|losers|active|trending]"] }, execute: runMoverCommand },
-  { name: "indices", description: "Fetch major US index quotes", execute: (args, ctx) => runQuoteBasket([...MARKET_SUMMARY_SYMBOLS], ctx, { group: "indices" }) },
-  { name: "sectors", description: "Fetch SPDR sector ETF quotes", execute: (args, ctx) => runQuoteBasket(SECTOR_ETFS, ctx, { group: "sectors" }) },
+  { name: "indices", description: "Fetch major US index quotes", execute: (_args, ctx) => runQuoteBasket([...MARKET_SUMMARY_SYMBOLS], ctx, { group: "indices" }) },
+  { name: "sectors", description: "Fetch SPDR sector ETF quotes", execute: (_args, ctx) => runQuoteBasket(SECTOR_ETFS, ctx, { group: "sectors" }) },
   { name: "fear-greed", description: "Fetch CNN Fear & Greed gauge data", execute: runFearGreed },
   { name: "econ", description: "Fetch economic calendar events", help: { usage: ["econ [--country US|G7|EU|all] [--impact high|medium|low|all]"] }, execute: runEcon },
   { name: "fred", description: "Fetch a FRED series through the configured cloud session", help: { usage: ["fred <series-id> [--start yyyy-mm-dd]"] }, execute: runFred },

package/src/cli/commands/plugins.ts

@@ -1,6 +1,6 @@
 import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { getPluginsDir } from "../../plugins/loader";
 import {
   cliStyles,
@@ -18,18 +18,34 @@ function ensurePluginsDir() {
   }
 }
 
-function parseGitHubRef(ref: string): { url: string; name: string } {
-  if (ref.startsWith("https://github.com/")) {
-    const clean = ref.replace(/\.git$/, "");
-    const name = clean.split("/").pop()!;
-    return { url: clean.endsWith(".git") ? ref : `${clean}.git`, name };
+const GITHUB_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+function validatePluginDirectoryName(name: string): string {
+  if (!GITHUB_SEGMENT_PATTERN.test(name)) {
+    throw new Error(`Invalid plugin name: ${name}.`);
   }
-  if (ref.startsWith("github:")) {
-    ref = ref.slice(7);
+  return name;
+}
+
+function parseGitHubRef(rawRef: string): { url: string; name: string } {
+  const ref = rawRef.startsWith("github:") ? rawRef.slice("github:".length) : rawRef;
+  let segments: string[];
+  if (ref.startsWith("https://")) {
+    const parsed = new URL(ref);
+    if (parsed.hostname !== "github.com" || parsed.port || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw new Error(`Invalid plugin reference: ${rawRef}. Use user/repo or a GitHub URL.`);
+    }
+    segments = parsed.pathname.split("/").filter(Boolean);
+  } else if (!ref.includes("://")) {
+    segments = ref.split("/");
+  } else {
+    segments = [];
   }
-  if (ref.includes("/") && !ref.includes("://")) {
-    const name = ref.split("/").pop()!;
-    return { url: `https://github.com/${ref}.git`, name };
+  const [owner, rawRepo] = segments;
+  const repo = rawRepo?.replace(/\.git$/, "");
+  if (segments.length === 2 && owner && GITHUB_SEGMENT_PATTERN.test(owner) && repo) {
+    const name = validatePluginDirectoryName(repo);
+    return { url: `https://github.com/${owner}/${name}.git`, name };
   }
   throw new Error(`Invalid plugin reference: ${ref}. Use user/repo or a GitHub URL.`);
 }
@@ -47,8 +63,9 @@ export async function installPlugin(ref: string) {
   console.log(cliStyles.muted(url));
 
   try {
-    execSync(`git clone --depth 1 ${url} ${targetDir}`, { stdio: "inherit" });
+    execFileSync("git", ["clone", "--depth", "1", url, targetDir], { stdio: "inherit" });
   } catch {
+    rmSync(targetDir, { recursive: true, force: true });
     fail(`Failed to clone ${url}.`);
   }
 
@@ -56,7 +73,7 @@ export async function installPlugin(ref: string) {
   if (existsSync(pkgPath)) {
     console.log(cliStyles.muted("Installing plugin dependencies..."));
     try {
-      execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+      execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
     } catch {
       console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
     }
@@ -92,7 +109,7 @@ export async function installPlugin(ref: string) {
 }
 
 export async function removePlugin(name: string) {
-  const targetDir = join(PLUGINS_DIR, name);
+  const targetDir = join(PLUGINS_DIR, validatePluginDirectoryName(name));
   if (!existsSync(targetDir)) {
     fail(`Plugin "${name}" was not found.`, PLUGINS_DIR);
   }
@@ -103,7 +120,7 @@ export async function removePlugin(name: string) {
 export async function updatePlugins(name?: string) {
   ensurePluginsDir();
   const dirs = name
-    ? [name]
+    ? [validatePluginDirectoryName(name)]
     : readdirSync(PLUGINS_DIR, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => entry.name);
@@ -121,10 +138,10 @@ export async function updatePlugins(name?: string) {
     }
     console.log(cliStyles.accent(`Updating ${dir}...`));
     try {
-      execSync("git pull", { cwd: targetDir, stdio: "inherit" });
+      execFileSync("git", ["pull", "--ff-only"], { cwd: targetDir, stdio: "inherit" });
       const pkgPath = join(targetDir, "package.json");
       if (existsSync(pkgPath)) {
-        execSync("bun install", { cwd: targetDir, stdio: "inherit" });
+        execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
       }
     } catch {
       console.error(cliStyles.danger(`Failed to update ${dir}.`));

package/src/cli/index.ts

@@ -14,7 +14,7 @@ import {
 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 { ticker } from "./commands/ticker";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
 import { overviewCliCommands } from "./commands/overview";
@@ -216,7 +216,7 @@ async function createRegistry(options: DispatchCliOptions = {}): Promise<CliComm
   return registry;
 }
 
-export { buildSearchReport, buildTickerReport, searchCandidatesForCli };
+export { buildSearchReport, searchCandidatesForCli };
 
 export async function dispatchCli(args: string[], options: DispatchCliOptions = {}): Promise<CliDispatchResult> {
   let parsed;