gloomberb 0.13.2 → 0.14.0

package/src/renderers/electrobun/view/screenshot-watermark.ts

@@ -0,0 +1,105 @@
+/// <reference lib="dom" />
+
+import { setScreenshotWatermarkVisible } from "../../../utils/screenshot-watermark";
+
+/**
+ * How long the watermark stays after the last screenshot signal. Cmd+Shift+4
+ * still needs a region drag in a system overlay the page never hears about,
+ * so time is the only cue left. A mistaken chord costs a few seconds of faint
+ * wordmark, nothing more.
+ */
+export const SCREENSHOT_WATERMARK_LINGER_MS = 10_000;
+
+/**
+ * Grace after the window regains focus. Cmd+Shift+5 and Win+Shift+S hand
+ * focus to a capture app; the shot is taken while we are blurred, and focus
+ * comes back right after, so the mark only has to survive that hand-back.
+ */
+const REFOCUS_GRACE_MS = 1_500;
+
+export type ScreenshotKeySignal = "show" | "hide" | "keep";
+
+type ScreenshotKeyEventLike = Pick<KeyboardEvent, "key" | "metaKey" | "shiftKey">;
+
+const MODIFIER_KEYS = new Set(["Alt", "AltGraph", "Control", "Fn", "Hyper", "Meta", "OS", "Shift", "Super"]);
+
+/**
+ * Classify a keydown. The OS swallows the final key of its screenshot chords
+ * (Cmd+Shift+3/4/5 on macOS, Win+Shift+S on Windows), so the modifier prefix
+ * is the only part the page ever sees; that prefix reveals the watermark. Any
+ * complete chord that does reach the page is an app shortcut, not a
+ * screenshot, and hides it again. Print Screen is delivered on Windows and on
+ * desktops that do not grab it globally, so it counts as a screenshot outright.
+ */
+export function screenshotKeySignal(event: ScreenshotKeyEventLike): ScreenshotKeySignal {
+  if (event.key === "PrintScreen" || event.key === "Snapshot") return "show";
+  if (MODIFIER_KEYS.has(event.key)) {
+    return event.metaKey && event.shiftKey ? "show" : "keep";
+  }
+  return "hide";
+}
+
+export function installScreenshotWatermark(target: Window = window): () => void {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let visible = false;
+  let blurredWhileVisible = false;
+
+  const clearTimer = () => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+  };
+  const hide = () => {
+    clearTimer();
+    visible = false;
+    blurredWhileVisible = false;
+    setScreenshotWatermarkVisible(false);
+  };
+  const hideAfter = (ms: number) => {
+    clearTimer();
+    timer = setTimeout(hide, ms);
+  };
+  const show = () => {
+    visible = true;
+    setScreenshotWatermarkVisible(true);
+    hideAfter(SCREENSHOT_WATERMARK_LINGER_MS);
+  };
+
+  const onKeyDown = (event: KeyboardEvent) => {
+    const signal = screenshotKeySignal(event);
+    if (signal === "show") show();
+    else if (signal === "hide") hide();
+  };
+  const onKeyUp = (event: KeyboardEvent) => {
+    // Print Screen on Windows often only surfaces as keyup.
+    if (screenshotKeySignal(event) === "show" && !MODIFIER_KEYS.has(event.key)) show();
+  };
+  // Pointer input means the user is back in the app; system capture overlays
+  // keep their own mouse events.
+  const onPointer = () => hide();
+  // A capture app stealing focus is the screenshot in progress: hold the mark
+  // for as long as it keeps focus, then let it fade once we are back.
+  const onBlur = () => {
+    if (!visible) return;
+    blurredWhileVisible = true;
+    clearTimer();
+  };
+  const onFocus = () => {
+    if (blurredWhileVisible) hideAfter(REFOCUS_GRACE_MS);
+  };
+
+  target.addEventListener("keydown", onKeyDown, true);
+  target.addEventListener("keyup", onKeyUp, true);
+  target.addEventListener("mousedown", onPointer, true);
+  target.addEventListener("wheel", onPointer, { capture: true, passive: true });
+  target.addEventListener("blur", onBlur);
+  target.addEventListener("focus", onFocus);
+  return () => {
+    hide();
+    target.removeEventListener("keydown", onKeyDown, true);
+    target.removeEventListener("keyup", onKeyUp, true);
+    target.removeEventListener("mousedown", onPointer, true);
+    target.removeEventListener("wheel", onPointer, { capture: true } as EventListenerOptions);
+    target.removeEventListener("blur", onBlur);
+    target.removeEventListener("focus", onFocus);
+  };
+}

