gloomberb 0.16.4 → 0.16.6

package/src/components/layout/shell/menu.ts

@@ -9,6 +9,7 @@ import type { PluginRegistry } from "../../../plugins/registry";
 import type { LayoutConfig } from "../../../types/config";
 import { isPaneLocked, setPaneLocked } from "../../../pane-settings";
 import { contextMenuDivider, type ContextMenuItem } from "../../../types/context-menu";
+import { pluginContextMenuSlot } from "../../../ui/context-menu";
 import { paneHintTitle, type CombinedPaneFooter } from "../pane/footer/model";
 import {
   formatPlatformShortcutLabel,
@@ -102,6 +103,10 @@ export function menuForPane(
   fullscreen?: { active: boolean; toggle: () => void },
   paneItems: ContextMenuItem[] = [],
   layoutMove: PaneMenuLayoutMove = {},
+  /** The pane's entry in DOCS, the same as the `?` in its header. */
+  openDocs?: () => void,
+  /** A new Ask Gloom conversation with this pane attached, the same as the button beside the `?`. */
+  askGloom?: () => void,
 ): ContextMenuItem[] {
   const baseActions: ContextMenuItem[] = [...paneItems];
   if (baseActions.length > 0) baseActions.push(contextMenuDivider("pane:own-actions-divider"));
@@ -122,10 +127,16 @@ export function menuForPane(
       onSelect: () => openPaneSettings(pane.instance.instanceId),
     });
   }
+  if (openDocs) {
+    baseActions.push({ id: "pane-docs", label: "Docs", onSelect: openDocs });
+  }
+  if (askGloom) {
+    baseActions.push({ id: "ask-gloom", label: "Ask Gloom", accelerator: accelerators.ask, onSelect: askGloom });
+  }
   if (sharePane) {
     baseActions.push({
       id: "share-pane",
-      label: "Share Pane",
+      label: "Share",
       accelerator: accelerators.share,
       onSelect: sharePane,
     });
@@ -146,6 +157,8 @@ export function menuForPane(
       onSelect: () => exportPaneCsv(pane.instance.instanceId),
     });
   }
