gloomberb 0.13.1 → 0.13.2

package/src/plugins/builtin/cloud/askg/undo.ts

@@ -0,0 +1,277 @@
+import { stableStringify } from "../../../../remote/revision";
+import type {
+  RemoteControlRequest,
+  RemoteControlResponse,
+  RemoteJsonPatchOperation,
+} from "../../../../remote/types";
+import type { JsonValue, ToolResultStatus } from "./protocol";
+
+export type InProcessRemoteControlHandler = (
+  request: RemoteControlRequest,
+) => Promise<RemoteControlResponse>;
+
+interface UndoResourceSnapshot {
+  resource: string;
+  value: JsonValue;
+}
+
+interface StoredUndoResource extends UndoResourceSnapshot {
+  expectedRev: string;
+}
+
+interface StoredUndo {
+  createdAt: number;
+  resources: StoredUndoResource[];
+}
+
+export interface PreparedUndo {
+  resources: UndoResourceSnapshot[];
+}
+
+export interface AppliedUndo {
+  status: Extract<ToolResultStatus, "ok" | "error" | "denied" | "cancelled">;
+  elapsedMs: number;
+  note?: string;
+}
+
+export interface ASKGUndoManagerOptions {
+  maxEntries?: number;
+  ttlMs?: number;
+  now?: () => number;
+  tokenFactory?: () => string;
+}
+
+const DEFAULT_MAX_ENTRIES = 50;
+const DEFAULT_TTL_MS = 10 * 60_000;
+
+const LAYOUT_UNDO_OPERATIONS = new Set([
+  "pane.setSetting",
+  "layout.gridlock",
+  "layout.closeFloating",
+  "layout.placePane",
+  "layout.setGrid",
+]);
+
+function shortReason(error: unknown): string {
+  const text = error instanceof Error ? error.message : String(error);
+  return text.replace(/\s+/g, " ").trim().slice(0, 240) || "Unknown error.";
+}
+
+function normalizeJson(value: unknown, seen = new WeakSet<object>()): JsonValue {
+  if (value == null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "bigint") return value.toString();
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.map((entry) => normalizeJson(entry, seen));
+    seen.delete(value);
+    return result;
+  }
+  const result: Record<string, JsonValue> = {};
+  for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+    result[key] = normalizeJson((value as Record<string, unknown>)[key], seen);
+  }
+  seen.delete(value);
+  return result;
+}
+
+function paneStateResource(args: Record<string, JsonValue>): string | null {
+  const paneId = args.paneId;
+  return typeof paneId === "string" && paneId.length > 0
+    ? `app://pane-state/${encodeURIComponent(paneId)}`
+    : null;
+}
+
+function resourcesForOperation(
+  operation: string,
+  args: Record<string, JsonValue>,
+): string[] | null {
+  if (operation === "pane.setState") {
+    const resource = paneStateResource(args);
+    return resource ? [resource] : null;
+  }
+  if (LAYOUT_UNDO_OPERATIONS.has(operation)) return ["app://layout/current"];
+  return null;
+}
+
+function pointerSegment(value: string): string {
+  return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+
+function isObject(value: JsonValue): value is Record<string, JsonValue> {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function replacementPatch(current: JsonValue, target: JsonValue): RemoteJsonPatchOperation[] | null {
+  if (!isObject(current) || !isObject(target)) return null;
+  const patch: RemoteJsonPatchOperation[] = [];
+  const currentKeys = Object.keys(current).sort();
+  const targetKeys = Object.keys(target).sort();
+  for (const key of currentKeys) {
+    if (!(key in target)) patch.push({ op: "remove", path: `/${pointerSegment(key)}` });
+  }
+  for (const key of targetKeys) {
+    const path = `/${pointerSegment(key)}`;
+    if (!(key in current)) {
+      patch.push({ op: "add", path, value: target[key] });
+    } else if (stableStringify(current[key]) !== stableStringify(target[key])) {
+      patch.push({ op: "replace", path, value: target[key] });
+    }
+  }
+  return patch;
+}
+
+function throwIfCancelled(signal?: AbortSignal): void {
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new Error("Undo was cancelled.");
+}
+
+function randomToken(): string {
+  return globalThis.crypto.randomUUID();
+}
+
+export class ASKGUndoManager {
+  private readonly entries = new Map<string, StoredUndo>();
+  private readonly maxEntries: number;
+  private readonly ttlMs: number;
+  private readonly now: () => number;
+  private readonly tokenFactory: () => string;
+
+  constructor(
+    private readonly remoteHandler: InProcessRemoteControlHandler,
+    options: ASKGUndoManagerOptions = {},
+  ) {
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.now = options.now ?? Date.now;
+    this.tokenFactory = options.tokenFactory ?? randomToken;
+  }
+
+  async prepare(
+    operation: string,
+    args: Record<string, JsonValue>,
+    signal?: AbortSignal,
+  ): Promise<PreparedUndo | null> {
+    const resources = resourcesForOperation(operation, args);
+    if (!resources) return null;
+    const snapshots: UndoResourceSnapshot[] = [];
+    for (const resource of resources) {
+      throwIfCancelled(signal);
+      const response = await this.remoteHandler({ type: "get", resource });
+      if (!response.ok) throw new Error(response.error.message);
+      snapshots.push({ resource, value: normalizeJson(response.data) });
+    }
+    return { resources: snapshots };
+  }
+
+  async commit(prepared: PreparedUndo, signal?: AbortSignal): Promise<string | null> {
+    const resources: StoredUndoResource[] = [];
+    let changed = false;
+    for (const before of prepared.resources) {
+      throwIfCancelled(signal);
+      const response = await this.remoteHandler({ type: "get", resource: before.resource });
+      if (!response.ok) throw new Error(response.error.message);
+      if (!response.rev) throw new Error(`Resource "${before.resource}" did not return a revision.`);
+      const current = normalizeJson(response.data);
+      if (stableStringify(current) !== stableStringify(before.value)) changed = true;
+      resources.push({ ...before, expectedRev: response.rev });
+    }
+    if (!changed) return null;
+
+    this.prune();
+    const token = this.tokenFactory();
+    this.entries.set(token, { createdAt: this.now(), resources });
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next().value as string | undefined;
+      if (!oldest) break;
+      this.entries.delete(oldest);
+    }
+    return token;
+  }
+
+  async undo(token: string, signal?: AbortSignal): Promise<AppliedUndo> {
+    const startedAt = this.now();
+    this.prune();
+    const entry = this.entries.get(token);
+    if (!entry) {
+      return {
+        status: "denied",
+        elapsedMs: Math.max(0, this.now() - startedAt),
+        note: "Undo token is unknown or expired.",
+      };
+    }
+
+    try {
+      const currentResources: Array<{
+        snapshot: StoredUndoResource;
+        value: JsonValue;
+        rev: string;
+        patch: RemoteJsonPatchOperation[];
+      }> = [];
+      for (const snapshot of entry.resources) {
+        throwIfCancelled(signal);
+        const response = await this.remoteHandler({ type: "get", resource: snapshot.resource });
+        if (!response.ok) throw new Error(response.error.message);
+        if (!response.rev) throw new Error(`Resource "${snapshot.resource}" did not return a revision.`);
+        if (response.rev !== snapshot.expectedRev) {
+          return {
+            status: "denied",
+            elapsedMs: Math.max(0, this.now() - startedAt),
+            note: `Cannot undo because "${snapshot.resource}" changed after the tool call.`,
+          };
+        }
+        const value = normalizeJson(response.data);
+        const patch = replacementPatch(value, snapshot.value);
+        if (!patch) {
+          return {
+            status: "denied",
+            elapsedMs: Math.max(0, this.now() - startedAt),
+            note: `Cannot safely restore non-object resource "${snapshot.resource}".`,
+          };
+        }
+        currentResources.push({ snapshot, value, rev: response.rev, patch });
+      }
+
+      for (const current of currentResources) {
+        throwIfCancelled(signal);
+        if (current.patch.length === 0) continue;
+        const response = await this.remoteHandler({
+          type: "patch",
+          resource: current.snapshot.resource,
+          patch: current.patch,
+          expectRev: current.rev,
+        });
+        if (!response.ok) throw new Error(response.error.message);
+      }
+      this.entries.delete(token);
+      return {
+        status: "ok",
+        elapsedMs: Math.max(0, this.now() - startedAt),
+      };
+    } catch (error) {
+      if (signal?.aborted) {
+        return {
+          status: "cancelled",
+          elapsedMs: Math.max(0, this.now() - startedAt),
+          note: "Undo was cancelled.",
+        };
+      }
+      return {
+        status: "error",
+        elapsedMs: Math.max(0, this.now() - startedAt),
+        note: shortReason(error),
+      };
+    }
+  }
+
+  private prune(): void {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [token, entry] of this.entries) {
+      if (entry.createdAt < cutoff) this.entries.delete(token);
+    }
+  }
+}

