gloomberb 0.9.4 → 0.9.6

package/src/remote/command-bar.ts

@@ -0,0 +1,98 @@
+import type { AppState } from "../state/app/context";
+import type { RemoteUiNodeSnapshot } from "./types";
+
+export function commandBarResultsFromNodes(nodes: RemoteUiNodeSnapshot[]) {
+  const directResults = nodes
+    .filter((node) => node.role === "command-bar-result")
+    .map((node) => {
+      const metadata = node.metadata ?? {};
+      const item = metadata.item && typeof metadata.item === "object"
+        ? metadata.item as Record<string, unknown>
+        : {};
+      return {
+        nodeId: node.id,
+        index: metadata.index,
+        label: node.label ?? item.label,
+        detail: item.detail,
+        category: item.category,
+        kind: item.kind,
+        right: item.right,
+        selected: metadata.selected === true,
+        disabled: node.disabled === true,
+        actions: node.actions,
+        itemId: item.id,
+        actionInput: undefined,
+        metadata,
+      };
+    });
+
+  const listResults = nodes.flatMap((node) => {
+    const metadata = node.metadata ?? {};
+    if (node.role !== "list" && node.role !== "command-bar-list") return [];
+    if (metadata.scope !== "command-bar") return [];
+    const rawItems = Array.isArray(metadata.items) ? metadata.items : [];
+    const selectedIndex = typeof metadata.selectedIndex === "number" ? metadata.selectedIndex : -1;
+    return rawItems
+      .map((entry, fallbackIndex) => (
+        entry && typeof entry === "object"
+          ? entry as Record<string, unknown>
+          : { label: String(entry), index: fallbackIndex }
+      ))
+      .map((item, fallbackIndex) => {
+        const index = typeof item.index === "number" ? item.index : fallbackIndex;
+        return {
+          nodeId: node.id,
+          index,
+          label: item.label,
+          detail: item.detail,
+          category: item.category ?? metadata.category,
+          kind: item.kind ?? metadata.itemKind,
+          right: item.right,
+          selected: selectedIndex === index,
+          disabled: item.disabled === true || node.disabled === true,
+          actions: node.actions,
+          itemId: item.id,
+          actionInput: {
+            index,
+            id: item.id,
+            label: item.label,
+          },
+          metadata: {
+            ...metadata,
+            item,
+          },
+        };
+      });
+  });
+
+  return [...directResults, ...listResults].sort((left, right) => {
+    const leftIndex = typeof left.index === "number" ? left.index : Number.MAX_SAFE_INTEGER;
+    const rightIndex = typeof right.index === "number" ? right.index : Number.MAX_SAFE_INTEGER;
+    return leftIndex - rightIndex;
+  });
+}
+
+export function isCommandBarInputNode(node: RemoteUiNodeSnapshot): boolean {
+  return (
+    (node.role === "input" || node.role === "command-bar-input")
+    && node.metadata?.scope === "command-bar"
+  );
+}
+
+function commandBarInputValue(nodes: RemoteUiNodeSnapshot[], fallback: string): string {
+  const focusedInput = nodes.find((node) => isCommandBarInputNode(node) && node.metadata?.focused === true);
+  const value = focusedInput?.metadata?.value;
+  return typeof value === "string" ? value : fallback;
+}
+
+export function commandBarSnapshot(state: AppState, nodes: RemoteUiNodeSnapshot[]) {
+  const results = commandBarResultsFromNodes(nodes);
+  return {
+    open: state.commandBarOpen,
+    query: commandBarInputValue(nodes, state.commandBarQuery),
+    stateQuery: state.commandBarQuery,
+    launchRequest: state.commandBarLaunchRequest,
+    selectedIndex: results.find((result) => result.selected)?.index ?? null,
+    results,
+  };
+}

package/src/remote/controller-utils.ts

