gloomberb 0.18.1 → 0.18.2

package/src/plugins/builtin/broker-trading/dock.tsx

@@ -0,0 +1,182 @@
+import { startTransition, useCallback, useLayoutEffect, useMemo, useRef, useState, type ReactNode } from "react";
+import { PaneFooterScope, usePaneMenuItems } from "../../../components";
+import { usePaneAppConfig, usePaneStateValue } from "../../../state/app/context";
+import { usePluginBrokerActions } from "../../runtime";
+import { useThemeColors } from "../../../theme/theme-context";
+import { Box, Text, useNativeRenderer, useUiCapabilities, type BoxRenderable } from "../../../ui";
+import { capturePointerDrag } from "../../../ui/pointer-drag";
+import { useShortcut } from "../../../react/input";
+import { useDialogState } from "../../../ui/dialog";
+import { ResearchTradingProvider, type ResearchTradeProjection } from "../shared/research-trading";
+import type { BrokerOrder } from "../../../types/trading";
+import { TickerOrdersSection } from "./overview-orders";
+import { createTradeIntent } from "./command";
+import { BrokerTradeTab } from "./pane";
+
+const TRADE_TAB = "broker-trade";
+/** Cells one press of `<` or `>` moves the divider, as in a pane sidebar. */
+const RESIZE_STEP = 4;
+
+/** Default, narrowest and widest ticket beside the chart; null when the pane is too narrow to share. */
+function tradeDockWidths(width: number, native: boolean, cellWidth = 8): { initial: number; min: number; max: number } | null {
+  if (width < (native ? 900 / cellWidth : 100)) return null;
+  const initial = native ? 336 / cellWidth : 34;
+  const min = native ? 280 / cellWidth : 30;
+  // The chart keeps at least half the pane.
+  return { initial, min, max: Math.max(min, Math.floor(width / 2)) };
+}
+
+interface DividerPointerEvent { x?: number; preciseX?: number; preventDefault?(): void; stopPropagation?(): void }
+
+/**
+ * Trade is the chart with the ticket beside it; Chart is the chart alone and
+ * Overview never carries the ticket. b or s on either opens Trade. Below the
+ * width where both fit, Trade is the ticket alone and the Chart tab is the
+ * other half. The ticket stays mounted across tabs once opened, so a draft
+ * survives a look at another tab.
+ */
+export function ResearchTradeWorkspace({ width, height, focused, symbol, tabId, selectTab, onCapture, locked = false, children }: {
+  width: number; height: number; focused: boolean; symbol: string; tabId: string;
+  selectTab(id: string): void; onCapture(captured: boolean): void;
+  /** A pane pinned to one tab (no strip) opens the ticket over that tab instead of switching. */
+  locked?: boolean;
+  /** Renders a research tab: the selected one, or Chart beside the ticket. */
+  children(width: number, focused: boolean, shownTabId?: string): ReactNode;
+}) {
+  const c = useThemeColors();
+  const { nativePaneChrome, cellWidthPx = 8 } = useUiCapabilities();
+  const nativeRenderer = useNativeRenderer();
+  const widths = tradeDockWidths(width, !!nativePaneChrome, cellWidthPx);
+  const [savedWidth, setSavedWidth] = usePaneStateValue<number | null>("brokerTradePanelWidth", null);
+  const [dragWidth, setDragWidth] = useState<number | null>(null);
+  const panelWidth = widths ? Math.min(widths.max, Math.max(widths.min, dragWidth ?? savedWidth ?? widths.initial)) : null;
+  const [intent, setIntent] = usePaneStateValue<string | null>("brokerTradeIntent", null);
+  const [mounted, setMounted] = useState(false);
+  const [lockedOpen, setLockedOpen] = useState(false);
+  const [panelFocused, setPanelFocused] = useState(true);
+  const dialogOpen = useDialogState((state) => state.isOpen);
+  const [projection, publish] = useState<ResearchTradeProjection>({ levels: [] });
+  // A text field in the ticket owns typed keys; otherwise keys the ticket does
+  // not use (zoom, pan, cursor) still reach the chart beside it.
+  const [ticketCaptured, setTicketCaptured] = useState(false);
+  const captureTicket = useCallback((captured: boolean) => { setTicketCaptured(captured); onCapture(captured); }, [onCapture]);
+  const config = usePaneAppConfig();
+  const { getBrokerAdapter } = usePluginBrokerActions();
+  const available = config.brokerInstances.some((profile) => profile.enabled !== false && !!getBrokerAdapter(profile.brokerType)?.placeOrder);
+  const docked = panelWidth !== null;
+  const visible = tabId === TRADE_TAB || locked && lockedOpen;
+  // Layout effect: the tab switches before the mounted ticket's effect takes the intent.
+  useLayoutEffect(() => {
+    if (visible || intent) { setMounted(true); setPanelFocused(true); }
+    if (intent && !visible) { if (locked) setLockedOpen(true); else selectTab(TRADE_TAB); }
+  }, [intent, visible, locked, selectTab]);
+  const openTicket = useCallback((side?: "BUY" | "SELL") => {
+    if (projection.busy) return;
+    if (side) setIntent(createTradeIntent({ action: side }));
+    setMounted(true); setPanelFocused(true);
+    if (locked) setLockedOpen(true); else selectTab(TRADE_TAB);
+  }, [projection.busy, locked, selectTab, setIntent]);
+  // Overview's order opens Trade with that order in the ticket, as the drawer's edit button does.
+  const modifyOrder = useCallback((order: BrokerOrder) => {
+    if (projection.busy) return;
+    setIntent(createTradeIntent({ action: order.action, modify: order })); setMounted(true); setPanelFocused(true);
+    if (locked) setLockedOpen(true); else selectTab(TRADE_TAB);
+  }, [projection.busy, locked, selectTab, setIntent]);
+  const orders = useCallback((ordersWidth: number) => <TickerOrdersSection width={ordersWidth} onModify={modifyOrder} />, [modifyOrder]);
+  const close = useCallback(() => {
+    captureTicket(false); setLockedOpen(false);
+    if (tabId === TRADE_TAB) selectTab("chart");
+  }, [captureTicket, selectTab, tabId]);
+  const split = visible && docked;
+  const ticketFocused = split && panelFocused;
+  const context = useMemo(() => ({ ...projection, symbol, available, docked, visible, ticketFocused, open: openTicket, close, publish, ...(available ? { orders } : {}) }),
+    [projection, symbol, available, docked, visible, ticketFocused, openTicket, close, orders]);
+  useShortcut((event) => {
+    if (event.name !== "f6" || event.repeat) return;
+    event.preventDefault(); event.stopPropagation(); captureTicket(false); setPanelFocused((value) => !value);
+  }, { enabled: focused && split && !dialogOpen, allowEditable: true, phase: "before", scope: "research:trade-focus" });
+  useShortcut((event) => {
+    if (event.name !== "escape" || event.defaultPrevented || event.targetEditable) return;
+    event.preventDefault(); event.stopPropagation(); close();
+  }, { enabled: focused && split && !panelFocused && !dialogOpen, phase: "after", scope: "research:trade-close" });
+
+  // The divider between chart and ticket drags, and < > move it from the keyboard.
+  const dividerRef = useRef<BoxRenderable>(null);
+  const dragOrigin = useRef<{ pointerX: number; width: number } | null>(null);
+  const [dividerActive, setDividerActive] = useState(false);
+  const clampWidth = (next: number) => widths ? Math.min(widths.max, Math.max(widths.min, next)) : next;
+  const dragTo = (event?: DividerPointerEvent) => {
+    const origin = dragOrigin.current;
+    if (!origin) return null;
+    event?.preventDefault?.(); event?.stopPropagation?.();
+    const pointerX = event?.preciseX ?? event?.x ?? origin.pointerX;
+    // Dragging left widens the ticket on the right.
+    const next = clampWidth(origin.width - (pointerX - origin.pointerX));
+    return nativePaneChrome ? next : Math.round(next);
+  };
+  const dividerHandlers = split ? {
+    onMouseDown: (event?: DividerPointerEvent) => {
+      event?.preventDefault?.(); event?.stopPropagation?.();
+      dragOrigin.current = { pointerX: event?.preciseX ?? event?.x ?? 0, width: panelWidth! };
+      setDividerActive(true);
+      capturePointerDrag(nativeRenderer, dividerRef.current);
+    },
+    onMouseDrag: (event?: DividerPointerEvent) => {
+      const next = dragTo(event);
+      if (next !== null) startTransition(() => setDragWidth(next));
+    },
+    onMouseDragEnd: (event?: DividerPointerEvent) => {
+      const next = dragTo(event);
+      const origin = dragOrigin.current;
+      dragOrigin.current = null;
+      setDividerActive(false);
+      setDragWidth(null);
+      // A click that never moved keeps the width as it was.
+      if (next !== null && next !== origin?.width) setSavedWidth(next);
+    },
+    onMouseOver: () => setDividerActive(true),
+    onMouseOut: () => { if (!dragOrigin.current) setDividerActive(false); },
+  } : {};
+  const stepWidth = useCallback((delta: number) => {
+    if (!widths || panelWidth === null) return;
+    const next = Math.min(widths.max, Math.max(widths.min, panelWidth + delta));
+    if (next !== panelWidth) setSavedWidth(next);
+  }, [widths?.min, widths?.max, panelWidth, setSavedWidth]);
+  useShortcut((event) => {
+    if (event.defaultPrevented || event.targetEditable || event.ctrl || event.meta || event.alt || event.super) return;
+    if (event.name !== "<" && event.name !== ">") return;
+    event.preventDefault(); event.stopPropagation(); stepWidth(event.name === "<" ? RESIZE_STEP : -RESIZE_STEP);
+  }, { enabled: focused && split && !dialogOpen, phase: "before", scope: "research:trade-resize" });
+  usePaneMenuItems("research:trade-focus", () => focused && split ? [
+    { id: "trade-focus", accelerator: "F6", label: panelFocused ? "Focus chart" : "Focus ticket", onSelect: () => setPanelFocused((value) => !value) },
+    { id: "trade-widen", accelerator: "<", label: "Widen trade panel", enabled: panelWidth! < widths!.max, onSelect: () => stepWidth(RESIZE_STEP) },
+    { id: "trade-narrow", accelerator: ">", label: "Narrow trade panel", enabled: panelWidth! > widths!.min, onSelect: () => stepWidth(-RESIZE_STEP) },
+  ] : null, [focused, split, panelFocused, panelWidth, widths?.min, widths?.max, stepWidth]);
+
+  const chartWidth = split ? width - panelWidth! : width;
+  const contentWidth = (split ? panelWidth! : width) - (split ? nativePaneChrome ? 1 / cellWidthPx : 1 : 0);
+  const dividerColor = dividerActive ? c.borderFocused : c.border;
+  return <ResearchTradingProvider value={context}>
+    <Box flexDirection="row" width={width} height={height} overflow="hidden">
+      <Box visible={!visible || split} width={chartWidth} height={height} flexDirection="column" overflow="hidden" onMouseDown={() => setPanelFocused(false)}>
+        <PaneFooterScope active={!visible || !panelFocused}>{children(chartWidth, focused && (!visible || !panelFocused || split && !ticketCaptured), split && !locked ? "chart" : undefined)}</PaneFooterScope>
+      </Box>
+      {mounted ? <Box visible={visible} position="relative" onMouseDown={() => setPanelFocused(true)} width={split ? panelWidth! : width} height={height} flexShrink={0} flexDirection="row">
+        {split && !nativePaneChrome ? <Box ref={dividerRef} width={1} height={height} flexDirection="column" flexShrink={0} {...dividerHandlers}>
+          {Array.from({ length: height }, (_, index) => <Text key={index} fg={dividerColor} selectable={false}>│</Text>)}
+        </Box> : null}
+        {split && nativePaneChrome ? <>
+          <Box position="absolute" top={0} left={0} width={1} height={height} style={{ width: 1, height: "100%", backgroundColor: dividerColor, pointerEvents: "none" }} />
+          {/* A 1px line is too thin to grab, so the handle straddles it. */}
+          <Box ref={dividerRef} position="absolute" top={0} left={0} width={1} height={height} title="Resize trade panel (< >)" {...dividerHandlers}
+            style={{ width: 7, left: -3, height: "100%", zIndex: 3, cursor: "col-resize" }} />
+        </> : null}
+        <Box flexDirection="column" width={contentWidth} height={height} flexGrow={1}>
+          <PaneFooterScope active={visible && panelFocused}>
+            <BrokerTradeTab width={contentWidth} height={height} focused={focused && visible && panelFocused} onCapture={captureTicket} docked={split} onClose={close} />
+          </PaneFooterScope>
+        </Box>
+      </Box> : null}
+    </Box>
+  </ResearchTradingProvider>;
+}

