gloomberb 0.9.4 → 0.9.6

package/src/app.tsx

@@ -39,6 +39,8 @@ import { bindPluginRegistryRuntimeAccess } from "./app/runtime/plugin-bindings";
 import { useAppStartupRuntime } from "./app/runtime/startup";
 import { useTickerRefreshRuntime } from "./app/runtime/ticker-refresh";
 import { useAppUpdateRuntime } from "./app/runtime/update";
+import { RemoteControlHost, type RemoteControlAdapter } from "./remote/app-host";
+import { RemoteUiRegistryProvider } from "./remote/semantic-tree";
 import {
   resolveAppSessionSnapshot,
   resolveCliLaunchConfig,
@@ -55,6 +57,7 @@ interface AppInnerProps {
   sessionSnapshot?: AppSessionSnapshot | null;
   desktopWindowBridge?: DesktopWindowBridge;
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
+  remoteControlAdapter?: RemoteControlAdapter;
 }
 
 function ThemedAppRoot({ children }: { children: ReactNode }) {
@@ -83,9 +86,11 @@ function AppInner({
   sessionSnapshot = null,
   desktopWindowBridge,
   desktopApplicationMenuBridge,
+  remoteControlAdapter,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
+  const getRemoteState = useCallback(() => stateRef.current, [stateRef]);
   const config = useAppSelector((state) => state.config);
   const tickers = useAppSelector((state) => state.tickers);
   const paneState = useAppSelector((state) => state.paneState);
@@ -288,6 +293,13 @@ function AppInner({
   if (desktopWindowBridge?.kind === "detached" && desktopWindowBridge.paneId) {
     return (
       <ContextMenuProvider pluginRegistry={pluginRegistry}>
+        <RemoteControlHost
+          adapter={remoteControlAdapter}
+          dispatch={dispatch}
+          getState={getRemoteState}
+          pluginRegistry={pluginRegistry}
+          desktopWindowBridge={desktopWindowBridge}
+        />
         <ThemedAppRoot>
           <DetachedPaneShell
             pluginRegistry={pluginRegistry}
@@ -301,6 +313,13 @@ function AppInner({
 
   return (
     <ContextMenuProvider pluginRegistry={pluginRegistry}>
+      <RemoteControlHost
+        adapter={remoteControlAdapter}
+        dispatch={dispatch}
+        getState={getRemoteState}
+        pluginRegistry={pluginRegistry}
+        desktopWindowBridge={desktopWindowBridge}
+      />
       <ThemedAppRoot>
         <Header />
         <TransientLayoutProvider>
@@ -336,6 +355,7 @@ interface AppProps {
   desktopApplicationMenuBridge?: DesktopApplicationMenuBridge;
   desktopSnapshot?: DesktopSharedStateSnapshot | null;
   desktopThemePreview?: DesktopThemePreviewState | null;
+  remoteControlAdapter?: RemoteControlAdapter;
 }
 
 export function App({
@@ -346,6 +366,7 @@ export function App({
   desktopApplicationMenuBridge,
   desktopSnapshot = null,
   desktopThemePreview = null,
+  remoteControlAdapter,
 }: AppProps) {
   const renderer = useNativeRenderer();
   const effectiveInitialConfig = useMemo(() => {
@@ -413,23 +434,26 @@ export function App({
   }
 
   return (
-    <AppProvider
-      config={config}
-      sessionStore={desktopWindowBridge?.kind === "detached" ? undefined : services.persistence.sessions}
-      sessionSnapshot={sessionSnapshot}
-      desktopBridge={desktopWindowBridge}
-      desktopSnapshot={desktopSnapshot}
-      initialThemePreview={desktopThemePreview}
-    >
-      <AppInner
-        pluginRegistry={services.pluginRegistry}
-        tickerRepository={services.tickerRepository}
-        dataProvider={services.dataProvider}
-        marketData={services.marketData}
+    <RemoteUiRegistryProvider>
+      <AppProvider
+        config={config}
+        sessionStore={desktopWindowBridge?.kind === "detached" ? undefined : services.persistence.sessions}
         sessionSnapshot={sessionSnapshot}
-        desktopWindowBridge={desktopWindowBridge}
-        desktopApplicationMenuBridge={desktopApplicationMenuBridge}
-      />
-    </AppProvider>
+        desktopBridge={desktopWindowBridge}
+        desktopSnapshot={desktopSnapshot}
+        initialThemePreview={desktopThemePreview}
+      >
+        <AppInner
+          pluginRegistry={services.pluginRegistry}
+          tickerRepository={services.tickerRepository}
+          dataProvider={services.dataProvider}
+          marketData={services.marketData}
+          sessionSnapshot={sessionSnapshot}
+          desktopWindowBridge={desktopWindowBridge}
+          desktopApplicationMenuBridge={desktopApplicationMenuBridge}
+          remoteControlAdapter={remoteControlAdapter}
+        />
+      </AppProvider>
+    </RemoteUiRegistryProvider>
   );
 }

package/src/cli/commands/remote.ts

@@ -0,0 +1,206 @@
+import { getDataDir } from "../../data/config/store";
+import type { CliCommandContext, CliCommandDef } from "../../types/plugin";
+import { sendRemoteControlRequest } from "../../remote/client";
+import type { RemoteAppKind, RemoteControlRequest, RemoteControlResponse } from "../../remote/types";
+
+interface RemoteArgs {
+  args: string[];
+  appKind?: RemoteAppKind;
+  expectRev?: string;
+  intervalMs: number;
+}
+
+export const remoteCliCommand: CliCommandDef = {
+  name: "remote",
+  description: "Control a running app through the semantic remote API",
+  help: {
+    usage: [
+      "remote schema [--app tui|desktop]",
+      "remote help [--app tui|desktop]",
+      "remote get <resource> [--app tui|desktop]",
+      "remote call <operation> [json] [--dry-run] [--app tui|desktop]",
+      "remote patch <resource> <json-patch> [--expect-rev rev] [--dry-run] [--app tui|desktop]",
+      "remote batch <json> [--dry-run] [--app tui|desktop]",
+      "remote watch <resource> [--interval ms] [--limit n] [--app tui|desktop]",
+    ],
+  },
+  execute: async (rawArgs, ctx) => {
+    const parsed = parseRemoteArgs(rawArgs);
+    const action = parsed.args[0];
+    if (!action) {
+      ctx.fail("Usage: gloomberb remote <schema|help|get|call|patch|batch|watch>");
+      return;
+    }
+
+    const dataDir = await getDataDir();
+    if (!dataDir) {
+      ctx.fail("No data directory configured.", "Run gloomberb once before using remote control.");
+      return;
+    }
+
+    if (action === "watch") {
+      const resource = parsed.args[1];
+      if (!resource) {
+        ctx.fail("Usage: gloomberb remote watch <resource>");
+        return;
+      }
+      const limit = ctx.cliOptions.limit ?? Number.POSITIVE_INFINITY;
+      for (let index = 0; index < limit; index += 1) {
+        const response = await sendRemoteControlRequest({ type: "get", resource }, {
+          dataDir,
+          appKind: parsed.appKind,
+        });
+        printRemoteResponse(response, ctx);
+        if (index < limit - 1) await new Promise((resolve) => setTimeout(resolve, parsed.intervalMs));
+      }
+      return;
+    }
+
+    const request = buildRemoteRequest(action, parsed, ctx.cliOptions.dryRun);
+    const response = await sendRemoteControlRequest(request, {
+      dataDir,
+      appKind: parsed.appKind,
+    });
+    printRemoteResponse(response, ctx);
+  },
+};
+
+function parseRemoteArgs(rawArgs: string[]): RemoteArgs {
+  const args: string[] = [];
+  let appKind: RemoteAppKind | undefined;
+  let expectRev: string | undefined;
+  let intervalMs = 1_000;
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index]!;
+    if (arg === "--app") {
+      index += 1;
+      appKind = parseAppKind(rawArgs[index]);
+      continue;
+    }
+    if (arg.startsWith("--app=")) {
+      appKind = parseAppKind(arg.slice("--app=".length));
+      continue;
+    }
+    if (arg === "--expect-rev") {
+      index += 1;
+      expectRev = rawArgs[index];
+      if (!expectRev) throw new Error("Missing value for --expect-rev.");
+      continue;
+    }
+    if (arg.startsWith("--expect-rev=")) {
+      expectRev = arg.slice("--expect-rev=".length);
+      continue;
+    }
+    if (arg === "--interval") {
+      index += 1;
+      intervalMs = parseInterval(rawArgs[index]);
+      continue;
+    }
+    if (arg.startsWith("--interval=")) {
+      intervalMs = parseInterval(arg.slice("--interval=".length));
+      continue;
+    }
+    args.push(arg);
+  }
+
+  return { args, appKind, expectRev, intervalMs };
+}
+
+function buildRemoteRequest(action: string, parsed: RemoteArgs, dryRun: boolean): RemoteControlRequest {
+  switch (action) {
+    case "schema":
+      return { type: "schema" };
+    case "help":
+      return { type: "help" };
+    case "get": {
+      const resource = parsed.args[1];
+      if (!resource) throw new Error("Usage: gloomberb remote get <resource>");
+      return { type: "get", resource };
+    }
+    case "call": {
+      const operation = parsed.args[1];
+      if (!operation) throw new Error("Usage: gloomberb remote call <operation> [json]");
+      return {
+        type: "call",
+        operation,
+        input: parseJsonValue(parsed.args[2], {}),
+        dryRun,
+      };
+    }
+    case "patch": {
+      const resource = parsed.args[1];
+      const patchRaw = parsed.args[2];
+      if (!resource || !patchRaw) throw new Error("Usage: gloomberb remote patch <resource> <json-patch>");
+      const patch = parseJsonValue(patchRaw, []);
+      if (!Array.isArray(patch)) throw new Error("Remote patch payload must be a JSON array.");
+      return {
+        type: "patch",
+        resource,
+        patch,
+        expectRev: parsed.expectRev,
+        dryRun,
+      };
+    }
+    case "batch": {
+      const payload = parseJsonValue(parsed.args[1], null);
+      if (!payload) throw new Error("Usage: gloomberb remote batch <json>");
+      if (Array.isArray(payload)) return { type: "batch", requests: payload as RemoteControlRequest[], dryRun };
+      return withCliDryRun(payload as RemoteControlRequest, dryRun);
+    }
+    default:
+      throw new Error(`Unknown remote action "${action}".`);
+  }
+}
+
+function withCliDryRun(request: RemoteControlRequest, dryRun: boolean): RemoteControlRequest {
+  if (!dryRun) return request;
+  if (request.type === "batch") return { ...request, dryRun: true };
+  if (request.type === "call" || request.type === "patch") return { ...request, dryRun: true };
+  return request;
+}
+
+function parseAppKind(value: string | undefined): RemoteAppKind {
+  if (value === "tui" || value === "desktop") return value;
+  throw new Error("--app must be either tui or desktop.");
+}
+
+function parseInterval(value: string | undefined): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 100) {
+    throw new Error("--interval must be an integer >= 100.");
+  }
+  return parsed;
+}
+
+function parseJsonValue<T>(raw: string | undefined, fallback: T): unknown {
+  if (raw == null) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON payload: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function printRemoteResponse(
+  response: RemoteControlResponse,
+  ctx: CliCommandContext,
+): void {
+  if (!response.ok) {
+    const details = response.error.details == null
+      ? undefined
+      : typeof response.error.details === "string"
+        ? response.error.details
+        : JSON.stringify(response.error.details, null, 2);
+    ctx.fail(response.error.message, details);
+    return;
+  }
+  const data = response.state ? { data: response.data, state: response.state } : response.data;
+  ctx.printResult({
+    data,
+    metadata: response.rev ? { rev: response.rev } : undefined,
+    warnings: response.warnings,
+  }, {
+    text: (data) => JSON.stringify(data, null, 2),
+  });
+}

package/src/cli/entry.ts

@@ -2,6 +2,7 @@ import { dispatchCli } from "./index";
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { loadExternalPlugins } from "../plugins/loader";
 import type { CliLaunchRequest } from "../types/plugin";
+import { OPEN_TUI_NATIVE_SMOKE_COMMAND, smokeOpenTuiNative } from "./native-smoke";
 
 async function launchOpenTuiApp(options: {
   externalPlugins: Awaited<ReturnType<typeof loadExternalPlugins>>;
@@ -18,9 +19,15 @@ async function launchOpenTuiApp(options: {
 }
 
 export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise<void> {
-  const externalPlugins = await loadExternalPlugins();
   const command = rawArgs[0];
 
+  if (command === OPEN_TUI_NATIVE_SMOKE_COMMAND) {
+    await smokeOpenTuiNative();
+    return;
+  }
+
+  const externalPlugins = await loadExternalPlugins();
+
   if (!command) {
     await launchOpenTuiApp({ externalPlugins });
     return;

package/src/cli/index.ts

@@ -18,6 +18,7 @@ import { ticker, buildTickerReport } from "./commands/ticker";
 import { apiCliCommand } from "./commands/api";
 import { marketDataCliCommands } from "./commands/market";
 import { overviewCliCommands } from "./commands/overview";
+import { remoteCliCommand } from "./commands/remote";
 import { createSystemCliCommands } from "./commands/system";
 import {
   aiCliCommand,
@@ -188,6 +189,7 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
     apiCliCommand,
     ...marketDataCliCommands,
     ...overviewCliCommands,
+    remoteCliCommand,
     ...createSystemCliCommands(() => commands),
     brokerCliCommand,
     ibkrCliCommand,

package/src/cli/native-smoke.ts

@@ -0,0 +1,5 @@
+export const OPEN_TUI_NATIVE_SMOKE_COMMAND = "__gloomberb-smoke-opentui-native";
+
+export async function smokeOpenTuiNative(): Promise<void> {
+  await import("../renderers/opentui/native-smoke");
+}

package/src/components/chart/core/keyboard.ts

@@ -1,4 +1,13 @@
-export function resolveChartKeyboardKey(event: { name?: string; sequence?: string }): string {
+export function resolveChartKeyboardKey(event: {
+  name?: string;
+  sequence?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  alt?: boolean;
+  super?: boolean;
+}): string {
+  if (event.ctrl || event.meta || event.alt || event.super) return "";
+
   const name = event.name ?? "";
   const sequence = event.sequence ?? "";
   const candidates = [name, sequence];

package/src/components/chart/native/bitmap-support.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import type { NativeRendererHost } from "../../../ui";
+import { shouldRenderNativeBitmap } from "./bitmap-support";
+
+function rendererWithCapabilities(capabilities: unknown): NativeRendererHost {
+  return {
+    terminalWidth: 80,
+    terminalHeight: 24,
+    resolution: null,
+    capabilities,
+    on() {},
+    off() {},
+    requestRender() {},
+    registerLifecyclePass() {},
+    unregisterLifecyclePass() {},
+  };
+}
+
+describe("shouldRenderNativeBitmap", () => {
+  test("skips native bitmaps only when kitty graphics are known unsupported", () => {
+    expect(shouldRenderNativeBitmap(rendererWithCapabilities({ kitty_graphics: false }), true)).toBe(false);
+    expect(shouldRenderNativeBitmap(rendererWithCapabilities({ kitty_graphics: true }), true)).toBe(true);
+    expect(shouldRenderNativeBitmap(rendererWithCapabilities(null), true)).toBe(true);
+    expect(shouldRenderNativeBitmap(rendererWithCapabilities({}), true)).toBe(true);
+    expect(shouldRenderNativeBitmap(rendererWithCapabilities({ kitty_graphics: true }), false)).toBe(false);
+  });
+});

package/src/components/chart/native/bitmap-support.ts

@@ -0,0 +1,55 @@
+import type { NativeRendererHost, PixelResolution } from "../../../ui";
+import { computeBitmapSize } from "./chart-rasterizer";
+
+interface NativeBitmapRendererCapabilities {
+  kitty_graphics?: boolean;
+}
+
+export interface NativeBitmapSize {
+  pixelWidth: number;
+  pixelHeight: number;
+}
+
+function hasKnownUnsupportedKittyGraphics(renderer: NativeRendererHost): boolean {
+  const capabilities = renderer.capabilities as NativeBitmapRendererCapabilities | null | undefined;
+  return capabilities?.kitty_graphics === false;
+}
+
+export function shouldRenderNativeBitmap(renderer: NativeRendererHost, nativeCharts: boolean): boolean {
+  return nativeCharts && !hasKnownUnsupportedKittyGraphics(renderer);
+}
+
+export function resolveNativeBitmapSize({
+  width,
+  height,
+  resolution,
+  terminalWidth,
+  terminalHeight,
+  cellWidthPx,
+  cellHeightPx,
+  pixelRatio,
+}: {
+  width: number;
+  height: number;
+  resolution: PixelResolution | null;
+  terminalWidth: number;
+  terminalHeight: number;
+  cellWidthPx: number;
+  cellHeightPx: number;
+  pixelRatio: number;
+}): NativeBitmapSize {
+  if (resolution && terminalWidth > 0 && terminalHeight > 0) {
+    return computeBitmapSize(
+      { x: 0, y: 0, width, height },
+      resolution,
+      terminalWidth,
+      terminalHeight,
+    );
+  }
+
+  const scale = Math.max(1, pixelRatio);
+  return {
+    pixelWidth: Math.max(1, Math.round(width * cellWidthPx * scale)),
+    pixelHeight: Math.max(1, Math.round(height * cellHeightPx * scale)),
+  };
+}

package/src/components/chart/native/kitty/index.test.ts

@@ -143,6 +143,53 @@ describe("resolveNativeSurfaceVisibleRect", () => {
 
     expect(resolveNativeSurfaceVisibleRect(child, 100, 30)).toBeNull();
   });
+
+  test("stops at repeated ancestors in cyclic native renderable trees", () => {
+    const root: NativeSurfaceRenderableNode = {
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 30,
+      parent: null,
+    };
+    const child: NativeSurfaceRenderableNode = {
+      x: 2,
+      y: 3,
+      width: 20,
+      height: 8,
+      parent: root,
+    };
+    root.parent = child;
+
+    expect(resolveNativeSurfaceVisibleRect(child, 100, 30)).toEqual({
+      x: 2,
+      y: 3,
+      width: 20,
+      height: 8,
+    });
+  });
+
+  test("fails closed when native renderable ancestors exceed a sane depth", () => {
+    let node: NativeSurfaceRenderableNode = {
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 30,
+      parent: null,
+    };
+
+    for (let index = 0; index < 300; index += 1) {
+      node = {
+        x: 0,
+        y: 0,
+        width: 100,
+        height: 30,
+        parent: node,
+      };
+    }
+
+    expect(resolveNativeSurfaceVisibleRect(node, 100, 30)).toBeNull();
+  });
 });
 
 describe("renderNativeChartBase", () => {

package/src/components/chart/native/surface/visibility.ts

@@ -9,6 +9,8 @@ export interface NativeSurfaceRenderableNode {
   parent: NativeSurfaceRenderableNode | null;
 }
 
+const MAX_RENDERABLE_ANCESTOR_DEPTH = 256;
+
 export function getRenderableCellRect(
   renderable: Pick<NativeSurfaceRenderableNode, "x" | "y" | "width" | "height">,
 ): CellRect {
@@ -34,8 +36,13 @@ export function resolveNativeSurfaceVisibleRect(
     height: terminalHeight,
   };
   let current: NativeSurfaceRenderableNode | null = renderable;
+  const seen = new Set<NativeSurfaceRenderableNode>();
+  let depth = 0;
 
-  while (current) {
+  while (current && !seen.has(current)) {
+    if (depth >= MAX_RENDERABLE_ANCESTOR_DEPTH) return null;
+    seen.add(current);
+    depth += 1;
     if (current.visible === false) return null;
 
     const nextVisible = intersectCellRects(visible, getRenderableCellRect(current));

package/src/components/chart/static/bar-chart-surface.test.tsx

@@ -47,6 +47,8 @@ describe("StaticBarChartSurface", () => {
 
     await act(async () => {
       await testSetup!.mockMouse.moveTo(14, 4);
+    });
+    await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });
@@ -86,6 +88,8 @@ describe("StaticBarChartSurface", () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
       await testSetup!.mockMouse.moveTo(14, 4);
+    });
+    await act(async () => {
       await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });

package/src/components/chart/static/chart/bitmap.ts

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import { useNativeRenderer, useUiCapabilities } from "../../../../ui";
-import { computeBitmapSize } from "../../native/chart-rasterizer";
+import { resolveNativeBitmapSize, shouldRenderNativeBitmap } from "../../native/bitmap-support";
 
 export interface StaticChartBitmapSize {
   pixelWidth: number;
@@ -16,20 +16,25 @@ export function useStaticChartBitmapSize(width: number, height: number): StaticC
     pixelRatio = 1,
   } = useUiCapabilities();
   const nativeRenderer = useNativeRenderer();
+  const rendererCapabilities = nativeRenderer.capabilities;
   const rendererResolution = nativeRenderer.resolution;
   const rendererTerminalWidth = nativeRenderer.terminalWidth;
   const rendererTerminalHeight = nativeRenderer.terminalHeight;
 
   return useMemo(() => {
-    if (nativeCharts && rendererResolution && rendererTerminalWidth > 0 && rendererTerminalHeight > 0) {
-      return computeBitmapSize(
-        { x: 0, y: 0, width, height },
-        rendererResolution,
-        rendererTerminalWidth,
-        rendererTerminalHeight,
-      );
+    if (shouldRenderNativeBitmap(nativeRenderer, nativeCharts === true)) {
+      return resolveNativeBitmapSize({
+        width,
+        height,
+        resolution: rendererResolution,
+        terminalWidth: rendererTerminalWidth,
+        terminalHeight: rendererTerminalHeight,
+        cellWidthPx,
+        cellHeightPx,
+        pixelRatio,
+      });
     }
-    if (!canvasCharts && !nativeCharts) return null;
+    if (!canvasCharts) return null;
     const scale = Math.max(1, pixelRatio);
     return {
       pixelWidth: Math.max(1, Math.round(width * cellWidthPx * scale)),
@@ -41,7 +46,9 @@ export function useStaticChartBitmapSize(width: number, height: number): StaticC
     cellWidthPx,
     height,
     nativeCharts,
+    nativeRenderer,
     pixelRatio,
+    rendererCapabilities,
     rendererResolution,
     rendererTerminalHeight,
     rendererTerminalWidth,