gloomberb 0.12.0 → 0.13.2

package/src/plugins/prediction-markets/headless.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../types/plugin";
+import {
+  createPredictionMarketsHeadless,
+  type PredictionMarketsHeadlessDependencies,
+} from "./headless";
+import type { PredictionMarketSummary, PredictionVenue } from "./types";
+
+function market(
+  key: string,
+  venue: PredictionVenue,
+  title: string,
+  volume24h: number,
+  endsAt: string,
+): PredictionMarketSummary {
+  return {
+    key,
+    venue,
+    marketId: `${key}-id`,
+    title,
+    marketLabel: "Yes",
+    eventLabel: title,
+    category: title.includes("Fed") ? "Economics" : "Politics",
+    tags: [],
+    status: "open",
+    url: `https://example.com/${key}`,
+    description: `${title} market`,
+    endsAt,
+    updatedAt: "2026-09-04T20:00:00.000Z",
+    yesPrice: 0.62,
+    noPrice: 0.38,
+    yesBid: 0.61,
+    yesAsk: 0.63,
+    noBid: 0.37,
+    noAsk: 0.39,
+    spread: 0.02,
+    lastTradePrice: 0.62,
+    volume24h,
+    volume24hUnit: "usd",
+    totalVolume: volume24h * 10,
+    totalVolumeUnit: "usd",
+    openInterest: volume24h / 2,
+    openInterestUnit: venue === "kalshi" ? "contracts" : "usd",
+    liquidity: volume24h / 4,
+    liquidityUnit: "usd",
+  };
+}
+
+const markets = [
+  market("poly-fed", "polymarket", "Will the Fed cut rates?", 2_000_000, "2026-10-01T00:00:00.000Z"),
+  market("kalshi-election", "kalshi", "Will the incumbent win?", 500_000, "2026-11-01T00:00:00.000Z"),
+];
+
+function args(
+  argument: string | null,
+  options: Record<string, string | number | boolean>,
+): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: argument ?? "",
+    argument,
+    symbols: [],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+function dependencies(seen: string[]): PredictionMarketsHeadlessDependencies {
+  return {
+    loadPolymarket: async (query) => {
+      seen.push(`polymarket:${query}`);
+      return markets.filter((entry) => entry.venue === "polymarket");
+    },
+    loadKalshi: async (query) => {
+      seen.push(`kalshi:${query}`);
+      return markets.filter((entry) => entry.venue === "kalshi");
+    },
+    now: () => new Date("2026-09-04T21:00:00.000Z"),
+  };
+}
+
+describe("prediction markets headless", () => {
+  test("projects venue data through the pane's shared row ordering", async () => {
+    const definition = createPredictionMarketsHeadless(dependencies([]));
+
+    const result = await definition.load(args(null, {
+      venue: "all",
+      category: "all",
+      tab: "top",
+      limit: 1,
+    }), context);
+
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        key: "poly-fed",
+        venue: "polymarket",
+        yesProbability: 0.62,
+        volume24h: 2_000_000,
+      }),
+    ]);
+    expect(result.metadata).toMatchObject({ total: 2, returned: 1, truncated: true });
+  });
+
+  test("uses the shortcut venue prefix without querying the other venue", async () => {
+    const seen: string[] = [];
+    const definition = createPredictionMarketsHeadless(dependencies(seen));
+
+    const result = await definition.load(args("polymarket:fed", {
+      venue: "all",
+      category: "macro",
+      tab: "ending",
+      limit: 20,
+    }), context);
+
+    expect(seen).toEqual(["polymarket:fed"]);
+    expect(result.rows.map((row) => row.key)).toEqual(["poly-fed"]);
+    expect(result.metadata).toMatchObject({ venue: "polymarket", query: "fed" });
+  });
+});

package/src/plugins/prediction-markets/headless.ts