package/src/plugins/builtin/broker-trading/headless.ts

@@ -0,0 +1,76 @@
+import type { BrokerAdapter } from "../../../types/broker";
+import type { HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneColumn } from "../../../types/headless";
+import { brokerOrderStatus, loadBrokerOrdersSnapshot } from "./orders-data";
+
+type BrokerResolver = (brokerType: string, context: HeadlessPaneContext) => BrokerAdapter | null;
+
+const orderColumns: HeadlessPaneColumn[] = [
+  { key: "symbol", header: "Symbol" }, { key: "side", header: "Side" }, { key: "status", header: "Status" },
+  { key: "quantity", header: "Quantity", align: "right" }, { key: "filled", header: "Filled", align: "right" },
+  { key: "orderType", header: "Type" }, { key: "limitPrice", header: "Limit", align: "right" },
+  { key: "stopPrice", header: "Stop", align: "right" }, { key: "updatedAt", header: "Updated" },
+];
+const activityColumns: HeadlessPaneColumn[] = [
+  { key: "symbol", header: "Symbol" }, { key: "side", header: "Side" },
+  { key: "quantity", header: "Quantity", align: "right" }, { key: "price", header: "Price", align: "right" },
+  { key: "commission", header: "Fees", align: "right" }, { key: "time", header: "Time" },
+];
+const isoTime = (value: number) => Number.isFinite(value) && value > 0 ? new Date(value).toISOString() : null;
+
+function ordinal(value: unknown, count: number, label: string): number {
+  if (value === undefined && count === 1) return 0;
+  if (value === undefined) throw new Error(`Choose ${label === "account" ? "an" : "a"} ${label} with --${label} (1 to ${count}).`);
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > count) throw new Error(`The ${label} must be between 1 and ${count}.`);
+  return value - 1;
+}
+
+function createBrokerOrdersHeadless(
+  resolveBroker: BrokerResolver = (type, context) => context.resolveBroker?.(type) ?? null,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle", argument: { kind: "none" },
+    description: "Read open orders and recent activity for one connected broker account.",
+    discovery: { id: "broker-orders", aliases: ["orders", "executions"], screenshotReadiness: "live-dom" },
+    options: [
+      { key: "profile", type: "integer", minimum: 1, description: "Broker profile number, required when more than one is available." },
+      { key: "account", type: "integer", minimum: 1, description: "Account number, required when the profile has more than one account." },
+      { key: "view", type: "enum", values: [{ value: "all" }, { value: "open" }, { value: "activity" }], defaultValue: "all", description: "Orders, activity, or both." },
+    ],
+    async load(args, context) {
+      context.signal.throwIfAborted();
+      const profiles = context.config.brokerInstances.filter((profile) => profile.enabled !== false)
+        .map((instance) => ({ instance, broker: resolveBroker(instance.brokerType, context) }))
+        .filter((row): row is { instance: typeof row.instance; broker: BrokerAdapter } => !!row.broker && !!(row.broker.listOpenOrders || row.broker.listExecutions));
+      if (!profiles.length) throw new Error("Connect a broker profile that reports orders in Brokers first.");
+      const { instance, broker } = profiles[ordinal(args.options.profile, profiles.length, "profile")]!;
+      if (!broker.listAccounts) throw new Error("This broker does not report account identities.");
+      const accounts = await broker.listAccounts(instance);
+      context.signal.throwIfAborted();
+      if (!accounts.length) throw new Error("This broker profile has no available accounts.");
+      const account = accounts[ordinal(args.options.account, accounts.length, "account")]!;
+      const data = await loadBrokerOrdersSnapshot(broker, instance, account.accountId, context.signal);
+      const view = args.options.view ?? "all";
+      const mode = account.tradingMode === "simulation" ? "SIMULATION" : account.tradingMode === "live" ? "LIVE" : "UNKNOWN";
+      return {
+        sections: [
+          { title: "Account", entries: [{ label: "Broker", value: broker.name }, { label: "Account", value: account.name }, { label: "Mode", value: mode }] },
+          ...(view !== "activity" ? [{ title: "Open orders", columns: orderColumns, rows: data.orders.map((order) => ({
+            symbol: order.contract.localSymbol || order.contract.symbol, side: order.action, status: brokerOrderStatus(order.status),
+            quantity: order.quantity, filled: order.filled, orderType: order.orderType,
+            limitPrice: order.limitPrice ?? null, stopPrice: order.stopPrice ?? null,
+            updatedAt: isoTime(order.updatedAt),
+          })) }] : []),
+          ...(view !== "open" ? [{ title: data.executionKind === "order-summaries" ? "Cumulative order summaries" : "Recent activity", columns: activityColumns,
+            rows: data.executions.map((execution) => ({ symbol: execution.contract.localSymbol || execution.contract.symbol,
+              side: execution.side, quantity: execution.shares, price: execution.price,
+              commission: execution.commission ?? null, commissionCurrency: execution.commissionCurrency ?? null,
+              time: isoTime(execution.time) })) }] : []),
+        ],
+        complete: data.errors.length === 0, errors: data.errors, notes: data.notes,
+        freshness: { source: broker.name, status: "not-a-feed", basis: "broker account snapshot", asOf: data.updatedAt, oldest: null },
+      };
+    },
+  };
+}
+
+export const brokerOrdersHeadless = createBrokerOrdersHeadless();