package/src/plugins/builtin/cloud/askg/verify.ts

@@ -0,0 +1,130 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createAppServices } from "../../../../core/app-services";
+import {
+  appReducer,
+  createInitialState,
+  type AppAction,
+} from "../../../../core/state/app/state";
+import { getLoadablePlugins } from "../../../catalog";
+import { createAppRemoteController } from "../../../../remote/controller";
+import type { RemoteUiRegistry } from "../../../../remote/semantic-tree";
+import { createDefaultConfig } from "../../../../types/config";
+import type { ASKGToolCallEvent, ClientToolManifest } from "./protocol";
+import { createASKGToolExecutor } from "./executor";
+import { buildASKGClientManifest, REMOTE_RESOURCE_TOOL_NAME } from "./manifest";
+
+function toolCall(tool: ClientToolManifest, args: ASKGToolCallEvent["args"]): ASKGToolCallEvent {
+  return {
+    seq: 1,
+    type: "tool-call",
+    turnId: "verify-turn",
+    toolCallId: `verify-${tool.name}`,
+    name: tool.name,
+    args,
+    writeTier: tool.writeTier,
+    requiresConfirmation: false,
+    preview: null,
+    timeoutMs: tool.timeoutMs,
+    expiresAt: new Date(Date.now() + tool.timeoutMs).toISOString(),
+  };
+}
+
+function resultShape(value: unknown): string {
+  if (Array.isArray(value)) return "array";
+  if (value == null) return String(value);
+  if (typeof value !== "object") return typeof value;
+  return Object.keys(value as Record<string, unknown>).sort().join(",") || "object";
+}
+
+async function verify() {
+  const dataDir = mkdtempSync(join(tmpdir(), "gloomberb-askg-client-"));
+  const config = { ...createDefaultConfig(dataDir), onboardingComplete: true };
+  const services = createAppServices({ config, plugins: getLoadablePlugins() });
+  try {
+    await services.ready;
+    let state = createInitialState(config);
+    const dispatch = (action: AppAction) => {
+      state = appReducer(state, action);
+    };
+    services.pluginRegistry.getConfigFn = () => state.config;
+    services.pluginRegistry.getLayoutFn = () => state.config.layout;
+    services.pluginRegistry.updateLayoutFn = (layout) => dispatch({ type: "UPDATE_LAYOUT", layout });
+
+    const uiRegistry: RemoteUiRegistry = {
+      register() {},
+      unregister() {},
+      snapshot: () => [],
+      invoke: async () => null,
+    };
+    const remote = createAppRemoteController({
+      dispatch,
+      getState: () => state,
+      pluginRegistry: services.pluginRegistry,
+      uiRegistry,
+    });
+    const built = await buildASKGClientManifest(services.pluginRegistry);
+    const sources = { headless: 0, "remote-op": 0 };
+    const tiers = { read: 0, "ui-write": 0, "user-data": 0, broker: 0 };
+    for (const tool of built.tools) {
+      sources[tool.source] += 1;
+      tiers[tool.writeTier] += 1;
+    }
+
+    console.log(JSON.stringify({
+      totalTools: built.tools.length,
+      sources,
+      tiers,
+      headlessNames: built.tools.filter(({ source }) => source === "headless").map(({ name }) => name),
+      manifestHash: built.manifestHash,
+      skipped: built.skipped,
+    }, null, 2));
+
+    const executor = createASKGToolExecutor({
+      manifests: built.tools,
+      registry: services.pluginRegistry,
+      context: {
+        config,
+        dataDir,
+        persistence: services.persistence,
+        store: services.tickerRepository,
+        dataProvider: services.providerRouter,
+      },
+      remoteHandler: remote.handle,
+    });
+    const headless = built.tools.find(({ source, name, argument }) => (
+      source === "headless" && name === "val" && (argument?.kind === "none" || argument?.optional)
+    )) ?? built.tools.find(({ source, argument }) => (
+      source === "headless" && (argument?.kind === "none" || argument?.optional)
+    ));
+    const resource = built.tools.find(({ name }) => name === REMOTE_RESOURCE_TOOL_NAME);
+    if (!headless || !resource) throw new Error("Verification tools are missing from the manifest.");
+
+    const headlessResult = await executor.execute(toolCall(headless, {}));
+    const remoteResult = await executor.execute(toolCall(resource, { resource: "app://snapshot" }));
+    console.log(JSON.stringify({
+      headless: {
+        name: headless.name,
+        status: headlessResult.status,
+        resultShape: resultShape(headlessResult.result),
+        rowCount: headlessResult.rowCount,
+        elapsedMs: headlessResult.elapsedMs,
+      },
+      remote: {
+        name: resource.name,
+        status: remoteResult.status,
+        resultShape: resultShape(remoteResult.result),
+        rowCount: remoteResult.rowCount,
+        elapsedMs: remoteResult.elapsedMs,
+      },
+    }, null, 2));
+  } finally {
+    services.destroy();
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+}
+
+if (import.meta.main) {
+  await verify();
+}

package/src/plugins/builtin/cloud/plugin.tsx

@@ -17,6 +17,7 @@ import {
   CONGRESS_TRADES_PANE_ID,
   CongressTradesPane,
 } from "../congress-trades/pane";
+import { congressHeadless } from "../congress-trades/headless";
 import { registerTwitterFeedFeature } from "../cloud-tweets/registration";
 import { composeBuiltinPlugin, type PluginModule } from "../plugin-module";
 import { registerCloudAuthCommands } from "./auth-commands";
@@ -181,6 +182,7 @@ const congressTradesModule: PluginModule = {
     description: "Track newly disclosed House periodic transaction reports.",
     keywords: ["congress", "house", "trades", "ptr", "stock", "disclosures"],
     shortcut: { prefix: "CG" },
+    headless: congressHeadless,
     createInstance: () => ({ placement: "floating" }),
     publicShare: createPublicPaneShare("Congress Trades"),
   }],