@@ -0,0 +1,255 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../types/plugin";
+import { PREDICTION_CATEGORY_OPTIONS } from "./categories";
+import {
+  filterPredictionMarkets,
+  getDefaultPredictionSort,
+  sortPredictionMarkets,
+} from "./metrics";
+import { parsePredictionSearchShortcut } from "./navigation";
+import { buildPredictionListRows } from "./rows";
+import { loadKalshiCatalog } from "./services/kalshi/adapter";
+import { loadPolymarketCatalog } from "./services/polymarket/adapter";
+import type {
+  PredictionBrowseTab,
+  PredictionCategoryId,
+  PredictionListRow,
+  PredictionMarketSummary,
+  PredictionVenueScope,
+} from "./types";
+
+const PREDICTION_COLUMNS = [
+  { key: "venue", header: "Venue" },
+  { key: "title", header: "Market" },
+  { key: "target", header: "Target" },
+  { key: "yesProbability", header: "Yes", align: "right" as const },
+  { key: "spread", header: "Spread", align: "right" as const },
+  { key: "volume24h", header: "24h volume", align: "right" as const },
+  { key: "openInterest", header: "Open interest", align: "right" as const },
+  { key: "endsAt", header: "Ends" },
+  { key: "status", header: "Status" },
+  { key: "category", header: "Category" },
+];
+
+export interface PredictionMarketsHeadlessDependencies {
+  loadPolymarket(
+    query: string,
+    category: PredictionCategoryId,
+    limit: number,
+  ): Promise<PredictionMarketSummary[]>;
+  loadKalshi(
+    query: string,
+    category: PredictionCategoryId,
+    limit: number,
+  ): Promise<PredictionMarketSummary[]>;
+  now(): Date;
+}
+
+const defaultDependencies: PredictionMarketsHeadlessDependencies = {
+  loadPolymarket: (query, category, limit) => loadPolymarketCatalog(
+    query,
+    category,
+    { limit },
+  ),
+  loadKalshi: (query, category, limit) => loadKalshiCatalog(
+    query,
+    category,
+    { limit },
+  ),
+  now: () => new Date(),
+};
+
+interface PredictionSelection {
+  query: string;
+  venue: PredictionVenueScope;
+  category: PredictionCategoryId;
+  tab: PredictionBrowseTab;
+  limit: number;
+}
+
+function selectionFor(args: HeadlessPaneLoadArgs): PredictionSelection {
+  const parsed = parsePredictionSearchShortcut(
+    typeof args.argument === "string" ? args.argument : "",
+  );
+  const optionVenue = String(args.options.venue ?? "all") as PredictionVenueScope;
+  return {
+    query: parsed.searchQuery,
+    venue: optionVenue === "all" ? parsed.venueScope : optionVenue,
+    category: String(args.options.category ?? "all") as PredictionCategoryId,
+    tab: String(args.options.tab ?? "top") as PredictionBrowseTab,
+    limit: Number(args.options.limit ?? 50),
+  };
+}
+
+function rowForHeadless(row: PredictionListRow) {
+  const focusMarket = row.markets.find((market) => market.key === row.focusMarketKey)
+    ?? row.representative;
+  return {
+    key: row.key,
+    kind: row.kind,
+    venue: row.venue,
+    title: row.title,
+    target: row.focusMarketLabel,
+    yesProbability: row.focusYesPrice,
+    noProbability: focusMarket.noPrice,
+    targetMarketId: focusMarket.marketId,
+    marketId: row.marketId,
+    event: row.eventLabel,
+    category: row.category ?? null,
+    tags: row.tags ?? [],
+    status: row.status,
+    url: row.url,
+    description: row.description,
+    endsAt: row.endsAt,
+    updatedAt: row.updatedAt,
+    spread: row.spread,
+    lastTradePrice: row.lastTradePrice,
+    volume24h: row.volume24h,
+    volume24hUnit: row.volume24hUnit,
+    totalVolume: row.totalVolume,
+    totalVolumeUnit: row.totalVolumeUnit,
+    openInterest: row.openInterest,
+    openInterestUnit: row.openInterestUnit,
+    liquidity: row.liquidity,
+    liquidityUnit: row.liquidityUnit,
+    marketCount: row.kind === "group" ? row.marketCount : 1,
+    yesProbabilityLow: row.kind === "group" ? row.yesPriceLow : row.yesPrice,
+    yesProbabilityHigh: row.kind === "group" ? row.yesPriceHigh : row.yesPrice,
+  };
+}
+
+export function projectPredictionMarketsHeadless(
+  markets: PredictionMarketSummary[],
+  errors: string[],
+  args: HeadlessPaneLoadArgs,
+  now: Date,
+): HeadlessRowsResult {
+  const selection = selectionFor(args);
+  const rows = sortPredictionMarkets(
+    filterPredictionMarkets(
+      buildPredictionListRows(markets),
+      selection.tab,
+      selection.venue,
+      selection.category,
+      selection.query,
+      new Set(),
+    ),
+    getDefaultPredictionSort(selection.tab),
+  );
+  const selectedRows = rows.slice(0, selection.limit).map(rowForHeadless);
+
+  return {
+    columns: PREDICTION_COLUMNS,
+    rows: selectedRows,
+    errors: errors.length > 0 ? errors : undefined,
+    metadata: {
+      fetchedAt: now.toISOString(),
+      query: selection.query || null,
+      venue: selection.venue,
+      category: selection.category,
+      tab: selection.tab,
+      sourceMarkets: markets.length,
+      total: rows.length,
+      returned: selectedRows.length,
+      truncated: selectedRows.length < rows.length,
+    },
+  };
+}
+
+export function createPredictionMarketsHeadless(
+  dependencies: PredictionMarketsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "query",
+      description: "Optional market query, including polymarket: or kalshi: shorthand.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "venue",
+        description: "Prediction venue to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "polymarket" },
+          { value: "kalshi" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "category",
+        description: "Market category to include.",
+        type: "enum",
+        values: PREDICTION_CATEGORY_OPTIONS.map((option) => ({ value: option.id })),
+        defaultValue: "all",
+      },
+      {
+        key: "tab",
+        description: "Browse ordering to apply.",
+        type: "enum",
+        values: [
+          { value: "top" },
+          { value: "ending" },
+          { value: "new" },
+        ],
+        defaultValue: "top",
+      },
+      {
+        key: "limit",
+        description: "Maximum market rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: PREDICTION_COLUMNS,
+    describe: (args) => {
+      const selection = selectionFor(args);
+      return selection.query
+        ? `Prediction Markets | ${selection.query}`
+        : "Prediction Markets";
+    },
+    async load(args) {
+      const selection = selectionFor(args);
+      const requested: Array<{
+        venue: "polymarket" | "kalshi";
+        load: Promise<PredictionMarketSummary[]>;
+      }> = [];
+      if (selection.venue !== "kalshi") {
+        requested.push({
+          venue: "polymarket",
+          load: dependencies.loadPolymarket(selection.query, selection.category, 200),
+        });
+      }
+      if (selection.venue !== "polymarket") {
+        requested.push({
+          venue: "kalshi",
+          load: dependencies.loadKalshi(selection.query, selection.category, 200),
+        });
+      }
+      const settled = await Promise.allSettled(requested.map((request) => request.load));
+      const markets: PredictionMarketSummary[] = [];
+      const errors: string[] = [];
+      for (const [index, result] of settled.entries()) {
+        if (result.status === "fulfilled") {
+          markets.push(...result.value);
+        } else {
+          const message = result.reason instanceof Error
+            ? result.reason.message
+            : String(result.reason);
+          errors.push(`${requested[index]?.venue ?? "venue"}: ${message}`);
+        }
+      }
+      return projectPredictionMarketsHeadless(markets, errors, args, dependencies.now());
+    },
+  };
+}
+
+export const predictionMarketsHeadless = createPredictionMarketsHeadless();