package/src/plugins/builtin/broker-trading/index.tsx

@@ -0,0 +1,77 @@
+import type { PluginModule } from "../plugin-module";
+import { brokerOrdersHeadless } from "./headless";
+import { BrokerOrdersPane, BrokerTradeTab } from "./pane";
+import { brokerCanTrade, createTradeCommand, openTradeTicket } from "./command";
+import { brokerOrderFeed } from "./order-feed";
+import { tickerSecType } from "./pane-model";
+
+/** Every enabled trading profile's orders, held for as long as the app runs: its fills toast with no ticket open. */
+let releaseHeldOrders: (() => void) | undefined;
+
+/** A ticker without a saved asset category trades as its research instrument kind says. */
+const INSTRUMENT_CATEGORY: Record<string, string> = { option: "OPT", future: "FUT", bond: "BOND", crypto: "CRYPTO", currency: "CASH" };
+
+/** Trading lives with broker profiles, with one research tab and one orders view. */
+export const brokerTradingModule: PluginModule = {
+  panes: [{
+    id: "broker-orders", name: "Orders", personalData: "account", icon: "O", component: BrokerOrdersPane,
+    defaultPosition: "right", defaultMode: "floating",
+    defaultFloatingSize: { width: 100, height: 30 }, headless: brokerOrdersHeadless,
+    portableShare: { private: { title: true, params: true, settings: true, state: true } },
+  }],
+  paneTemplates: [{
+    id: "broker-orders-pane", paneId: "broker-orders", label: "Orders",
+    description: "Open orders and recent activity for a broker account",
+    keywords: ["orders", "trades", "executions", "cancel", "modify"],
+    shortcut: { prefix: "ORD" }, headless: brokerOrdersHeadless,
+    createInstance: () => ({ placement: "floating" }),
+  }],
+  setup(ctx) {
+    brokerOrderFeed.setNotifier((notification) => { ctx.notify(notification); });
+    let held = new Map<string, { key: string; release(): void }>();
+    // A broker registered by a later plugin, or a profile added or edited, is held from then on.
+    const holdProfiles = () => {
+      const next = new Map<string, { key: string; release(): void }>();
+      for (const instance of ctx.getConfig().brokerInstances) {
+        const broker = instance.enabled === false ? null : ctx.getBrokerAdapter?.(instance.brokerType);
+        if (!broker?.listOpenOrders || !broker.placeOrder) continue;
+        const key = JSON.stringify([broker.id, instance.config]);
+        const current = held.get(instance.id);
+        if (current?.key === key) { next.set(instance.id, current); held.delete(instance.id); continue; }
+        next.set(instance.id, { key, release: brokerOrderFeed.hold(broker, instance) });
+      }
+      for (const stale of held.values()) stale.release();
+      held = next;
+    };
+    const unsubscribe = [ctx.on("config:changed", holdProfiles), ctx.on("plugin:registered", holdProfiles)];
+    holdProfiles();
+    releaseHeldOrders = () => {
+      for (const stop of unsubscribe) stop();
+      for (const entry of held.values()) entry.release();
+      held.clear();
+      brokerOrderFeed.setNotifier(undefined);
+      brokerOrderFeed.clear();
+    };
+    const supported = (symbol: string, secType = "STK") => brokerCanTrade(ctx.getConfig().brokerInstances, (type) => ctx.getBrokerAdapter?.(type), symbol, secType);
+    ctx.registerTickerResearchTab({
+      id: "broker-trade", name: "Trade", order: 20, component: BrokerTradeTab,
+      instruments: ["equity", "fund", "option", "future", "bond", "crypto", "currency", "other"],
+      isVisible: ({ ticker, instrumentKind }) => supported(ticker?.metadata.ticker ?? "", tickerSecType(ticker?.metadata.assetCategory, INSTRUMENT_CATEGORY[instrumentKind])),
+    });
+    for (const side of ["BUY", "SELL"] as const) {
+      ctx.registerCommand(createTradeCommand(ctx, side, supported));
+      ctx.registerTickerAction({
+        id: `broker-${side.toLowerCase()}`, label: side === "BUY" ? "Buy" : "Sell",
+        keywords: [side.toLowerCase(), "trade", "order", "broker"],
+        filter: (ticker) => supported(ticker.metadata.ticker, tickerSecType(ticker.metadata.assetCategory)),
+        execute: (ticker) => {
+          openTradeTicket(ctx, ticker.metadata.ticker, { action: side });
+        },
+      });
+    }
+  },
+  dispose() {
+    releaseHeldOrders?.();
+    releaseHeldOrders = undefined;
+  },
+};