gloomberb 0.11.3 → 0.12.0

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

@@ -37,12 +37,13 @@ async function withPaneRuntime<T>(
     registry: PaneFunctionCatalog;
     resolved: ResolvedPaneFunction;
   }) => Promise<T>,
+  settings: { strictHeadlessOptions?: boolean } = {},
 ): Promise<T> {
   const parsed = parsePaneFunctionArgs(args);
   return withMarketData(ctx, async (context) => {
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
-      const resolved = await resolvePaneFunction(registry, context, parsed);
+      const resolved = await resolvePaneFunction(registry, context, parsed, settings);
       return await run({ parsed, context, registry, resolved });
     } finally {
       registry.destroy();
@@ -73,7 +74,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       ctx.printResult({ data: report.data }, {
         text: () => report.text,
       });
-    });
+    }, { strictHeadlessOptions: true });
   });
 }
 
@@ -98,6 +99,9 @@ export async function runPaneScreenshot(args: string[], ctx: CliCommandContext)
         outputPath,
         width: parsed.width,
         height: parsed.height,
+        theme: parsed.theme,
+        scale: parsed.scale,
+        watermark: parsed.watermark,
         options: parsed.options,
       });
       if (parsed.requireBotSafe && !result.usable) {

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

@@ -23,6 +23,12 @@ export interface ParsedPaneFunctionArgs {
   outputPath: string | null;
   width: number;
   height: number;
+  /** Theme id override for screenshots; null keeps the configured theme. */
+  theme: string | null;
+  /** Render scale: 1.5 renders two thirds as many cells at 1.5x size, so text reads larger at the same pixel size. */
+  scale: number;
+  /** Small label drawn in the pane title bar, e.g. a domain; null draws nothing. */
+  watermark: string | null;
   requireBotSafe: boolean;
 }
 
@@ -62,6 +68,9 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
   let outputPath: string | null = null;
   let width = DEFAULT_SHOT_WIDTH;
   let height = DEFAULT_SHOT_HEIGHT;
+  let theme: string | null = null;
+  let scale = 1;
+  let watermark: string | null = null;
   let requireBotSafe = false;
 
   for (let index = 0; index < args.length; index += 1) {
@@ -98,6 +107,12 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
       if (Number.isFinite(parsedHeight)) {
         height = Math.max(MIN_SHOT_HEIGHT, Math.min(MAX_SHOT_HEIGHT, Math.round(parsedHeight)));
       }
+    } else if (normalizedKey === "theme" && value !== true) {
+      theme = value.trim() || null;
+    } else if (normalizedKey === "scale" && value !== true) {
+      scale = parseScale(value);
+    } else if (normalizedKey === "watermark" && value !== true) {
+      watermark = value.trim() || null;
     } else if (normalizedKey === "arguments" && value !== true) {
       Object.assign(options, parseArgumentsOption(value));
     } else {
@@ -107,7 +122,7 @@ export function parsePaneFunctionArgs(args: string[]): ParsedPaneFunctionArgs {
 
   const target = positionals[0]?.trim() ?? "";
   const arg = positionals.slice(1).join(" ").trim();
-  return { target, arg, options, outputPath, width, height, requireBotSafe };
+  return { target, arg, options, outputPath, width, height, theme, scale, watermark, requireBotSafe };
 }
 
 export function parsePaneCatalogArgs(args: string[]): ParsedPaneCatalogArgs {
@@ -165,7 +180,17 @@ export function optionString(options: PaneOptionValues, key: string): string | u
   return value === true || value === undefined ? undefined : String(value);
 }
 
-const RESERVED_OPTION_KEYS = new Set(["output", "out", "o", "width", "height", "arguments", "state"]);
+const RESERVED_OPTION_KEYS = new Set([
+  "output", "out", "o", "width", "height", "theme", "scale", "watermark", "arguments", "state",
+]);
+
+function parseScale(value: string): number {
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed) || parsed < 0.5 || parsed > 4) {
+    throw new Error(`--scale must be a number between 0.5 and 4, got "${value}".`);
+  }
+  return parsed;
+}
 
 export function optionSettings(options: Record<string, string | true>): Record<string, unknown> {
   const settings: Record<string, unknown> = {};

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

@@ -44,6 +44,7 @@ import {
   withShotPriceHistory,
 } from "./data";
 import type { ResolvedPaneFunction } from "./resolver";
+import { buildHeadlessFunctionReport } from "./headless";
 
 export interface PaneFunctionReportData {
   kind: string;
@@ -750,6 +751,9 @@ export async function buildFunctionReport(
   context: MarketContext,
   rawArg: string,
 ): Promise<PaneFunctionReport> {
+  if (resolved.headless) {
+    return buildHeadlessFunctionReport(resolved, context, rawArg);
+  }
   if (isFinancialAnalysisFunction(resolved)) {
     return buildFinancialStatementReport(resolved, context, rawArg);
   }

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

@@ -1,6 +1,11 @@
 import type { PaneInstanceConfig } from "../../types/config";
 import { CHART_COMPOSER_PANE_ID } from "../../types/config";
-import type { PaneDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import type {
+  HeadlessPaneDefinition,
+  PaneDef,
+  PaneTemplateCreateOptions,
+  PaneTemplateDef,
+} from "../../types/plugin";
 import { applyChartComposerCapabilityOptions } from "../../plugins/builtin/chart-composer/cli-options";
 import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec";
 import { normalizeTickerInput } from "../../tickers/search";
@@ -20,6 +25,7 @@ import {
 } from "./options";
 import {
   capabilityPaneSettings,
+  getHeadlessPaneDefinition,
   getPaneFunctionCapability,
   normalizeCapabilityOptions,
   type NormalizedPaneFunctionOptions,
@@ -33,6 +39,7 @@ export interface ResolvedPaneFunction {
   shortcut?: string;
   pane: PaneDef;
   template?: PaneTemplateDef;
+  headless?: HeadlessPaneDefinition;
   instance: PaneInstanceConfig;
   createOptions: PaneTemplateCreateOptions | undefined;
   optionSettings: Record<string, unknown>;
@@ -41,16 +48,24 @@ export interface ResolvedPaneFunction {
 }
 
 async function buildPaneInstance(
-  resolved: Pick<ResolvedPaneFunction, "pane" | "template" | "createOptions" | "optionSettings" | "capability" | "options">,
+  resolved: Pick<ResolvedPaneFunction, "pane" | "template" | "headless" | "createOptions" | "optionSettings" | "capability" | "options">,
   context: MarketContext,
   target: string,
 ): Promise<PaneInstanceConfig> {
-  // A text argument is a phrase, not a symbol: uppercasing it and binding it as
-  // a ticker makes the pane look for a provider for "HIGH GROWTH SOFTWARE".
-  const argKind = resolved.template?.shortcut?.argKind;
+  // Free text is a phrase, not a symbol. Treating it as a ticker makes the
+  // pane look for a provider for values such as "HIGH GROWTH SOFTWARE".
+  const shortcutArgKind = resolved.template?.shortcut?.argKind;
+  const headlessArgKind = resolved.headless?.argument.kind;
+  const fallbackSymbol = headlessArgKind === "free-text" || headlessArgKind === "none"
+    ? null
+    : headlessArgKind === "tickers" || headlessArgKind === "symbol-list"
+      ? normalizeTickerInput(null, cleanTickerInput(target.split(/[,\n]/)[0] ?? ""))
+      : shortcutArgKind === "text"
+        ? null
+        : normalizeTickerInput(null, cleanTickerInput(target));
   const primarySymbol = resolved.createOptions?.symbol
     ?? resolved.createOptions?.symbols?.[0]
-    ?? (argKind === "text" ? null : normalizeTickerInput(null, cleanTickerInput(target)));
+    ?? fallbackSymbol;
   const templateContext = buildTemplateContext(context, primarySymbol ?? null);
   const spec = await resolved.template?.createInstance?.(templateContext, resolved.createOptions) ?? {};
   const instanceId = `${resolved.pane.id}:cli-${slugifyName(target || resolved.pane.id, "pane")}`;
@@ -83,6 +98,7 @@ export async function resolvePaneFunction(
   registry: PaneFunctionCatalog,
   context: MarketContext,
   args: ParsedPaneFunctionArgs,
+  resolutionSettings: { strictHeadlessOptions?: boolean } = {},
 ): Promise<ResolvedPaneFunction> {
   if (!args.target) {
     throw new Error("Usage: gloomberb fn <function-or-pane> [argument] [--key value]");
@@ -106,9 +122,10 @@ export async function resolvePaneFunction(
     throw new Error(`Template "${template?.id}" points at missing pane "${template?.paneId}".`);
   }
   const createOptions = buildCreateOptions(template, args.arg);
+  const headless = getHeadlessPaneDefinition(template, pane);
   const capability = getPaneFunctionCapability(template, pane);
   const normalizedOptions = normalizeCapabilityOptions(capability, args.options, {
-    strict: args.requireBotSafe,
+    strict: args.requireBotSafe || (!!headless && resolutionSettings.strictHeadlessOptions === true),
   });
   const settings = capability.botSafe
     ? {
@@ -126,13 +143,14 @@ export async function resolvePaneFunction(
     shortcut: template?.shortcut?.prefix,
     pane,
     template,
+    ...(headless ? { headless } : {}),
     instance: {} as PaneInstanceConfig,
     createOptions,
     optionSettings: settings,
     capability,
     options: normalizedOptions,
   };
-  resolved.instance = await buildPaneInstance(resolved, context, args.arg || pane.id);
+  resolved.instance = await buildPaneInstance(resolved, context, args.arg);
   return resolved;
 }
 

package/src/cli/pane-functions/screenshot.test.ts

@@ -3,12 +3,15 @@ import type { RemoteUiNodeSnapshot } from "../../remote/types";
 import {
   chartSeriesEvidenceWithinRange,
   chartEvidenceMismatchesFor,
+  isPaneScreenshotUsable,
   missingActiveTabSelections,
+  resolveDesktopShotApiProxy,
   shotDataEvidenceFor,
   shotExpectedText,
   shotPriceHistoryRange,
   shotSemanticRowCount,
   shotUnavailableSymbols,
+  stripDesktopShotCredentials,
   type PaneScreenshotExpectedChartEvidence,
   type PaneScreenshotExpectedSelection,
 } from "./screenshot";
@@ -18,6 +21,79 @@ import type { ResolvedPaneFunction } from "./resolver";
 import { buildCustomChartPreset } from "../../plugins/builtin/chart-composer/presets";
 import { CHART_COMPOSER_PANE_ID } from "../../types/config";
 
+describe("pane screenshot rendered readiness", () => {
+  const rendered = {
+    rowCount: 2,
+    loadingStateDetected: false,
+    errorStateDetected: false,
+    emptyStateDetected: false,
+    complete: true,
+    semanticMismatch: false,
+    requiresStructuredDataEvidence: false,
+    hasStructuredDataEvidence: false,
+  };
+
+  test("requires rows without loading, error, or empty states", () => {
+    expect(isPaneScreenshotUsable(rendered)).toBe(true);
+    expect(isPaneScreenshotUsable({ ...rendered, rowCount: 0 })).toBe(false);
+    expect(isPaneScreenshotUsable({ ...rendered, loadingStateDetected: true })).toBe(false);
+    expect(isPaneScreenshotUsable({ ...rendered, errorStateDetected: true })).toBe(false);
+    expect(isPaneScreenshotUsable({ ...rendered, emptyStateDetected: true })).toBe(false);
+  });
+
+  test("preserves mapped capability completeness and evidence checks", () => {
+    expect(isPaneScreenshotUsable({ ...rendered, complete: false })).toBe(false);
+    expect(isPaneScreenshotUsable({ ...rendered, semanticMismatch: true })).toBe(false);
+    expect(isPaneScreenshotUsable({
+      ...rendered,
+      requiresStructuredDataEvidence: true,
+    })).toBe(false);
+    expect(isPaneScreenshotUsable({
+      ...rendered,
+      requiresStructuredDataEvidence: true,
+      hasStructuredDataEvidence: true,
+    })).toBe(true);
+  });
+});
+
+describe("pane screenshot payload credentials", () => {
+  test("keeps the restored session in the proxy and strips credential fields from page data", () => {
+    const sessionToken = "private-shot-session";
+    const proxy = resolveDesktopShotApiProxy({
+      persistence: {
+        pluginState: {
+          get: (_pluginId: string, key: string) => key === "resume:session"
+            ? { value: { sessionToken }, schemaVersion: 1, updatedAt: 1 }
+            : null,
+        },
+      },
+    } as any);
+    const payload = stripDesktopShotCredentials({
+      config: {
+        theme: "tokyo",
+        pluginConfig: {
+          service: { apiKey: "private-api-key", display: "compact" },
+        },
+        brokerInstances: [{ config: { password: "private-password", region: "US" } }],
+      },
+      paneState: {
+        pane: { pluginState: { service: { accessToken: "private-access", tab: "latest" } } },
+      },
+    });
+
+    expect(proxy.sessionToken).toBe(sessionToken);
+    expect(payload).toEqual({
+      config: {
+        theme: "tokyo",
+        pluginConfig: { service: { display: "compact" } },
+        brokerInstances: [{ config: { region: "US" } }],
+      },
+      paneState: { pane: { pluginState: { service: { tab: "latest" } } } },
+    });
+    expect(JSON.stringify(payload)).not.toContain("private-");
+  });
+});
+
 describe("pane screenshot active-state verification", () => {
   const expected: PaneScreenshotExpectedSelection[] = [
     { control: "statement", label: "Cash Flow" },