package/src/plugins/prediction-markets/index.tsx

@@ -5,6 +5,7 @@ import { PredictionMarketsPane } from "./pane";
 import { attachPredictionMarketsPersistence, resetPredictionMarketsPersistence } from "./services/fetch";
 import { predictionMarketsCliCommand } from "./cli";
 import { predictionChartSeriesCapability } from "./capability";
+import { predictionMarketsHeadless } from "./headless";
 import {
   buildPredictionMarketsPaneSettingsDef,
   createPredictionMarketsPaneSettings,
@@ -59,6 +60,7 @@ export const predictionMarketsPlugin: GloomPlugin = {
       description: "Open a new prediction markets browser pane",
       keywords: ["prediction", "markets", "polymarket", "kalshi", "events"],
       shortcut: { prefix: "PM", argPlaceholder: "query", argKind: "text" },
+      headless: predictionMarketsHeadless,
       createInstance: (_context, options) => {
         const parsed = parsePredictionSearchShortcut(options?.arg ?? "");
         return {

package/src/plugins/seed.ts

@@ -19,6 +19,9 @@ export const EXTRACTED_PLUGINS = [
   { id: "substack", repo: "gloom-sh/gloomberb-substack", directory: "gloomberb-substack" },
   { id: "ibkr", repo: "gloom-sh/gloomberb-ibkr", directory: "gloomberb-ibkr" },
   { id: "ibkr-gateway", repo: "gloom-sh/gloomberb-ibkr-gateway", directory: "gloomberb-ibkr-gateway" },
+  { id: "public", repo: "gloom-sh/gloomberb-public", directory: "gloomberb-public" },
+  { id: "robinhood", repo: "gloom-sh/gloomberb-robinhood", directory: "gloomberb-robinhood" },
+  { id: "simplefin", repo: "gloom-sh/gloomberb-simplefin", directory: "gloomberb-simplefin" },
 ] as const;
 
 export interface SeedResult {

package/src/public/broker.ts

@@ -7,6 +7,12 @@
  * from the view, since the renderer cannot open sockets itself.
  */
 export { getBrokerRemoteClient, setBrokerRemoteClient } from "../brokers/remote-broker-adapter";
+/**
+ * Placeholder a broker shows instead of a stored secret, so an edited profile
+ * can tell "unchanged" from "cleared". Broker plugins that persist a derived
+ * credential need the host's exact string for the round trip to work.
+ */
+export { PRESERVED_PASSWORD_HINT } from "../brokers/profile-form";
 export type { BrokerRemoteClient } from "../brokers/remote-broker-adapter";
 export type { ResourceStore } from "../data/resource-store";
 export { resolveTickerFinancialsForInstrument } from "../market-data/coordinator";

package/src/remote/schema.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { TOOL_NAME_PATTERN } from "../plugins/builtin/cloud/askg/protocol";
+import {
+  REMOTE_OPERATIONS,
+  remoteOperationDescriptors,
+  remoteOperationToolName,
+  writeTierForSideEffectLevel,
+} from "./schema";
+
+function jsonRoundTrip<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+describe("remote operation schema", () => {
+  test("publishes stable input schemas and write tiers", () => {
+    expect(REMOTE_OPERATIONS.length).toBeGreaterThan(0);
+
+    for (const operation of REMOTE_OPERATIONS) {
+      expect(operation.title.length).toBeGreaterThan(0);
+      expect(operation.inputSchema.type).toBe("object");
+      const mappedTier = writeTierForSideEffectLevel(operation.sideEffectLevel);
+      if (operation.id === "layout.delete") {
+        expect(operation.sideEffectLevel).toBe("local-write");
+        expect(operation.writeTier).toBe("user-data");
+      } else {
+        expect(operation.writeTier).toBe(mappedTier);
+      }
+      expect(jsonRoundTrip(operation.inputSchema)).toEqual(operation.inputSchema);
+    }
+
+    expect(writeTierForSideEffectLevel("none")).toBe("read");
+    expect(writeTierForSideEffectLevel("network-write")).toBe("user-data");
+    expect(writeTierForSideEffectLevel("external-trade")).toBe("broker");
+    expect(REMOTE_OPERATIONS.find(({ id }) => id === "layout.delete")?.writeTier)
+      .toBe("user-data");
+    expect(REMOTE_OPERATIONS.find(({ id }) => id === "capability.invoke")?.writeTier)
+      .toBe("broker");
+    expect(REMOTE_OPERATIONS.find(({ id }) => id === "layout.placePane")?.inputSchema)
+      .toMatchObject({
+        required: ["paneId", "region"],
+        properties: {
+          region: { enum: ["left", "right", "top", "bottom", "floating"] },
+        },
+      });
+  });
+
+  test("serializes operation descriptors without losing fields", () => {
+    const descriptors = remoteOperationDescriptors();
+
+    expect(jsonRoundTrip(descriptors)).toEqual(descriptors);
+    expect(descriptors).toHaveLength(REMOTE_OPERATIONS.length);
+    expect(new Set(descriptors.map(({ name }) => name)).size).toBe(descriptors.length);
+    expect(descriptors.every(({ name }) => new RegExp(TOOL_NAME_PATTERN).test(name)))
+      .toBe(true);
+    expect(remoteOperationToolName("commandBar.activateResult"))
+      .toBe("command_bar.activate_result");
+    expect(descriptors[0]).toEqual({
+      name: remoteOperationToolName(REMOTE_OPERATIONS[0]!.id),
+      title: REMOTE_OPERATIONS[0]!.title,
+      description: REMOTE_OPERATIONS[0]!.description,
+      writeTier: REMOTE_OPERATIONS[0]!.writeTier,
+      inputSchema: REMOTE_OPERATIONS[0]!.inputSchema,
+    });
+  });
+});