gloomberb 0.11.3 → 0.13.1

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

@@ -1,19 +1,33 @@
 import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join } from "path";
-import { pathToFileURL } from "url";
+import { join, resolve, sep } from "path";
 import type { AppConfig } from "../types/config";
 import type { ResolvedSeries } from "../time-series/types";
-import type { OptionsChain, TickerFinancials } from "../types/financials";
+import type { OptionsChain, PricePoint, TickerFinancials } from "../types/financials";
+import type { ManualChartResolution } from "../time-series/resolution";
 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 type { DatedObservation } from "../plugins/builtin/market-valuation/series";
 import {
   electrobunViewPath,
   writeElectrobunViewPage,
 } from "../renderers/electrobun/view/build-assets";
 
+export interface DesktopPaneShotIntradayHistory {
+  symbol: string;
+  exchange: string;
+  rangePreset: "1D" | "1W";
+  resolution: ManualChartResolution;
+  requestedSession: string | null;
+  sessionDates: string[];
+  points: PricePoint[];
+  start: string | null;
+  end: string | null;
+  unavailableReason: string | null;
+}
+
 export interface DesktopPaneShotPayload {
   config: AppConfig;
   paneId: string;
@@ -21,16 +35,49 @@ export interface DesktopPaneShotPayload {
   heightCells: number;
   widthPx: number;
   heightPx: number;
+  /** Chrome device scale factor; 2 keeps text crisp, higher values zoom the layout. */
+  deviceScaleFactor?: number;
+  /** Label drawn at the right edge of the pane title bar; null draws nothing. */
+  watermark?: string | null;
   tickers: TickerRecord[];
   financials: Array<[string, TickerFinancials]>;
+  intradayHistories: DesktopPaneShotIntradayHistory[];
   optionsChains: Array<[string, OptionsChain]>;
   fredSeries: Array<[string, FredSeriesCacheEntry]>;
+  valuationSeries: Array<[string, DatedObservation[]]>;
+  statSeries: Array<[string, DatedObservation[]]>;
   capabilitySeries: Array<[string, ResolvedSeries]>;
   paneState: Record<string, PaneRuntimeState>;
 }
 
+/** Kept in Bun memory and never serialized into the browser page or CLI result. */
+export interface DesktopPaneShotApiProxy {
+  baseUrl: string;
+  sessionToken: string | null;
+}
+
+export interface DesktopPaneShotRenderedCell {
+  columnId?: string;
+  columnLabel: string;
+  text: string;
+}
+
+export interface DesktopPaneShotRenderedRow {
+  tableIndex: number;
+  rowIndex: number;
+  key?: string;
+  selected: boolean;
+  cells: DesktopPaneShotRenderedCell[];
+}
+
 export interface DesktopPaneShotRenderResult {
   visibleText: string;
+  rows: DesktopPaneShotRenderedRow[];
+  truncated: boolean;
+  truncationReasons: string[];
+  loadingStateDetected: boolean;
+  errorStateDetected: boolean;
+  errorStateMarkers: string[];
   emptyStateDetected: boolean;
   emptyStateMarkers: string[];
   semanticUi: RemoteUiNodeSnapshot[];
@@ -47,30 +94,49 @@ type PendingCdpCall = {
   reject: (error: Error) => void;
 };
 
+const SHOT_MODE_CSS = [
+  "[data-gloom-role='composite-chart-toolbar']",
+  "[data-gloom-role='chart-series-quick-add']",
+  "[data-gloom-role='pane-close']",
+].join(", ") + " { display: none !important; }\n"
+  // Sits where the hidden close button was: one cell high, right-aligned in the title bar.
+  + "[data-gloom-role='shot-watermark'] { position: fixed; top: 1px; right: 10px; height: var(--cell-h);"
+  + " line-height: var(--cell-h); font-size: 12px; letter-spacing: 0.02em; color: var(--gloom-text-dim, #888);"
+  + " pointer-events: none; z-index: 1000; }";
+
 const CHROME_POLL_ATTEMPTS = 80;
-const SHOT_READY_TIMEOUT_MS = 10_000;
+const SHOT_READY_TIMEOUT_MS = 45_000;
 const CDP_CALL_TIMEOUT_MS = 10_000;
-const SHOT_DEVICE_SCALE_FACTOR = 2;
+const DEFAULT_DEVICE_SCALE_FACTOR = 2;
+const SHOT_API_PROXY_PREFIX = "/__gloom_cli_api__";
+const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
 
 export async function renderDesktopPaneScreenshot(
   payload: DesktopPaneShotPayload,
   outputPath: string,
+  apiProxy: DesktopPaneShotApiProxy,
+  options: { captureImage?: boolean } = {},
 ): Promise<DesktopPaneShotRenderResult> {
   const tempDir = await mkdtemp(join(tmpdir(), "gloom-pane-shot-"));
+  let server: ReturnType<typeof Bun.serve> | null = null;
   try {
     const outdir = join(tempDir, "assets");
     await mkdir(outdir, { recursive: true });
-    const htmlPath = await buildShotPage(outdir, payload);
+    await buildShotPage(outdir, payload);
+    server = serveShotPage(outdir, apiProxy);
     const chrome = await findChromeExecutable();
     return await capturePageScreenshot({
       chrome,
-      url: pathToFileURL(htmlPath).href,
+      url: new URL("/", server.url).href,
       outputPath,
       widthPx: payload.widthPx,
       heightPx: payload.heightPx,
+      deviceScaleFactor: payload.deviceScaleFactor ?? DEFAULT_DEVICE_SCALE_FACTOR,
       userDataDir: join(tempDir, "chrome-profile"),
+      captureImage: options.captureImage !== false,
     });
   } finally {
+    server?.stop(true);
     await rm(tempDir, { recursive: true, force: true });
   }
 }
@@ -90,6 +156,20 @@ async function buildShotPage(outdir: string, payload: DesktopPaneShotPayload): P
     loadingText: "Rendering pane...",
     bootstrapScript: `
       window.__GLOOM_CLI_SHOT_PAYLOAD__ = ${payloadJson};
+      (() => {
+        // A screenshot cannot be interacted with, so drawing tools, the
+        // quick-add input and the close button only add noise to the image.
+        const style = document.createElement("style");
+        style.textContent = ${JSON.stringify(SHOT_MODE_CSS)};
+        document.head.appendChild(style);
+        const watermark = ${JSON.stringify(payload.watermark ?? null)};
+        if (watermark) {
+          const mark = document.createElement("div");
+          mark.setAttribute("data-gloom-role", "shot-watermark");
+          mark.textContent = watermark;
+          document.addEventListener("DOMContentLoaded", () => document.body.appendChild(mark));
+        }
+      })();
       window.addEventListener("error", (event) => {
         window.__GLOOM_CLI_SHOT_ERROR__ = event.error && event.error.stack ? event.error.stack : String(event.error || event.message);
       });
@@ -100,6 +180,116 @@ async function buildShotPage(outdir: string, payload: DesktopPaneShotPayload): P
   });
 }
 
+function serveShotPage(
+  outdir: string,
+  apiProxy: DesktopPaneShotApiProxy,
+): ReturnType<typeof Bun.serve> {
+  const staticRoot = resolve(outdir);
+  return Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 60,
+    fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname.startsWith(`${SHOT_API_PROXY_PREFIX}/`)) {
+        return proxyShotApiRequest(request, url, apiProxy);
+      }
+      return serveShotAsset(url, staticRoot);
+    },
+  });
+}
+
+async function serveShotAsset(url: URL, staticRoot: string): Promise<Response> {
+  let pathname: string;
+  try {
+    pathname = decodeURIComponent(url.pathname);
+  } catch {
+    return new Response("Bad request", { status: 400 });
+  }
+  const relativePath = pathname === "/" ? "index.html" : pathname.replace(/^\/+/, "");
+  const filePath = resolve(staticRoot, relativePath);
+  if (filePath !== staticRoot && !filePath.startsWith(`${staticRoot}${sep}`)) {
+    return new Response("Not found", { status: 404 });
+  }
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) return new Response("Not found", { status: 404 });
+  return new Response(file);
+}
+
+async function proxyShotApiRequest(
+  request: Request,
+  requestUrl: URL,
+  apiProxy: DesktopPaneShotApiProxy,
+): Promise<Response> {
+  const baseUrl = new URL(apiProxy.baseUrl);
+  const proxiedPath = requestUrl.pathname.slice(SHOT_API_PROXY_PREFIX.length) || "/";
+  const target = new URL(baseUrl);
+  const basePath = baseUrl.pathname.replace(/\/+$/, "");
+  target.pathname = `${basePath}${proxiedPath.startsWith("/") ? proxiedPath : `/${proxiedPath}`}`;
+  target.search = requestUrl.search;
+  target.hash = "";
+  const headers = new Headers(request.headers);
+  for (const name of [
+    "authorization",
+    "connection",
+    "content-length",
+    "cookie",
+    "host",
+    "origin",
+    "proxy-authorization",
+    "referer",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "x-forwarded-for",
+    "x-forwarded-host",
+    "x-forwarded-proto",
+  ]) {
+    headers.delete(name);
+  }
+  const browserOwnedHeaders: string[] = [];
+  headers.forEach((_value, name) => {
+    if (name.startsWith("sec-") || name === "accept-encoding") browserOwnedHeaders.push(name);
+  });
+  for (const name of browserOwnedHeaders) headers.delete(name);
+  headers.set("Origin", baseUrl.origin);
+  if (apiProxy.sessionToken) {
+    headers.set(
+      "Cookie",
+      SESSION_COOKIE_NAMES.map((name) => `${name}=${apiProxy.sessionToken}`).join("; "),
+    );
+  }
+
+  try {
+    const response = await fetch(target, {
+      method: request.method,
+      headers,
+      body: request.method === "GET" || request.method === "HEAD" ? undefined : request.body,
+      redirect: "follow",
+    });
+    const responseHeaders = new Headers(response.headers);
+    for (const name of [
+      "access-control-allow-credentials",
+      "access-control-allow-origin",
+      "content-encoding",
+      "content-length",
+      "set-cookie",
+      "transfer-encoding",
+    ]) {
+      responseHeaders.delete(name);
+    }
+    responseHeaders.set("Cache-Control", "no-store");
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+    });
+  } catch {
+    return Response.json({ error: "Cloud API request failed." }, { status: 502 });
+  }
+}
+
 async function findChromeExecutable(): Promise<string> {
   const candidates = [
     process.env.CHROME_PATH,
@@ -123,14 +313,18 @@ async function capturePageScreenshot({
   outputPath,
   widthPx,
   heightPx,
+  deviceScaleFactor,
   userDataDir,
+  captureImage,
 }: {
   chrome: string;
   url: string;
   outputPath: string;
   widthPx: number;
   heightPx: number;
+  deviceScaleFactor: number;
   userDataDir: string;
+  captureImage: boolean;
 }): Promise<DesktopPaneShotRenderResult> {
   await mkdir(userDataDir, { recursive: true });
   const port = 43000 + Math.floor(Math.random() * 10000);
@@ -166,18 +360,20 @@ async function capturePageScreenshot({
     await session.send("Emulation.setDeviceMetricsOverride", {
       width: widthPx,
       height: heightPx,
-      deviceScaleFactor: SHOT_DEVICE_SCALE_FACTOR,
+      deviceScaleFactor,
       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, Uint8Array.from(Buffer.from(screenshot.data, "base64")));
+    if (captureImage) {
+      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, Uint8Array.from(Buffer.from(screenshot.data, "base64")));
+    }
     return rendered;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -189,6 +385,22 @@ async function capturePageScreenshot({
   }
 }
 
+const LOADING_STATE_PATTERNS = [
+  /\bLoading(?: [^.]{0,80})?\.{3}/gi,
+  /\bRendering pane\.{3}/gi,
+];
+
+const ERROR_STATE_PATTERNS = [
+  /\b[^.]{1,100} unavailable\./gi,
+  /\bFailed to fetch\b/gi,
+  /\bCould not load\b/gi,
+  /\bSign in to\b/gi,
+  /\bVerify your email\b/gi,
+  /\brequires signup and email verification\b/gi,
+  /\bpart of Gloom Cloud Pro\b/gi,
+  /\bCloud API request failed\b/gi,
+];
+
 const EMPTY_STATE_PATTERNS = [
   /\bNo chart data\b/gi,
   /\bNo graph data\b/gi,
@@ -197,21 +409,127 @@ const EMPTY_STATE_PATTERNS = [
   /\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 tickers? selected\b/gi,
   /\bNo data(?: available)?\b/gi,
+  /\bNothing to show yet\b/gi,
+  /\bNo transcribed calls(?: for [^.]+)? yet\b/gi,
+  /\bNo short interest (?:data|found)\b/gi,
+  /\bNo (?:House PTR |insider )?(?:trades|members|transactions|filings)\b/gi,
 ];
 
+function stateMarkers(text: string, patterns: RegExp[]): string[] {
+  return [...new Set(patterns.flatMap((pattern) => (
+    [...text.matchAll(pattern)].map((match) => match[0])
+  )))];
+}
+
 async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneShotRenderResult> {
   const result = await session.send("Runtime.evaluate", {
     expression: `(() => {
       const root = document.getElementById("root") || document.body;
+      const semanticUi = window.__GLOOM_CLI_SHOT_SEMANTIC_UI__ || [];
+      const normalize = (value) => String(value || "").replace(/\\s+/g, " ").trim();
+      const isVisible = (element) => {
+        if (!(element instanceof HTMLElement)) return false;
+        const style = getComputedStyle(element);
+        if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+        const rect = element.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0
+          && rect.right > 0 && rect.bottom > 0
+          && rect.left < window.innerWidth && rect.top < window.innerHeight;
+      };
+      const semanticTables = semanticUi.filter((node) => node && node.role === "table");
+      const rows = [];
+      const truncationReasons = new Set();
+      const markScrollTruncation = (element) => {
+        if (!(element instanceof HTMLElement) || !isVisible(element)) return;
+        if (
+          element.getAttribute("data-gloom-scrollbar-y") === "visible"
+          || element.scrollHeight > element.clientHeight + 1
+        ) {
+          truncationReasons.add("rows extend below the rendered viewport");
+        }
+        if (
+          element.getAttribute("data-gloom-scrollbar-x") === "visible"
+          || element.scrollWidth > element.clientWidth + 1
+        ) {
+          truncationReasons.add("columns extend beyond the rendered viewport");
+        }
+      };
+      [...root.querySelectorAll(
+        '[data-gloom-scrollbar-x="visible"], [data-gloom-scrollbar-y="visible"], [data-gloom-role="data-table-body-scroll"]',
+      )].forEach(markScrollTruncation);
+      [...root.querySelectorAll('[data-gloom-role="data-table"]')]
+        .filter(isVisible)
+        .forEach((table, tableIndex) => {
+          const tableMetadata = semanticTables[tableIndex] && semanticTables[tableIndex].metadata || {};
+          const semanticColumns = Array.isArray(tableMetadata.columns) ? tableMetadata.columns : [];
+          const semanticRows = Array.isArray(tableMetadata.rows) ? tableMetadata.rows : [];
+          const headers = [...table.querySelectorAll('[data-gloom-role="data-table-header-cell"]')]
+            .map((cell) => normalize(cell.innerText || cell.textContent));
+          const rowElements = [...table.querySelectorAll(
+            '[data-gloom-role="data-table-row"], [data-gloom-role="data-table-section-header"]',
+          )].filter(isVisible);
+          rowElements.forEach((row, rowIndex) => {
+            const cellElements = [...row.querySelectorAll('[data-gloom-role="data-table-cell"]')];
+            const values = cellElements.length > 0 ? cellElements : [row];
+            const semanticRow = semanticRows[rowIndex] || {};
+            const cells = values.map((cell, cellIndex) => {
+              const semanticColumn = semanticColumns[cellIndex] || {};
+              const text = normalize(cell.innerText || cell.textContent);
+              const textNodes = [cell, ...cell.querySelectorAll('*')];
+              if (
+                /\\u2026|\\.\\.\\./.test(text)
+                || textNodes.some((node) => (
+                  node instanceof HTMLElement
+                  && isVisible(node)
+                  && node.scrollWidth > node.clientWidth + 1
+                ))
+              ) {
+                truncationReasons.add("one or more cells are visibly clipped");
+              }
+              return {
+                ...(typeof semanticColumn.id === "string" ? { columnId: semanticColumn.id } : {}),
+                columnLabel: typeof semanticColumn.label === "string"
+                  ? semanticColumn.label
+                  : headers[cellIndex] || (values.length === 1 ? "Row" : String(cellIndex + 1)),
+                text,
+              };
+            }).filter((cell) => cell.text.length > 0);
+            if (cells.length === 0) return;
+            rows.push({
+              tableIndex,
+              rowIndex,
+              ...(typeof semanticRow.key === "string" ? { key: semanticRow.key } : {}),
+              selected: row.getAttribute("data-selected") === "true" || semanticRow.selected === true,
+              cells,
+            });
+          });
+        });
+      if (rows.length === 0) {
+        [...root.querySelectorAll('[data-gloom-role="desktop-list-row"]')]
+          .filter(isVisible)
+          .forEach((row, rowIndex) => {
+            const text = normalize(row.innerText || row.textContent);
+            if (!text) return;
+            rows.push({
+              tableIndex: 0,
+              rowIndex,
+              selected: row.getAttribute("data-selected") === "true",
+              cells: [{ columnLabel: "Row", text }],
+            });
+          });
+      }
       return {
         visibleText: root.innerText || root.textContent || "",
         error: window.__GLOOM_CLI_SHOT_ERROR__ || "",
-        semanticUi: window.__GLOOM_CLI_SHOT_SEMANTIC_UI__ || [],
+        loadingStateDetected: root.querySelector('[data-gloom-status="loading"]') !== null,
+        errorStateDetected: root.querySelector('[data-gloom-status="error"]') !== null,
+        emptyStateDetected: root.querySelector('[data-gloom-status="empty"]') !== null,
+        rows,
+        truncated: truncationReasons.size > 0,
+        truncationReasons: [...truncationReasons],
+        semanticUi,
       };
     })()`,
     returnByValue: true,
@@ -220,6 +538,12 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
       value?: {
         visibleText?: string;
         error?: string;
+        loadingStateDetected?: boolean;
+        errorStateDetected?: boolean;
+        emptyStateDetected?: boolean;
+        rows?: DesktopPaneShotRenderedRow[];
+        truncated?: boolean;
+        truncationReasons?: string[];
         semanticUi?: RemoteUiNodeSnapshot[];
       };
     };
@@ -227,12 +551,26 @@ async function readRenderedPaneState(session: CdpSession): Promise<DesktopPaneSh
   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])
-  )))];
+  const loadingStateMarkers = stateMarkers(visibleText, LOADING_STATE_PATTERNS);
+  const errorStateMarkers = stateMarkers(visibleText, ERROR_STATE_PATTERNS);
+  const emptyStateMarkers = stateMarkers(visibleText, EMPTY_STATE_PATTERNS);
+  const rows = Array.isArray(value?.rows) ? value.rows : [];
+  const textShowsEllipsis = rows.some((row) => row.cells.some((cell) => /\u2026|\.\.\./.test(cell.text)));
+  const truncationReasons = Array.isArray(value?.truncationReasons)
+    ? value.truncationReasons.filter((reason): reason is string => typeof reason === "string")
+    : [];
+  if (textShowsEllipsis && !truncationReasons.includes("one or more cells are visibly clipped")) {
+    truncationReasons.push("one or more cells are visibly clipped");
+  }
   return {
     visibleText,
-    emptyStateDetected: emptyStateMarkers.length > 0,
+    rows,
+    truncated: value?.truncated === true || textShowsEllipsis,
+    truncationReasons,
+    loadingStateDetected: value?.loadingStateDetected === true || loadingStateMarkers.length > 0,
+    errorStateDetected: value?.errorStateDetected === true || errorStateMarkers.length > 0,
+    errorStateMarkers,
+    emptyStateDetected: value?.emptyStateDetected === true || emptyStateMarkers.length > 0,
     emptyStateMarkers,
     semanticUi: Array.isArray(value?.semanticUi) ? value.semanticUi : [],
   };

package/src/cli/index.ts

@@ -121,7 +121,7 @@ function createCoreCliCommands(
       aliases: ["screenshot"],
       description: "Render a desktop-style screenshot for a pane-backed market function",
       help: {
-        usage: ["shot <function-or-pane> [argument] [--output path] [--width px] [--height px] [--key value]"],
+        usage: ["shot <function-or-pane> [argument] [--output path] [--width px] [--height px] [--theme id] [--scale n] [--watermark text] [--key value]"],
       },
       execute: async (args, ctx) => {
         await runPaneScreenshot(args, ctx);