package/src/plugins/builtin/congress-trades/client.ts

@@ -0,0 +1,11 @@
+import { apiClient } from "../../../api-client";
+import type { CloudCongressHousePayload } from "../../../api-client";
+import type { CloudCongressHouseParams } from "../../../api-client/paths";
+import type { HeadlessPaneApiClient } from "../../../types/plugin";
+
+export function loadCongressHouse(
+  params: CloudCongressHouseParams = {},
+  client: Pick<HeadlessPaneApiClient, "getCloudCongressHouse"> = apiClient,
+): Promise<CloudCongressHousePayload> {
+  return client.getCloudCongressHouse(params);
+}

package/src/plugins/builtin/congress-trades/detail.tsx

@@ -15,7 +15,6 @@ import type {
   CloudCongressMemberPayload,
   CloudCongressTradePayload,
 } from "../../../api-client";
-import { apiClient } from "../../../api-client";
 import {
   CONGRESS_MEMBER_FILING_LIMIT,
   CONGRESS_MEMBER_TRADE_LIMIT,
@@ -34,6 +33,7 @@ import {
   type TradeColumnId,
 } from "./model";
 import { renderCongressTradeCell } from "./table";
+import { loadCongressHouse } from "./client";
 
 function DetailLine({
   label,
@@ -133,7 +133,7 @@ export function MemberTradesDetail({
     const gen = fetchGenRef.current;
     setStatus("loading");
     setError(null);
-    apiClient.getCloudCongressHouse({
+    loadCongressHouse({
       member: member.memberName,
       limit: CONGRESS_MEMBER_TRADE_LIMIT,
       filingLimit: Math.max(CONGRESS_MEMBER_FILING_LIMIT, filingLimit),
@@ -162,7 +162,7 @@ export function MemberTradesDetail({
     if (!nextRequest) return;
     const gen = fetchGenRef.current;
     setLoadingMore(true);
-    apiClient.getCloudCongressHouse({
+    loadCongressHouse({
       ...nextRequest,
       member: member.memberName,
       limit: CONGRESS_MEMBER_TRADE_LIMIT,

package/src/plugins/builtin/congress-trades/headless.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudCongressHousePayload } from "../../../api-client";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createCongressHeadless } from "./headless";
+
+const payload: CloudCongressHousePayload = {
+  asOf: "2026-09-04T12:00:00.000Z",
+  chamber: "house",
+  source: "house-clerk",
+  year: 2026,
+  indexUpdatedAt: "2026-09-04T11:00:00.000Z",
+  filingsScanned: 2,
+  filingCount: 2,
+  trades: [
+    {
+      id: "trade-1",
+      chamber: "house",
+      filingId: "filing-1",
+      docId: "doc-1",
+      memberName: "Nancy Pelosi",
+      stateDistrict: "CA-11",
+      filingDate: "2026-09-03",
+      transactionDate: "2026-08-20",
+      notificationDate: null,
+      lagDays: 14,
+      side: "BUY",
+      transactionType: "Purchase",
+      ticker: "NVDA",
+      assetName: "NVIDIA Corporation",
+      assetType: "Stock",
+      owner: "SP",
+      rawOwner: "Spouse",
+      amount: "$1,000,001 - $5,000,000",
+      amountLow: 1_000_001,
+      amountHigh: 5_000_000,
+      capGainsOver200: null,
+      filingStatus: null,
+      subholdingOf: null,
+      description: null,
+      sourceUrl: "https://disclosures-clerk.house.gov/filing-1",
+    },
+  ],
+  members: [
+    {
+      id: "member-1",
+      memberName: "Nancy Pelosi",
+      stateDistrict: "CA-11",
+      tradeCount: 12,
+      buyCount: 8,
+      sellCount: 4,
+      exchangeCount: 0,
+      otherCount: 0,
+      estimatedLow: 2_000_000,
+      estimatedHigh: 8_000_000,
+      lastFilingDate: "2026-09-03",
+      avgLagDays: 18,
+    },
+  ],
+};
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-congress"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(tab: "trades" | "members", limit = 50): HeadlessPaneLoadArgs {
+  return { rawArgument: "", argument: null, symbols: [], options: { tab, year: 2026, limit } };
+}
+
+describe("congress headless model", () => {
+  test("projects the active tab and applies its row limit", async () => {
+    const headless = createCongressHeadless({ loadHouse: async () => payload });
+
+    const trades = await headless.load(args("trades", 1), context());
+    expect(trades.rows).toMatchObject([{
+      memberName: "Nancy Pelosi",
+      side: "BUY",
+      ticker: "NVDA",
+      amountLow: 1_000_001,
+      amountHigh: 5_000_000,
+    }]);
+    expect(trades.columns?.map((column) => column.key)).toContain("ticker");
+
+    const members = await headless.load(args("members", 1), context());
+    expect(members.rows).toMatchObject([{
+      memberName: "Nancy Pelosi",
+      tradeCount: 12,
+      buyCount: 8,
+    }]);
+    expect(members.columns?.map((column) => column.key)).toContain("tradeCount");
+  });
+});