package/src/renderers/electrobun/view/styles.css

@@ -20,6 +20,12 @@ body {
 input, textarea, button { font: inherit; }
 input, textarea { cursor: text; user-select: text; }
 button, [data-gloom-interactive="true"] { cursor: pointer; }
+/* `plain` buttons drop the border, so hover is the only thing left that says
+   the row or chip is clickable. A translucent wash reads the same on the
+   sidebar, a pane body and the status bar. */
+[data-gloom-role="desktop-button"][data-gloom-variant="plain"]:not(:disabled):hover {
+  background-color: color-mix(in srgb, var(--gloom-text-bright) 8%, transparent);
+}
 [data-gloom-hover-bg="true"]:hover {
   background-color: var(--gloom-box-hover-bg) !important;
 }
@@ -582,3 +588,13 @@ body.gloom-dragging [data-gloom-role="chart-surface"] {
     0 14px 34px color-mix(in srgb, var(--gloom-bg) 42%, transparent),
     inset 0 1px 0 color-mix(in srgb, var(--gloom-text-bright) 5%, transparent);
 }
+/* Chart screenshot watermark: mounted by every chart, revealed together by
+   html[data-gloom-screenshot] (pane capture, OS screenshot chords, CLI shots). */
+[data-gloom-role="chart-watermark"] {
+  visibility: hidden;
+  pointer-events: none;
+  opacity: 0.1;
+}
+html[data-gloom-screenshot="true"] [data-gloom-role="chart-watermark"] {
+  visibility: visible;
+}

package/src/renderers/electrobun/view/test-utils.tsx

@@ -0,0 +1,76 @@
+/** @jsxImportSource react */
+import { afterAll, afterEach, beforeAll } from "bun:test";
+import { Window } from "happy-dom";
+import { act, type ReactNode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { UiHostProvider, type RendererHost } from "../../../ui";
+import type { UiHost } from "../../../ui/host";
+import { WebBox } from "./host/box";
+import { WebText, WebSpan } from "./host/text";
+import { WebScrollBox } from "./host/scroll-box";
+import { WebInput } from "./host/input";
+import { WebButton, WebTextField } from "./desktop/controls";
+
+const renderer: RendererHost = {
+  requestExit() {},
+  async openExternal() {},
+  async copyText() {},
+  async readText() { return ""; },
+  notify() {},
+};
+
+const ui = {
+  kind: "desktop-web",
+  capabilities: { cellWidthPx: 8, cellHeightPx: 18, fractionalViewport: true },
+  Box: WebBox, Text: WebText, Span: WebSpan, ScrollBox: WebScrollBox,
+  Button: WebButton, Input: WebInput, TextField: WebTextField,
+  SpinnerMark: () => null,
+} as unknown as UiHost;
+
+/** Each suite owns its DOM, including roots and globals even when an assertion fails. */
+export function createDomTestHarness({ withUi = true } = {}) {
+  const window = new Window({ url: "http://localhost" });
+  const roots = new Set<Root>();
+  const globals = {
+    IS_REACT_ACT_ENVIRONMENT: true,
+    window, document: window.document, navigator: window.navigator,
+    KeyboardEvent: window.KeyboardEvent, MouseEvent: window.MouseEvent,
+    WheelEvent: window.WheelEvent, Event: window.Event,
+    HTMLElement: window.HTMLElement, Node: window.Node,
+    requestAnimationFrame: (callback: (time: number) => void) => window.setTimeout(() => callback(Date.now()), 8),
+    cancelAnimationFrame: (id: NodeJS.Timeout) => window.clearTimeout(id),
+  };
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  beforeAll(() => {
+    for (const [key, value] of Object.entries(globals)) {
+      previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+      Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+    }
+  });
+  afterEach(async () => {
+    await act(async () => {
+      for (const root of roots) root.unmount();
+      roots.clear();
+    });
+    window.document.body.replaceChildren();
+    await window.happyDOM.abort();
+  });
+  afterAll(() => {
+    for (const [key, descriptor] of previous) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+  });
+
+  async function render(node: ReactNode): Promise<HTMLElement> {
+    const container = window.document.createElement("div");
+    window.document.body.appendChild(container);
+    const root = createRoot(container as unknown as HTMLElement);
+    roots.add(root);
+    await act(async () => {
+      root.render(withUi ? <UiHostProvider ui={ui} renderer={renderer}>{node}</UiHostProvider> : node);
+    });
+    return container as unknown as HTMLElement;
+  }
+  return { window, render };
+}

package/src/renderers/electrobun/view/toast-host.test.tsx

@@ -1,21 +1,11 @@
 /** @jsxImportSource react */
-import { Window } from "happy-dom";
-
-const testWindow = new Window({ url: "http://localhost" });
-Object.assign(globalThis, {
-  IS_REACT_ACT_ENVIRONMENT: true,
-  window: testWindow,
-  document: testWindow.document,
-  navigator: testWindow.navigator,
-  HTMLElement: testWindow.HTMLElement,
-  MouseEvent: testWindow.MouseEvent,
-});
-
 import { expect, test } from "bun:test";
 import { act } from "react";
-import { createRoot } from "react-dom/client";
 import { useToastHost, type ToastHost } from "../../../ui/toast";
 import { WebToastHostProvider } from "./toast-host";
+import { createDomTestHarness } from "./test-utils";
+
+const { render: renderDom } = createDomTestHarness({ withUi: false });
 
 let toastHost: ToastHost | null = null;
 
@@ -27,18 +17,13 @@ function ToastViewport() {
 }
 
 test("DOM notifications show context and open from the whole card", async () => {
-  const container = testWindow.document.createElement("div");
-  testWindow.document.body.appendChild(container);
-  const root = createRoot(container as unknown as HTMLElement);
   let opened = 0;
 
-  await act(async () => {
-    root.render(
-      <WebToastHostProvider>
-        <ToastViewport />
-      </WebToastHostProvider>,
-    );
-  });
+  const container = await renderDom(
+    <WebToastHostProvider>
+      <ToastViewport />
+    </WebToastHostProvider>,
+  );
   await act(async () => {
     toastHost?.info("@bob mentioned you", {
       title: "Gloomberb chat",
@@ -72,7 +57,5 @@ test("DOM notifications show context and open from the whole card", async () =>
   expect(opened).toBe(1);
   expect(container.querySelector(".gloom-toast")).toBeNull();
 
-  await act(async () => root.unmount());
-  container.remove();
   toastHost = null;
 });

package/src/renderers/electrobun/view/ui-host.tsx

@@ -73,7 +73,4 @@ export const webRendererHost: RendererHost = {
     }).catch(() => {});
   },
   showContextMenu: showDesktopContextMenu,
-  resolveLiveStream(request) {
-    return backendRequest("media.resolveLiveStream", request);
-  },
 };

package/src/renderers/electrobun/view/window-fullscreen.ts

@@ -0,0 +1,57 @@
+import { setWindowFullscreen } from "../../../components/layout/window-fullscreen";
+import { backendRequest } from "./backend-rpc";
+
+/**
+ * Long enough that dragging a window edge does not ask the host on every
+ * frame, short enough that the header has moved by the time the fullscreen
+ * animation finishes.
+ */
+const RESIZE_SETTLE_MS = 120;
+
+/**
+ * Keeps the view's idea of its window's fullscreen state current. Electrobun
+ * emits no fullscreen event and a webview cannot see its window's style mask,
+ * but entering and leaving fullscreen always resizes the window, so the host
+ * is asked every time the size settles.
+ */
+export function installElectrobunWindowFullscreenTracking(): () => void {
+  let settleTimer: ReturnType<typeof setTimeout> | null = null;
+  let reading = false;
+  let readAgain = false;
+
+  const read = async (): Promise<void> => {
+    if (reading) {
+      readAgain = true;
+      return;
+    }
+    reading = true;
+    try {
+      setWindowFullscreen(await backendRequest("host.windowFullscreen") === true);
+    } catch {
+      // A host too old to answer has the window chrome the header already
+      // assumes, so leaving the last known state alone is the safe read.
+    } finally {
+      reading = false;
+      if (readAgain) {
+        readAgain = false;
+        void read();
+      }
+    }
+  };
+
+  const scheduleRead = (): void => {
+    if (settleTimer) clearTimeout(settleTimer);
+    settleTimer = setTimeout(() => {
+      settleTimer = null;
+      void read();
+    }, RESIZE_SETTLE_MS);
+  };
+
+  window.addEventListener("resize", scheduleRead);
+  void read();
+
+  return () => {
+    window.removeEventListener("resize", scheduleRead);
+    if (settleTimer) clearTimeout(settleTimer);
+  };
+}

package/src/renderers/opentui/interaction-performance.ts

@@ -21,6 +21,8 @@ interface PendingInteraction {
   id: number;
   key: string;
   startedAtMs: number;
+  committedAtMs?: number;
+  renderMs?: number;
 }
 
 export interface InteractionPerformanceSample {
@@ -29,6 +31,12 @@ export interface InteractionPerformanceSample {
   frameId: number;
   inputsInFrame: number;
   latencyMs: number;
+  /** Keypress to the React commit that consumed it. */
+  commitDelayMs: number;
+  /** React render work in that commit, from the Profiler. */
+  renderMs: number;
+  /** Commit to the frame that painted it. */
+  frameDelayMs: number;
   frameCallbackMs: number;
   /** Renderer-wide count shared by every input completed in this frame. */
   cellsUpdated: number;
@@ -45,7 +53,8 @@ export interface InteractionPerformanceSummary {
 export interface InteractionPerformanceRecorder {
   (): void;
   readonly enabled: boolean;
-  markCommit(): void;
+  /** React Profiler `onRender` signature; only `actualDuration` is read. */
+  markCommit(id?: string, phase?: string, actualDurationMs?: number): void;
 }
 
 function round(value: number): number {
@@ -113,6 +122,7 @@ export function installInteractionPerformanceRecorder(
   const pending: PendingInteraction[] = [];
   const samples: InteractionPerformanceSample[] = [];
   let committedCount = 0;
+  let commitCount = 0;
   let nextId = 1;
   let stopped = false;
 
@@ -131,12 +141,16 @@ export function installInteractionPerformanceRecorder(
     const completed = pending.splice(0, committedCount);
     committedCount = 0;
     for (const interaction of completed) {
+      const committedAtMs = interaction.committedAtMs ?? completedAtMs;
       samples.push({
         id: interaction.id,
         key: interaction.key,
         frameId: event.frameId,
         inputsInFrame: completed.length,
         latencyMs: round(completedAtMs - interaction.startedAtMs),
+        commitDelayMs: round(committedAtMs - interaction.startedAtMs),
+        renderMs: round(interaction.renderMs ?? 0),
+        frameDelayMs: round(completedAtMs - committedAtMs),
         frameCallbackMs: round(stats.frameCallbackTime),
         cellsUpdated: stats.cellsUpdated,
         rssBytes,
@@ -162,9 +176,14 @@ export function installInteractionPerformanceRecorder(
         ]),
     );
     const report = {
-      version: 2,
+      version: 3,
       startedAt,
       endedAt: new Date().toISOString(),
+      // The React Profiler is inert in production builds, so a run against
+      // one records no commits and therefore no samples. Saying so here beats
+      // an empty report that looks like a benchmark harness bug.
+      commitSignal: commitCount > 0 ? "profiler" : "none",
+      commitCount,
       summary: summarizeInteractionPerformance(samples),
       byKey,
       unframedInputCount: pending.length,
@@ -177,9 +196,16 @@ export function installInteractionPerformanceRecorder(
   Object.defineProperties(stop, {
     enabled: { value: true },
     markCommit: {
-      value: () => {
+      value: (_id?: string, _phase?: string, actualDurationMs?: number) => {
         // A React Profiler callback runs after host mutations commit. Only
         // inputs present by then may be completed by the following frame.
+        commitCount += 1;
+        const committedAtMs = performance.now();
+        for (let index = committedCount; index < pending.length; index += 1) {
+          const interaction = pending[index]!;
+          interaction.committedAtMs = committedAtMs;
+          interaction.renderMs = actualDurationMs;
+        }
         committedCount = pending.length;
       },
     },

package/src/renderers/opentui/scrollbox-layout.ts

@@ -0,0 +1,35 @@
+import type { BoxRenderable, ScrollBoxRenderable as NativeScrollBoxRenderable } from "@opentui/core";
+import type { ScrollBoxRenderable } from "../../ui/host";
+
+/** Observe computed native content layout after ScrollBox updates its range. */
+export function observeScrollBoxContentSize(
+  scrollBox: ScrollBoxRenderable | null,
+  onSizeChange: () => void,
+): (() => void) | undefined {
+  return observeSizeChange((scrollBox as NativeScrollBoxRenderable | null)?.content, onSizeChange);
+}
+
+/** Scrollbars can resize the viewport without changing the scroll box itself. */
+export function observeScrollBoxViewportSize(
+  scrollBox: ScrollBoxRenderable | null,
+  onSizeChange: () => void,
+): (() => void) | undefined {
+  return observeSizeChange((scrollBox as NativeScrollBoxRenderable | null)?.viewport, onSizeChange);
+}
+
+function observeSizeChange(content: BoxRenderable | undefined, onSizeChange: () => void) {
+  if (!content) return;
+  // Computed layout invokes onSizeChange, not the explicit resize event.
+  // Preserve the internal handler that recalculates the scrollbars.
+  const previousSizeChange = content.onSizeChange;
+  const handleContentSizeChange = () => {
+    previousSizeChange?.call(content);
+    onSizeChange();
+  };
+  content.onSizeChange = handleContentSizeChange;
+  return () => {
+    if (content.onSizeChange === handleContentSizeChange) {
+      content.onSizeChange = previousSizeChange;
+    }
+  };
+}

package/src/renderers/opentui/start.tsx

@@ -7,7 +7,8 @@ import { applyLanguageFromConfig } from "../../i18n";
 import * as nodeConfigStoreHost from "../../data/config/store/node";
 import { loadExternalPlugins } from "../../plugins/loader";
 import { restoreExtractedPlugins } from "../../cli/restore-plugins";
-import { setPluginInstaller } from "../../plugins/builtin/plugin-marketplace/store";
+import { setPluginManager } from "../../plugins/builtin/plugin-marketplace/store";
+import { createNodePluginManager } from "../../plugins/manager-node";
 import { setCurrentPluginTarget } from "../../plugins/current-target";
 import { getLoadablePlugins } from "../../plugins/catalog";
 import { OpenTuiInputHostProvider } from "./input-host";
@@ -24,18 +25,13 @@ import { measurePerfAsync } from "../../utils/perf-marks";
 import type { CliLaunchRequest } from "../../types/plugin";
 import type { RemoteControlAdapter } from "../../remote/app-host";
 import { startRemoteControlServer, type RemoteControlServer } from "../../remote/server";
-import { createPiAiHost } from "../../plugins/builtin/ai/pi";
-import {
-  installAiRunHost,
-} from "../../plugins/builtin/ai/runner";
 import { createAppServices } from "../../core/app-services";
+import { flushPendingPersistence } from "../../state/persist-scheduler";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
 setCurrentPluginTarget("tui");
 
-const AI_STARTUP_READINESS_TIMEOUT_MS = 5_000;
-
 export interface StartOpenTuiAppOptions {
   externalPlugins?: Awaited<ReturnType<typeof loadExternalPlugins>>;
   cliArgs?: string[];
@@ -88,15 +84,7 @@ export async function startOpenTuiApp(options: StartOpenTuiAppOptions = {}): Pro
     await measurePerfAsync("startup.opentui.restore-plugins", restoreExtractedPlugins);
   }
 
-  setPluginInstaller(async (ref) => {
-    try {
-      const { installPlugin } = await import("../../cli/commands/plugins");
-      await installPlugin(ref, { quiet: true });
-      return { ok: true };
-    } catch (error) {
-      return { ok: false, error: error instanceof Error ? error.message : String(error) };
-    }
-  });
+  setPluginManager(createNodePluginManager("tui"));
 
   const externalPlugins = options.externalPlugins ?? await measurePerfAsync("startup.opentui.load-external-plugins", () => loadExternalPlugins("tui"));
   let cliLaunchRequest = options.cliLaunchRequest ?? null;
@@ -115,7 +103,7 @@ export async function startOpenTuiApp(options: StartOpenTuiAppOptions = {}): Pro
     stopMainThreadMonitor();
     if (exitTimer) return;
     exitTimer = setTimeout(() => {
-      process.exit(process.exitCode ?? 0);
+      void flushPendingPersistence().finally(() => process.exit(process.exitCode ?? 0));
     }, 0);
   };
   try {
@@ -130,30 +118,9 @@ export async function startOpenTuiApp(options: StartOpenTuiAppOptions = {}): Pro
 
     const config = await measurePerfAsync("startup.opentui.init-data-dir", () => initDataDir(dataDir));
     applyLanguageFromConfig(config);
-    try {
-      const aiHost = createPiAiHost({
-        appKind: "tui",
-        dataDir: config.dataDir,
-      });
-      await measurePerfAsync(
-        "startup.opentui.ai-catalog",
-        () => installAiRunHost(aiHost, {
-          catalogTimeoutMs: AI_STARTUP_READINESS_TIMEOUT_MS,
-          timeoutMessage: "In-app AI provider discovery timed out during startup",
-          onCatalogError(error) {
-            appLog.warn("In-app AI provider discovery could not finish during startup", {
-              error: error instanceof Error ? error.message : String(error),
-            });
-          },
-        }),
-      );
-    } catch (error) {
-      appLog.warn("In-app AI providers could not be initialized", {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
     host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
-    host.renderer.once("destroy", finishProcessExit);
+    const renderer = host.renderer;
+    renderer.once("destroy", finishProcessExit);
 
     host.render(
       <UiHostProvider ui={openTuiUiHost} renderer={host.rendererHost} nativeRenderer={host.nativeRenderer}>