+  // Plugin actions sit with sharing and exporting.
+  baseActions.push(pluginContextMenuSlot("pane"));
 
   if (fullscreen) {
     baseActions.push({

package/src/components/layout/shell/native/pointer-runtime.ts

@@ -2,6 +2,7 @@ import { useCallback, type Dispatch, type SetStateAction } from "react";
 import type { DockDividerLayout, FloatingRect, LayoutBounds } from "../../../../layout/pane-manager";
 import type { ActionMenuState } from "../action-menu-overlay";
 import type { ShellDragRuntimeState, ShellMouseEvent } from "../drag/runtime";
+import type { ResizeEdges } from "../drag";
 import type { WindowEditState } from "../../window-edit/mode";
 
 interface UseShellNativePointerRuntimeOptions {
@@ -119,7 +120,7 @@ export function useShellNativePointerRuntime({
     event.preventDefault();
   }, [commandBarOpen, focusNativePane, getShellPointer, nativePaneChrome, startDrag, transientFocusActive, windowMode]);
 
-  const startNativeFloatResize = useCallback((paneId: string, rect: FloatingRect, event: ShellMouseEvent) => {
+  const startNativeFloatResize = useCallback((paneId: string, rect: FloatingRect, event: ShellMouseEvent, edges?: ResizeEdges) => {
     if (!nativePaneChrome) return;
     if (commandBarOpen) return;
     if (transientFocusActive) return;
@@ -136,6 +137,7 @@ export function useShellNativePointerRuntime({
       startX: pointer.x,
       startY: pointer.y,
       origRect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+      edges,
     });
     updateDragFloatingRect({ paneId, rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } });
     event.stopPropagation();

package/src/components/layout/shell/pane/actions.ts

@@ -1,4 +1,4 @@
-import { useCallback } from "react";
+import { useCallback, useState } from "react";
 import type { DesktopWindowBridge } from "../../../../types/desktop-window";
 import {
   applyDrop,
@@ -15,6 +15,7 @@ import { isPaneLockedInLayout } from "../../../../pane-settings";
 import type { RendererHost } from "../../../../ui";
 import { capturePaneScreenshotPngBase64 } from "../../../../utils/dom-screenshot";
 import { fireAndForget } from "../../../../utils/fire-and-forget";
+import { createOneShots } from "../../../../utils/one-shot";
 import {
   exportPaneTableCsv,
   hasPaneTableExporter,
@@ -64,6 +65,10 @@ export function useShellPaneActions({
   visibleLayout,
   width,
 }: UseShellPaneActionsOptions) {
+  // Actions with a side effect outside the layout (the clipboard, a file, a new
+  // window) refuse a second trigger while one runs and for a moment after, from
+  // a held key, a native menu accelerator or a double press alike.
+  const [shots] = useState(createOneShots);
   const openPaneSettings = useCallback((paneId: string) => {
     pluginRegistry.openPaneSettings(paneId);
     closePaneMenu();
@@ -71,6 +76,9 @@ export function useShellPaneActions({
 
   const copyPaneScreenshot = useCallback(async (paneId: string) => {
     closePaneMenu();
+    const shot = shots.get("copy-screenshot");
+    if (shot.refuses()) return;
+    shot.start();
     try {
       await new Promise((resolve) => setTimeout(resolve, 0));
       if (!rendererHost.copyPngImage) {
@@ -82,8 +90,10 @@ export function useShellPaneActions({
     } catch (error) {
       const message = error instanceof Error ? error.message : "Could not copy pane screenshot.";
       pluginRegistry.notify({ body: message, type: "error" });
+    } finally {
+      shot.end();
     }
-  }, [closePaneMenu, pluginRegistry, rendererHost]);
+  }, [closePaneMenu, pluginRegistry, rendererHost, shots]);
 
   const canExportPaneCsv = useCallback((paneId: string) => {
     const pane = paneMap.get(paneId);
@@ -94,12 +104,19 @@ export function useShellPaneActions({
     closePaneMenu();
     const pane = paneMap.get(paneId);
     if (!pane) return;
-    await exportPaneTableCsv(
-      paneId,
-      pane.instance.title ?? pane.def.name,
-      pluginRegistry.notify,
-    );
-  }, [closePaneMenu, paneMap, pluginRegistry]);
+    const shot = shots.get("export-csv");
+    if (shot.refuses()) return;
+    shot.start();
+    try {
+      await exportPaneTableCsv(
+        paneId,
+        pane.instance.title ?? pane.def.name,
+        pluginRegistry.notify,
+      );
+    } finally {
+      shot.end();
+    }
+  }, [closePaneMenu, paneMap, pluginRegistry, shots]);
 
   const exportFocusedPaneCsv = useCallback(() => {
     if (!focusedPaneId || !canExportPaneCsv(focusedPaneId)) return false;
@@ -161,9 +178,14 @@ export function useShellPaneActions({
   const popOutFocusedPane = useCallback(() => {
     if (!focusedPaneId || desktopWindowBridge?.kind !== "main" || !desktopWindowBridge.popOutPane) return false;
     if (!isPaneInLayout(visibleLayout, focusedPaneId)) return false;
-    fireAndForget(desktopWindowBridge.popOutPane(focusedPaneId), "desktop.popOutPane");
+    const shot = shots.get("pop-out");
+    if (shot.refuses()) return true;
+    shot.start();
+    const request = desktopWindowBridge.popOutPane(focusedPaneId);
+    fireAndForget(request, "desktop.popOutPane");
+    void Promise.resolve(request).then(() => undefined, () => undefined).finally(() => shot.end());
     return true;
-  }, [desktopWindowBridge, focusedPaneId, visibleLayout]);
+  }, [desktopWindowBridge, focusedPaneId, shots, visibleLayout]);
 
   const gridlockVisiblePanes = useCallback(() => {
     tidyWindows({

package/src/components/layout/shell/pane/ask.ts

@@ -0,0 +1,131 @@
+import { useCallback, useSyncExternalStore, type RefObject } from "react";
+import { buildAskGloomPaneAttachment } from "../../../../ask-gloom/pane-context";
+import {
+  askGloomAboutPane,
+  canAskGloomAboutPanes,
+  subscribeAskGloomAboutPanes,
+} from "../../../../ask-gloom/pane-request";
+import { domPaneText, terminalPaneText, type CellRect } from "../../../../ask-gloom/pane-text";
+import type { DockLeafLayout, FloatingRect, LayoutBounds, ResolvedPane } from "../../../../layout/pane-manager";
+import type { PluginRegistry } from "../../../../plugins/registry";
+import { useRemoteUiRegistry, type RemoteUiRegistry } from "../../../../remote/semantic-tree";
+import { resolveTickerForPane, type AppState } from "../../../../state/app/context";
+import { useNativeRenderer } from "../../../../ui";
+import { readRenderableBounds } from "../cursor-occlusion";
+
+interface ShellPaneAskOptions {
+  focusedPaneId: string | null;
+  getPaneTitle: (pane: ResolvedPane) => string;
+  nativePaneChrome: boolean;
+  paneMap: Map<string, ResolvedPane>;
+  pluginRegistry: PluginRegistry;
+  /** What is on screen: in fullscreen, the one pane filling the area. */
+  screenDockLeafLayouts: DockLeafLayout[];
+  screenFloatingPanes: Array<{ pane: ResolvedPane; rect: FloatingRect }>;
+  /** The shell's box: where the pane area starts on the terminal's screen. */
+  shellRef: RefObject<unknown>;
+  stateRef: RefObject<AppState>;
+}
+
+export interface AskAboutPaneOptions {
+  /** Terminal: a surface drawn over the pane when it was asked from, such as its menu. */
+  cover?: LayoutBounds | null;
+}
+
+const DEFAULT_FLOATING_Z = 50;
+
+/**
+ * The tab each strip of the pane has open, outermost first: on the desktop the
+ * primary strip sits in the header, the rest are in the body with the
+ * terminal's, where the semantic tree names their pane.
+ */
+function activePaneTabs(paneId: string, remoteUi: RemoteUiRegistry | null, nativePaneChrome: boolean): string[] {
+  const tabs: string[] = [];
+  if (nativePaneChrome) {
+    const doc = (globalThis as { document?: Document }).document;
+    const header = doc?.querySelector(`[data-gloom-pane-id="${paneId.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"] [data-gloom-role=pane-header-tabs]`);
+    const selected = header?.querySelector("[role=tab][aria-selected=true]")?.textContent?.trim();
+    if (selected) tabs.push(selected);
+  }
+  try {
+    for (const node of remoteUi?.snapshot() ?? []) {
+      if (node.paneId !== paneId || node.role !== "tabs") continue;
+      const metadata = node.metadata as { activeValue?: unknown; tabs?: Array<{ value?: unknown; label?: unknown }> } | undefined;
+      const label = metadata?.tabs?.find((tab) => tab.value === metadata.activeValue)?.label;
+      if (typeof label === "string" && label.trim() && !tabs.includes(label.trim())) tabs.push(label.trim());
+    }
+  } catch {
+    // A node that fails to describe itself leaves the tab out.
+  }
+  return tabs;
+}
+
+/**
+ * Ask Gloom about a pane, from its header button, its menu or the pane-ask
+ * key: describes the pane (its function and arguments, and its text as drawn
+ * now) and hands it to Ask Gloom. Offered only while Ask Gloom takes it.
+ */
+export function useShellPaneAsk({
+  focusedPaneId,
+  getPaneTitle,
+  nativePaneChrome,
+  paneMap,
+  pluginRegistry,
+  screenDockLeafLayouts,
+  screenFloatingPanes,
+  shellRef,
+  stateRef,
+}: ShellPaneAskOptions) {
+  const canAsk = useSyncExternalStore(subscribeAskGloomAboutPanes, canAskGloomAboutPanes, canAskGloomAboutPanes);
+  const nativeRenderer = useNativeRenderer();
+  const remoteUi = useRemoteUiRegistry();
+
+  const readTerminalText = useCallback((paneId: string, cover: LayoutBounds | null | undefined): string | null => {
+    const frame = nativeRenderer.captureFrame?.();
+    if (!frame) return null;
+    const docked = screenDockLeafLayouts.find((leaf) => leaf.instanceId === paneId);
+    const floatingIndex = screenFloatingPanes.findIndex(({ pane }) => pane.instance.instanceId === paneId);
+    const rect = docked?.rect ?? screenFloatingPanes[floatingIndex]?.rect;
+    if (!rect) return null;
+    const z = (index: number) => screenFloatingPanes[index]?.pane.floating?.zIndex ?? DEFAULT_FLOATING_Z;
+    // Floating panes over this one: every one over a docked pane, the higher ones over a floating pane.
+    const covered: CellRect[] = screenFloatingPanes
+      .filter((_, index) => index !== floatingIndex && (docked || z(index) > z(floatingIndex) || (z(index) === z(floatingIndex) && index > floatingIndex)))
+      .map((entry) => entry.rect);
+    if (cover) covered.push(cover);
+    const shell = readRenderableBounds(shellRef.current);
+    return terminalPaneText(frame, rect, { offsetX: shell?.x ?? 0, offsetY: shell?.y ?? 0, covered });
+  }, [nativeRenderer, screenDockLeafLayouts, screenFloatingPanes, shellRef]);
+
+  const askAboutPane = useCallback((paneId: string, options: AskAboutPaneOptions = {}): boolean => {
+    if (!canAskGloomAboutPanes()) return false;
+    const pane = paneMap.get(paneId);
+    if (!pane) return false;
+    const state = stateRef.current;
+    let visibleText: string | null = null;
+    try {
+      visibleText = nativePaneChrome ? domPaneText(paneId) : readTerminalText(paneId, options.cover);
+    } catch {
+      visibleText = null;
+    }
+    const attachment = buildAskGloomPaneAttachment({
+      registry: pluginRegistry,
+      instance: pane.instance,
+      title: getPaneTitle(pane),
+      symbol: resolveTickerForPane(state, paneId),
+      paneState: state.paneState[paneId],
+      config: state.config,
+      tickers: state.tickers,
+      activeTabs: activePaneTabs(paneId, remoteUi, nativePaneChrome),
+      visibleText,
+    });
+    return askGloomAboutPane(attachment);
+  }, [getPaneTitle, nativePaneChrome, paneMap, pluginRegistry, readTerminalText, remoteUi, stateRef]);
+
+  const askAboutFocusedPane = useCallback(
+    () => (focusedPaneId ? askAboutPane(focusedPaneId) : false),
+    [askAboutPane, focusedPaneId],
+  );
+
+  return { canAsk, askAboutPane, askAboutFocusedPane };
+}

package/src/components/layout/shell/pane/capture.ts

@@ -0,0 +1,162 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { createOneShot } from "../../../../utils/one-shot";
+import type { LayoutBounds, ResolvedPane } from "../../../../layout/pane-manager";
+import { getPaneSettings } from "../../../../pane-settings";
+import type { PluginRegistry } from "../../../../plugins/registry";
+import { paneScreenshotScale, PANE_SCREENSHOT_MIN_WIDTH } from "../../../../remote/pane-screenshot";
+import {
+  base64Bytes,
+  formatCaptureStamp,
+  resolvePanePersonalData,
+  type PaneImageCapture,
+} from "../../../../shares/pane-image";
+import { resolveCollectionForPane, resolveTickerForPane, useAppStateRef, type AppState } from "../../../../state/app/context";
+import type { LayoutConfig } from "../../../../types/config";
+import type { PanePersonalDataContext } from "../../../../types/plugin";
+import { useUiCapabilities, type NativeRendererHost } from "../../../../ui";
+import { buildPaneSharePayload } from "../../../../shares/pane";
+import { preparePaneShare } from "../../../../shares/prepare";
+import { shareFocusedPane } from "../../../../shares/flow";
+import { useDialog } from "../../../../ui/dialog";
+import { capturePaneImage as paintPaneImage } from "../../../../utils/dom-screenshot";
+import { setPaneCaptureStamp } from "../../pane/capture-stamp";
+
+/** Under the chat's 5 MB image limit with room to spare; a larger paint is shrunk to fit. */
+const PANE_IMAGE_MAX_BYTES = 4 * 1024 * 1024;
+/** How long the terminal gets to draw the footer as a status line (a frame or two). */
+const TERMINAL_SETTLE_MS = 120;
+
+function nextFrames(count: number): Promise<void> {
+  if (typeof requestAnimationFrame !== "function") return new Promise((resolve) => setTimeout(resolve, 32 * count));
+  return new Promise((resolve) => {
+    const step = (left: number) => (left <= 0 ? resolve() : requestAnimationFrame(() => step(left - 1)));
+    step(count);
+  });
+}
+
+/** What a pane shows now, for its `personalData` rule. */
+function personalDataContext(state: AppState, layout: LayoutConfig, pane: ResolvedPane): PanePersonalDataContext {
+  const paneId = pane.instance.instanceId;
+  return {
+    config: state.config,
+    layout,
+    paneId,
+    paneType: pane.instance.paneId,
+    pane: pane.instance,
+    settings: getPaneSettings(pane.instance),
+    paneState: state.paneState[paneId] ?? {},
+    activeTicker: resolveTickerForPane(state, paneId),
+    activeCollectionId: resolveCollectionForPane(state, paneId),
+    tickers: state.tickers,
+  };
+}
+
+/** Whether the plugin that owns a pane also connects a broker. */
+function ownerConnectsBroker(pluginRegistry: PluginRegistry, paneType: string): boolean {
+  const owner = pluginRegistry.getPanePluginId(paneType);
+  return !!owner && [...pluginRegistry.brokers.keys()].some((brokerType) => pluginRegistry.getBrokerPluginId(brokerType) === owner);
+}
+
+interface UseShellPaneCaptureOptions {
+  appHeaderHeight: number;
+  closePaneMenu: () => void;
+  focusedPaneId: string | null;
+  getPaneTitle: (pane: ResolvedPane) => string;
+  /** The layout the panes are in, for their `personalData` rules. */
+  layout: LayoutConfig;
+  nativePaneChrome: boolean;
+  nativeRenderer: NativeRendererHost;
+  paneMap: Map<string, ResolvedPane>;
+  pluginRegistry: PluginRegistry;
+  /** Where each visible pane sits in the shell, fullscreen and transient focus applied. */
+  screenRects: () => Map<string, LayoutBounds>;
+}
+
+/**
+ * Binds `capturePaneImage` and `promptDialog` for plugins that post a pane's
+ * picture or copy its link. The desktop and the web paint the pane's DOM; the
+ * terminal draws the cells it shows, kitty charts included.
+ */
+export function useShellPaneCapture(options: UseShellPaneCaptureOptions): void {
+  const { pluginRegistry } = options;
+  const dialog = useDialog();
+  // Shared by menu, command, key and plugin calls, including triggers without a repeat flag.
+  const [shareOnce] = useState(createOneShot);
+  const { publicSharing } = useUiCapabilities();
+  const stateRef = useAppStateRef();
+  const latest = useRef(options);
+  latest.current = options;
+
+  const capture = useCallback(async (requestedPaneId?: string): Promise<PaneImageCapture> => {
+    const current = latest.current;
+    const paneId = requestedPaneId ?? current.focusedPaneId;
+    const pane = paneId ? current.paneMap.get(paneId) : undefined;
+    if (!paneId || !pane) throw new Error("Focus a pane to share it.");
+    current.closePaneMenu();
+    await preparePaneShare(paneId);
+    // React state/settings flushed by the pane must land before building the link.
+    await nextFrames(2);
+    const capturedAt = new Date();
+    setPaneCaptureStamp(paneId, formatCaptureStamp(capturedAt));
+    try {
+      let image: Pick<PaneImageCapture, "png" | "width" | "height" | "pixels" | "cells">;
+      if (current.nativePaneChrome) {
+        await nextFrames(2);
+        const shot = await paintPaneImage({
+          instanceId: paneId,
+          scaleFor: (screen) => paneScreenshotScale(screen),
+          maxBytes: PANE_IMAGE_MAX_BYTES,
+          minWidth: PANE_SCREENSHOT_MIN_WIDTH,
+        });
+        image = { png: base64Bytes(shot.pngBase64), width: shot.width, height: shot.height };
+      } else {
+        const rect = current.screenRects().get(paneId);
+        if (!rect || !current.nativeRenderer.capturePaneImage) {
+          throw new Error("Show the pane on screen to share it.");
+        }
+        current.nativeRenderer.requestRender();
+        await new Promise((resolve) => setTimeout(resolve, TERMINAL_SETTLE_MS));
+        image = await current.nativeRenderer.capturePaneImage({
+          x: rect.x,
+          y: rect.y + current.appHeaderHeight,
+          width: rect.width,
+          height: rect.height,
+        });
+      }
+      return {
+        paneId,
+        paneType: pane.instance.paneId,
+        title: current.getPaneTitle(pane),
+        capturedAt: capturedAt.toISOString(),
+        sharePayload: publicSharing ? buildPaneSharePayload(
+          pluginRegistry,
+          latest.current.paneMap.get(paneId)?.instance ?? pane.instance,
+          stateRef.current.paneState[paneId] ?? {},
+          resolveTickerForPane(stateRef.current, paneId),
+          stateRef.current.tickers,
+        ) : null,
+        personalData: resolvePanePersonalData(pane.def, personalDataContext(stateRef.current, current.layout, pane), {
+          ownerConnectsBroker: ownerConnectsBroker(current.pluginRegistry, pane.def.id),
+        }),
+        ...image,
+      };
+    } finally {
+      setPaneCaptureStamp(paneId, null);
+    }
+  }, [pluginRegistry, publicSharing, stateRef]);
+
+  useEffect(() => pluginRegistry.bindHost({
+    sharePane: (requestedPaneId) => {
+      const paneId = requestedPaneId ?? latest.current.focusedPaneId;
+      if (!paneId || shareOnce.refuses()) return;
+      shareOnce.start();
+      // Let a menu/command close before the capture starts. The flow also refuses
+      // a second run for the entire dialog/post, even beyond the cooldown's timeout.
+      setTimeout(() => {
+        void shareFocusedPane(pluginRegistry, paneId).finally(() => shareOnce.end());
+      }, 0);
+    },
+    capturePaneImage: capture,
+    promptDialog: (prompt) => dialog.prompt(prompt),
+  }), [capture, dialog, pluginRegistry, shareOnce]);
+}