@@ -0,0 +1,111 @@
+import { getDockedPaneIds } from "../plugins/pane-manager";
+import type { AppState } from "../state/app/context";
+import type { LayoutConfig, PaneInstanceConfig } from "../types/config";
+import { revisionFor } from "./revision";
+import type { RemoteControlResponse, RemoteIncludedState, RemoteStateInclude } from "./types";
+
+export interface PatchTarget<T> {
+  value: T;
+  apply(value: T): Promise<void> | void;
+}
+
+export function ok<T>(data: T, rev?: string, state?: RemoteIncludedState): RemoteControlResponse<T> {
+  return {
+    ok: true,
+    data,
+    ...(rev ? { rev } : {}),
+    ...(state ? { state } : {}),
+  };
+}
+
+export function fail(code: string, error: unknown): RemoteControlResponse {
+  return {
+    ok: false,
+    error: {
+      code,
+      message: error instanceof Error ? error.message : String(error),
+    },
+  };
+}
+
+export function asRecord(input: unknown): Record<string, unknown> {
+  return input && typeof input === "object" && !Array.isArray(input) ? input as Record<string, unknown> : {};
+}
+
+export function stringInput(input: Record<string, unknown>, key: string): string {
+  const value = input[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${key} is required.`);
+  }
+  return value;
+}
+
+export function optionalString(input: Record<string, unknown>, key: string): string | undefined {
+  const value = input[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export function numberInput(input: Record<string, unknown>, key: string): number {
+  const value = input[key];
+  if (!Number.isInteger(value)) {
+    throw new Error(`${key} must be an integer.`);
+  }
+  return value as number;
+}
+
+export function optionalNumber(input: Record<string, unknown>, key: string): number | undefined {
+  const value = input[key];
+  return Number.isInteger(value) ? value as number : undefined;
+}
+
+export function activeLayoutRev(state: AppState): string {
+  return revisionFor({
+    layout: state.config.layout,
+    paneState: state.paneState,
+    focusedPaneId: state.focusedPaneId,
+    activePanel: state.activePanel,
+  });
+}
+
+export function panePlacement(layout: LayoutConfig, instanceId: string): "docked" | "floating" | "detached" | "hidden" {
+  if (getDockedPaneIds(layout).includes(instanceId)) return "docked";
+  if (layout.floating.some((entry) => entry.instanceId === instanceId)) return "floating";
+  if ((layout.detached ?? []).some((entry) => entry.instanceId === instanceId)) return "detached";
+  return "hidden";
+}
+
+export function paneSnapshot(state: AppState, pane: PaneInstanceConfig) {
+  return {
+    ...pane,
+    placement: panePlacement(state.config.layout, pane.instanceId),
+    focused: state.focusedPaneId === pane.instanceId,
+    runtimeState: state.paneState[pane.instanceId] ?? {},
+  };
+}
+
+export function mutationSummary(state: AppState, extra: Record<string, unknown> = {}) {
+  return {
+    ok: true,
+    rev: activeLayoutRev(state),
+    activeLayoutIndex: state.config.activeLayoutIndex,
+    activeLayoutName: state.config.layouts[state.config.activeLayoutIndex]?.name ?? null,
+    focusedPaneId: state.focusedPaneId,
+    commandBarOpen: state.commandBarOpen,
+    commandBarQuery: state.commandBarQuery,
+    dockedPaneIds: getDockedPaneIds(state.config.layout),
+    floatingPaneIds: state.config.layout.floating.map((entry) => entry.instanceId),
+    detachedPaneIds: (state.config.layout.detached ?? []).map((entry) => entry.instanceId),
+    ...extra,
+  };
+}
+
+export function normalizeIncludes(
+  include: RemoteStateInclude[] | undefined,
+  defaults: RemoteStateInclude[] = [],
+): RemoteStateInclude[] {
+  const raw = include ?? defaults;
+  if (raw.includes("all")) {
+    return ["app", "layout", "panes", "commandBar", "ui", "schema", "help"];
+  }
+  return [...new Set(raw)];
+}

package/src/remote/controller.test.ts

@@ -0,0 +1,365 @@
+import { describe, expect, test } from "bun:test";
+import type { Dispatch } from "react";
+import { appReducer, createInitialState, type AppAction, type AppState } from "../core/state/app/state";
+import type { PluginRegistry } from "../plugins/registry";
+import { createDefaultConfig } from "../types/config";
+import { createAppRemoteController } from "./controller";
+import type { RemoteControlSchema, RemoteUiNodeSnapshot } from "./types";
+import type { RemoteUiRegistry } from "./semantic-tree";
+
+function createRegistryHarness() {
+  let state = createInitialState({
+    ...createDefaultConfig("/tmp/gloom-remote-controller"),
+    onboardingComplete: true,
+  });
+  const actions: AppAction[] = [];
+  const dispatch: Dispatch<AppAction> = (action) => {
+    actions.push(action);
+    state = appReducer(state, action);
+  };
+  const registry = {
+    panes: new Map(),
+    paneTemplates: new Map(),
+    commands: new Map(),
+    capabilities: {
+      manifests: () => [],
+      invoke: async () => ({ invoked: true }),
+    },
+    resolvePaneSettings: () => null,
+    showPane: () => {},
+    focusPane: () => {},
+    hidePane: () => {},
+    createPaneFromTemplateAsyncFn: async () => {},
+    navigateTicker: () => {},
+    pinTicker: () => {},
+    selectTicker: () => {},
+    switchTab: () => {},
+    getTermSizeFn: () => ({ width: 120, height: 40 }),
+    updateLayoutFn: (layout: AppState["config"]["layout"]) => {
+      dispatch({ type: "UPDATE_LAYOUT", layout });
+    },
+    applyPaneSettingValueFn: async () => {},
+    notify: () => {},
+  } as unknown as PluginRegistry;
+  let uiNodes: RemoteUiNodeSnapshot[] = [{ id: "ui:test", role: "button", label: "Test", actions: ["press"] }];
+  const invokedUiActions: Array<{ nodeId: string; action: string; input?: unknown }> = [];
+  const uiRegistry: RemoteUiRegistry = {
+    register: () => {},
+    unregister: () => {},
+    snapshot: () => uiNodes,
+    invoke: async (nodeId, action, input) => {
+      invokedUiActions.push({ nodeId, action, input });
+      return { nodeId, action, input };
+    },
+  };
+  const controller = createAppRemoteController({
+    dispatch,
+    getState: () => state,
+    pluginRegistry: registry,
+    uiRegistry,
+  });
+  return {
+    actions,
+    controller,
+    getState: () => state,
+    invokedUiActions,
+    setUiNodes: (nodes: RemoteUiNodeSnapshot[]) => {
+      uiNodes = nodes;
+    },
+  };
+}
+
+describe("createAppRemoteController", () => {
+  test("exposes schema, app snapshot, and semantic UI tree", async () => {
+    const { controller } = createRegistryHarness();
+
+    const schema = await controller.handle({ type: "schema" });
+    expect(schema.ok).toBe(true);
+    if (schema.ok) {
+      const data = schema.data as RemoteControlSchema;
+      expect(data.resources.some((resource) => resource.uri === "ui://tree")).toBe(true);
+      expect(data.operations.some((operation) => operation.id === "ui.invoke")).toBe(true);
+      expect(data.help).toMatchObject({
+        title: "Gloomberb remote control guide",
+      });
+    }
+
+    const help = await controller.handle({ type: "help" });
+    expect(help.ok).toBe(true);
+    if (help.ok) {
+      expect(help.data).toMatchObject({
+        batching: expect.any(Object),
+      });
+    }
+
+    const snapshot = await controller.handle({ type: "get", resource: "app://snapshot" });
+    expect(snapshot.ok).toBe(true);
+    if (snapshot.ok) {
+      const data = snapshot.data as { ui: unknown[] };
+      expect(data.ui).toEqual([{ id: "ui:test", role: "button", label: "Test", actions: ["press"] }]);
+      expect(typeof snapshot.rev).toBe("string");
+    }
+  });
+
+  test("dispatches semantic app operations", async () => {
+    const { actions, controller, getState } = createRegistryHarness();
+
+    const response = await controller.handle({
+      type: "call",
+      operation: "app.openCommandBar",
+      input: { query: "NVDA" },
+    });
+
+    expect(response.ok).toBe(true);
+    expect(actions).toContainEqual({ type: "SET_COMMAND_BAR", open: true, query: "NVDA" });
+    expect(getState().commandBarOpen).toBe(true);
+    expect(getState().commandBarQuery).toBe("NVDA");
+    if (response.ok) {
+      expect(response.state?.commandBar).toMatchObject({
+        open: true,
+        stateQuery: "NVDA",
+      });
+    }
+  });
+
+  test("opens ticker search without requiring command-bar prefix syntax", async () => {
+    const { actions, controller, getState } = createRegistryHarness();
+
+    const response = await controller.handle({
+      type: "call",
+      operation: "app.search",
+      input: { mode: "ticker", query: "google" },
+    });
+
+    expect(response.ok).toBe(true);
+    expect(actions).toContainEqual({
+      type: "SET_COMMAND_BAR",
+      open: true,
+      launch: { kind: "ticker-search", query: "google" },
+    });
+    expect(getState().commandBarOpen).toBe(true);
+    expect(getState().commandBarLaunchRequest).toMatchObject({
+      kind: "ticker-search",
+      query: "google",
+    });
+  });
+
+  test("exposes and activates semantic command-bar results", async () => {
+    const { controller, invokedUiActions, setUiNodes } = createRegistryHarness();
+    setUiNodes([
+      {
+        id: "ui:input",
+        role: "input",
+        actions: ["setValue"],
+        metadata: { value: "T google", focused: true },
+      },
+      {
+        id: "ui:goog",
+        role: "command-bar-result",
+        label: "GOOG",
+        actions: ["activate"],
+        metadata: {
+          index: 1,
+          selected: false,
+          item: {
+            id: "ticker:GOOG",
+            label: "GOOG",
+            detail: "Alphabet Inc.",
+            category: "Primary Listing",
+            kind: "ticker",
+            right: "Equity NASDAQ",
+          },
+        },
+      },
+    ]);
+
+    const results = await controller.handle({ type: "get", resource: "app://command-bar/results" });
+    expect(results.ok).toBe(true);
+    if (results.ok) {
+      expect(results.data).toMatchObject([
+        {
+          nodeId: "ui:goog",
+          index: 1,
+          label: "GOOG",
+          kind: "ticker",
+          right: "Equity NASDAQ",
+        },
+      ]);
+    }
+
+    const activated = await controller.handle({
+      type: "call",
+      operation: "commandBar.activateResult",
+      input: { index: 1 },
+    });
+    expect(activated.ok).toBe(true);
+    expect(invokedUiActions).toContainEqual({ nodeId: "ui:goog", action: "activate", input: undefined });
+  });
+
+  test("scopes command-bar query reads to the command-bar input", async () => {
+    const { controller, setUiNodes } = createRegistryHarness();
+    setUiNodes([
+      {
+        id: "ui:pane-input",
+        role: "input",
+        actions: ["setValue"],
+        metadata: { value: "pane search", focused: true },
+      },
+      {
+        id: "ui:command-input",
+        role: "input",
+        actions: ["setValue"],
+        metadata: { value: "theme", focused: true, scope: "command-bar" },
+      },
+    ]);
+
+    const response = await controller.handle({ type: "get", resource: "app://command-bar" });
+    expect(response.ok).toBe(true);
+    if (response.ok) {
+      expect((response.data as { query: string }).query).toBe("theme");
+    }
+  });
+
+  test("exposes shared list items as command-bar results", async () => {
+    const { controller, invokedUiActions, setUiNodes } = createRegistryHarness();
+    setUiNodes([
+      {
+        id: "ui:theme-list",
+        role: "list",
+        label: "Theme picker",
+        actions: ["activate", "select"],
+        metadata: {
+          scope: "command-bar",
+          selectedIndex: 1,
+          itemKind: "theme",
+          items: [
+            { index: 0, id: "github-dark", label: "GitHub Dark", kind: "theme", category: "Themes" },
+            { index: 1, id: "github-light", label: "GitHub Light", kind: "theme", category: "Themes", current: true },
+          ],
+        },
+      },
+    ]);
+
+    const results = await controller.handle({ type: "get", resource: "app://command-bar/results" });
+    expect(results.ok).toBe(true);
+    if (results.ok) {
+      expect(results.data).toMatchObject([
+        { nodeId: "ui:theme-list", index: 0, label: "GitHub Dark", kind: "theme", itemId: "github-dark" },
+        { nodeId: "ui:theme-list", index: 1, label: "GitHub Light", kind: "theme", itemId: "github-light", selected: true },
+      ]);
+    }
+
+    const activated = await controller.handle({
+      type: "call",
+      operation: "commandBar.activateResult",
+      input: { label: "GitHub Light" },
+    });
+    expect(activated.ok).toBe(true);
+    expect(invokedUiActions).toContainEqual({
+      nodeId: "ui:theme-list",
+      action: "activate",
+      input: { index: 1, id: "github-light", label: "GitHub Light" },
+    });
+  });
+
+  test("invokes semantic UI nodes by selector", async () => {
+    const { controller, invokedUiActions, setUiNodes } = createRegistryHarness();
+    setUiNodes([
+      { id: "ui:cancel", role: "button", label: "Cancel", actions: ["press"] },
+      { id: "ui:done", role: "button", label: "Done", actions: ["press"], metadata: { scope: "command-bar" } },
+    ]);
+
+    const response = await controller.handle({
+      type: "call",
+      operation: "ui.invokeMatching",
+      input: { role: "button", label: "Done", action: "press" },
+    });
+
+    expect(response.ok).toBe(true);
+    expect(invokedUiActions).toContainEqual({ nodeId: "ui:done", action: "press", input: undefined });
+
+    const directResponse = await controller.handle({
+      type: "call",
+      operation: "ui.invoke",
+      input: { nodeId: "ui:done", action: "press" },
+    });
+    expect(directResponse.ok).toBe(true);
+    if (directResponse.ok) {
+      expect(directResponse.data).toMatchObject({
+        ok: true,
+        result: { nodeId: "ui:done", action: "press" },
+      });
+    }
+  });
+
+  test("runs sequential batches with halt-on-error and final state", async () => {
+    const { controller } = createRegistryHarness();
+
+    const response = await controller.handle({
+      type: "batch",
+      include: ["commandBar"],
+      requests: [
+        { type: "call", operation: "app.openCommandBar", input: { query: "theme" } },
+        { type: "call", operation: "missing.operation", input: {} },
+        { type: "call", operation: "app.closeCommandBar", input: {} },
+      ],
+    });
+
+    expect(response.ok).toBe(true);
+    if (response.ok) {
+      expect(response.data).toMatchObject({
+        ok: false,
+        haltedAt: 1,
+      });
+      expect((response.data as { responses: unknown[] }).responses).toHaveLength(2);
+      expect(response.state?.commandBar).toMatchObject({
+        open: true,
+      });
+    }
+  });
+
+  test("patches pane runtime state with replace semantics", async () => {
+    const { controller, getState } = createRegistryHarness();
+    const paneId = getState().config.layout.instances[0]!.instanceId;
+    await controller.handle({
+      type: "call",
+      operation: "pane.setState",
+      input: { paneId, patch: { cursorSymbol: "NVDA", stale: true } },
+    });
+
+    const response = await controller.handle({
+      type: "patch",
+      resource: `app://pane-state/${encodeURIComponent(paneId)}`,
+      patch: [{ op: "remove", path: "/stale" }],
+    });
+
+    expect(response.ok).toBe(true);
+    expect(getState().paneState[paneId]).toMatchObject({ cursorSymbol: "NVDA" });
+    expect(getState().paneState[paneId]?.stale).toBeUndefined();
+  });
+
+  test("closes floating panes and grids visible panes through layout helpers", async () => {
+    const { controller, getState } = createRegistryHarness();
+    expect(getState().config.layout.floating.length).toBeGreaterThan(0);
+
+    const closeResponse = await controller.handle({
+      type: "call",
+      operation: "layout.closeFloating",
+      input: {},
+    });
+    expect(closeResponse.ok).toBe(true);
+    expect(getState().config.layout.floating).toEqual([]);
+
+    const paneIds = getState().config.layout.instances.slice(0, 4).map((pane) => pane.instanceId);
+    const gridResponse = await controller.handle({
+      type: "call",
+      operation: "layout.setGrid",
+      input: { paneIds, columns: 2 },
+    });
+    expect(gridResponse.ok).toBe(true);
+    expect(getState().config.layout.dockRoot).toMatchObject({
+      kind: "split",
+      axis: "vertical",
+    });
+  });
+});