gloomberb 0.5.1 → 0.6.0

package/src/renderers/electrobun/bun/core-capabilities.ts

@@ -0,0 +1,328 @@
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import {
+  AI_RUNNER_CAPABILITY_ID,
+  BROKER_CAPABILITY_ID,
+  NOTES_FILES_CAPABILITY_ID,
+  type CapabilityOperation,
+  type PluginCapability,
+} from "../../../capabilities";
+import type { AppServices } from "../../../core/app-services";
+import { getAiProviderDefinitions } from "../../../plugins/builtin/ai/providers";
+import { isAiRunCancelled, runAiPrompt } from "../../../plugins/builtin/ai/runner";
+import type { BrokerAdapter } from "../../../types/broker";
+import type { AppConfig, BrokerInstanceConfig } from "../../../types/config";
+
+const DESKTOP_CORE_PLUGIN_ID = "desktop-core";
+const NOTES_INDEX_FILE = "__quick-notes-index__.json";
+
+const BROKER_INVOKE_OPERATIONS = new Set([
+  "validate",
+  "importPositions",
+  "connect",
+  "disconnect",
+  "getPersistedConfigUpdate",
+  "listAccounts",
+  "searchInstruments",
+  "getTickerFinancials",
+  "getQuote",
+  "getPriceHistory",
+  "getPriceHistoryForResolution",
+  "getDetailedPriceHistory",
+  "getChartResolutionSupport",
+  "getChartResolutionCapabilities",
+  "getOptionsChain",
+  "listOpenOrders",
+  "listExecutions",
+  "previewOrder",
+  "placeOrder",
+  "modifyOrder",
+  "cancelOrder",
+]);
+
+interface CoreCapabilityOptions {
+  getConfig(): AppConfig;
+  getServices(): AppServices;
+}
+
+function op(handler: CapabilityOperation["handler"], kind: CapabilityOperation["kind"] = "read"): CapabilityOperation {
+  return { kind, rendererSafe: true, handler };
+}
+
+function stream(subscribe: CapabilityOperation["subscribe"]): CapabilityOperation {
+  return { kind: "stream", rendererSafe: true, subscribe };
+}
+
+function requireString(value: unknown, name: string): string {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${name} is required.`);
+  }
+  return value;
+}
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function resolveBrokerInstance(
+  options: CoreCapabilityOptions,
+  instanceId: string | undefined,
+): { instance: BrokerInstanceConfig; broker: BrokerAdapter } {
+  if (!instanceId) throw new Error("Broker request requires an instance.");
+  const instance = options.getConfig().brokerInstances.find((entry) => entry.id === instanceId);
+  if (!instance) throw new Error(`Broker profile "${instanceId}" was not found.`);
+  const broker = options.getServices().pluginRegistry.brokers.get(instance.brokerType);
+  if (!broker) throw new Error(`Broker "${instance.brokerType}" is not available.`);
+  return { instance, broker };
+}
+
+function brokerStatus(options: CoreCapabilityOptions, broker: BrokerAdapter, instanceId: string) {
+  const instance = options.getConfig().brokerInstances.find((entry) => entry.id === instanceId);
+  if (!instance) return { state: "disconnected" as const, updatedAt: Date.now() };
+  return broker.getStatus?.(instance) ?? { state: "disconnected" as const, updatedAt: Date.now() };
+}
+
+function invokeBrokerOperation(
+  broker: BrokerAdapter,
+  instance: BrokerInstanceConfig,
+  operation: string,
+  args: unknown[],
+) {
+  if (!BROKER_INVOKE_OPERATIONS.has(operation)) {
+    throw new Error(`Broker operation "${operation}" is not supported.`);
+  }
+
+  switch (operation) {
+    case "validate":
+    case "importPositions":
+    case "connect":
+    case "disconnect":
+    case "getPersistedConfigUpdate":
+    case "listAccounts":
+    case "listOpenOrders":
+    case "listExecutions":
+      return (broker[operation] as any)?.call(broker, instance);
+    case "searchInstruments":
+      return broker.searchInstruments?.(args[0] as string, instance);
+    case "getTickerFinancials":
+    case "getQuote":
+    case "getPriceHistory":
+    case "getPriceHistoryForResolution":
+    case "getDetailedPriceHistory":
+    case "getChartResolutionSupport":
+    case "getChartResolutionCapabilities":
+    case "getOptionsChain":
+      return (broker[operation] as any)?.call(broker, args[0], instance, ...args.slice(1));
+    case "previewOrder":
+    case "placeOrder":
+      return (broker[operation] as any)?.call(broker, instance, args[0]);
+    case "modifyOrder":
+      return broker.modifyOrder?.(instance, args[0] as number, args[1] as never);
+    case "cancelOrder":
+      return broker.cancelOrder?.(instance, args[0] as number);
+    default:
+      throw new Error(`Broker operation "${operation}" is not supported.`);
+  }
+}
+
+function createBrokerCapability(options: CoreCapabilityOptions): PluginCapability {
+  return {
+    id: BROKER_CAPABILITY_ID,
+    kind: "broker",
+    name: "Broker Service",
+    operations: {
+      invoke: op(async (input: any) => {
+        const { instance, broker } = resolveBrokerInstance(options, input.instanceId);
+        const operation = requireString(input.operation, "Broker operation");
+        const args = Array.isArray(input.args) ? input.args : [];
+        const result = await invokeBrokerOperation(broker, instance, operation, args);
+        if (result === undefined && typeof (broker as any)[operation] !== "function") {
+          throw new Error(`Broker operation "${operation}" is not available on "${broker.name}".`);
+        }
+        return result ?? null;
+      }, "action"),
+      status: stream((input: any, emit) => {
+        const instanceId = requireString(input.instanceId, "Broker instance");
+        const { instance, broker } = resolveBrokerInstance(options, instanceId);
+        const pushStatus = () => {
+          emit({
+            kind: "status",
+            instanceId,
+            status: brokerStatus(options, broker, instanceId),
+          });
+        };
+        const unsubscribe = broker.subscribeStatus?.(instance, pushStatus) ?? (() => {});
+        pushStatus();
+        return unsubscribe;
+      }),
+      quotes: stream((input: any, emit) => {
+        const instanceId = requireString(input.instanceId, "Broker instance");
+        const { instance, broker } = resolveBrokerInstance(options, instanceId);
+        if (!broker.subscribeQuotes) throw new Error(`Broker "${broker.name}" does not support quote subscriptions.`);
+        return broker.subscribeQuotes(
+          instance,
+          Array.isArray(input.targets) ? input.targets : [],
+          (target, quote) => {
+            emit({ kind: "quote", target, quote });
+          },
+        );
+      }),
+      removeInstance: op(async (input: any) => {
+        const { instance, broker } = resolveBrokerInstance(options, input.instanceId);
+        await broker.disconnect?.(instance);
+        return null;
+      }, "action"),
+      destroyAll: op(async () => {
+        const config = options.getConfig();
+        await Promise.allSettled(config.brokerInstances.map(async (instance) => {
+          const broker = options.getServices().pluginRegistry.brokers.get(instance.brokerType);
+          await broker?.disconnect?.(instance);
+        }));
+        return null;
+      }, "action"),
+    },
+  };
+}
+
+function notePath(dataDir: string, symbol: string): string {
+  return join(dataDir, `${symbol}.md`);
+}
+
+function notesIndexPath(dataDir: string): string {
+  return join(dataDir, NOTES_INDEX_FILE);
+}
+
+async function readTextOrEmpty(path: string): Promise<string> {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+async function writeTextEnsuringParent(path: string, value: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, value, "utf-8");
+}
+
+async function deleteFileIfPresent(path: string): Promise<void> {
+  try {
+    await unlink(path);
+  } catch {
+    // ignore missing files
+  }
+}
+
+function createNotesFilesCapability(): PluginCapability {
+  return {
+    id: NOTES_FILES_CAPABILITY_ID,
+    kind: "notes-files",
+    name: "Notes Files",
+    operations: {
+      load: op((input: any) => readTextOrEmpty(notePath(
+        requireString(input.dataDir, "Notes dataDir"),
+        requireString(input.symbol, "Notes symbol"),
+      ))),
+      save: op(async (input: any) => {
+        await writeTextEnsuringParent(
+          notePath(
+            requireString(input.dataDir, "Notes dataDir"),
+            requireString(input.symbol, "Notes symbol"),
+          ),
+          optionalString(input.notes) ?? "",
+        );
+        return null;
+      }, "action"),
+      delete: op(async (input: any) => {
+        await deleteFileIfPresent(notePath(
+          requireString(input.dataDir, "Notes dataDir"),
+          requireString(input.symbol, "Notes symbol"),
+        ));
+        return null;
+      }, "action"),
+      loadQuickNotesIndex: op(async (input: any) => {
+        const raw = await readTextOrEmpty(notesIndexPath(requireString(input.dataDir, "Notes dataDir")));
+        if (!raw.trim()) return [];
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return [];
+        }
+      }),
+      saveQuickNotesIndex: op(async (input: any) => {
+        await writeTextEnsuringParent(
+          notesIndexPath(requireString(input.dataDir, "Notes dataDir")),
+          JSON.stringify(input.entries ?? []),
+        );
+        return null;
+      }, "action"),
+    },
+  };
+}
+
+function getAiProviderAvailability(): Record<string, boolean> {
+  const availability: Record<string, boolean> = {};
+  const hasBunWhich = typeof Bun !== "undefined" && typeof Bun.which === "function";
+  for (const definition of getAiProviderDefinitions()) {
+    availability[definition.id] = hasBunWhich ? !!Bun.which(definition.command) : false;
+  }
+  return availability;
+}
+
+function createAiRunnerCapability(options: CoreCapabilityOptions): PluginCapability {
+  return {
+    id: AI_RUNNER_CAPABILITY_ID,
+    kind: "ai-runner",
+    name: "AI Runner",
+    operations: {
+      getProviderAvailability: op(() => getAiProviderAvailability()),
+      run: stream((input: any, emit) => {
+        const providerId = requireString(input.providerId, "AI provider");
+        const prompt = requireString(input.prompt, "AI prompt");
+        const providerDefinition = getAiProviderDefinitions().find((entry) => entry.id === providerId);
+        if (!providerDefinition) {
+          throw new Error(`Unknown AI provider: ${providerId}`);
+        }
+        if (typeof Bun === "undefined" || typeof Bun.which !== "function" || !Bun.which(providerDefinition.command)) {
+          throw new Error(`${providerDefinition.name} is not installed on this system.`);
+        }
+
+        let disposed = false;
+        const controller = runAiPrompt({
+          provider: {
+            ...providerDefinition,
+            available: true,
+          },
+          prompt,
+          cwd: optionalString(input.cwd) ?? options.getConfig().dataDir,
+          onChunk: (output) => {
+            if (!disposed) emit({ kind: "chunk", output });
+          },
+        });
+
+        controller.done.then((output) => {
+          if (!disposed) emit({ kind: "done", output });
+        }).catch((error) => {
+          if (disposed) return;
+          if (isAiRunCancelled(error)) {
+            emit({ kind: "cancelled" });
+            return;
+          }
+          emit({ kind: "error", error: error instanceof Error ? error.message : String(error) });
+        });
+
+        return () => {
+          disposed = true;
+          controller.cancel();
+        };
+      }),
+    },
+  };
+}
+
+export function registerElectrobunCoreCapabilities(options: CoreCapabilityOptions): void {
+  const registry = options.getServices().pluginRegistry.capabilities;
+  registry.register(DESKTOP_CORE_PLUGIN_ID, createBrokerCapability(options));
+  registry.register(DESKTOP_CORE_PLUGIN_ID, createNotesFilesCapability());
+  registry.register(DESKTOP_CORE_PLUGIN_ID, createAiRunnerCapability(options));
+}

package/src/renderers/electrobun/bun/desktop-workspace.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../../types/config";
+import { createDesktopWorkspace } from "./desktop-workspace";
+
+describe("desktop workspace", () => {
+  test("popping out a pane persists it into the active layout", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-desktop");
+    const workspace = createDesktopWorkspace(config, null);
+
+    const snapshot = workspace.popOutPane("chat:main", {
+      x: 100,
+      y: 120,
+      width: 800,
+      height: 540,
+    });
+
+    expect(snapshot.config.layout.detached).toEqual([
+      { instanceId: "chat:main", x: 100, y: 120, width: 800, height: 540 },
+    ]);
+    expect(snapshot.config.layouts[snapshot.config.activeLayoutIndex]?.layout.detached).toEqual([
+      { instanceId: "chat:main", x: 100, y: 120, width: 800, height: 540 },
+    ]);
+    expect(snapshot.config.layout.floating.some((entry) => entry.instanceId === "chat:main")).toBe(false);
+  });
+
+  test("docking a detached pane onto a frame edge clears detached placement", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-desktop");
+    const workspace = createDesktopWorkspace(config, null);
+    workspace.popOutPane("chat:main", {
+      x: 100,
+      y: 120,
+      width: 800,
+      height: 540,
+    });
+
+    const snapshot = workspace.dockDetachedPane("chat:main", "left");
+
+    expect(snapshot.config.layout.detached).toHaveLength(0);
+    expect(snapshot.config.layout.dockRoot).not.toBeNull();
+  });
+
+  test("updating a detached frame rewrites the detached entry in-place", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-desktop");
+    const workspace = createDesktopWorkspace(config, null);
+    workspace.popOutPane("chat:main", {
+      x: 100,
+      y: 120,
+      width: 800,
+      height: 540,
+    });
+
+    const snapshot = workspace.updateDetachedFrame("chat:main", {
+      x: 220,
+      y: 260,
+      width: 640,
+      height: 480,
+    });
+
+    expect(snapshot.config.layout.detached).toEqual([
+      { instanceId: "chat:main", x: 220, y: 260, width: 640, height: 480 },
+    ]);
+  });
+});

package/src/renderers/electrobun/bun/desktop-workspace.ts

@@ -0,0 +1,162 @@
+import type { AppSessionSnapshot } from "../../../core/state/session-persistence";
+import type { PaneRuntimeState } from "../../../core/state/app-state";
+import { cloneLayout, type AppConfig } from "../../../types/config";
+import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
+import { detachPaneToFrame, dockPane, insertAtRootEdge, removePane } from "../../../plugins/pane-manager";
+
+function clonePaneStateMap(state: Record<string, PaneRuntimeState>): Record<string, PaneRuntimeState> {
+  return Object.fromEntries(
+    Object.entries(state).map(([paneId, paneState]) => [paneId, { ...paneState }]),
+  );
+}
+
+function filterPaneState(
+  layout: AppConfig["layout"],
+  paneState: Record<string, PaneRuntimeState>,
+): Record<string, PaneRuntimeState> {
+  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
+  return Object.fromEntries(
+    Object.entries(paneState).filter(([paneId]) => validPaneIds.has(paneId)),
+  );
+}
+
+function syncActiveLayout(config: AppConfig): AppConfig {
+  return {
+    ...config,
+    layouts: config.layouts.map((entry, index) => (
+      index === config.activeLayoutIndex
+        ? { ...entry, layout: cloneLayout(config.layout) }
+        : entry
+    )),
+  };
+}
+
+export interface DesktopWorkspace {
+  getSnapshot(): DesktopSharedStateSnapshot;
+  syncMainState(snapshot: DesktopSharedStateSnapshot): DesktopSharedStateSnapshot;
+  replaceConfig(config: AppConfig, options?: { layoutChanged?: boolean }): DesktopSharedStateSnapshot;
+  replaceDetachedPaneState(paneId: string, paneState: PaneRuntimeState): DesktopSharedStateSnapshot;
+  updateDetachedFrame(
+    paneId: string,
+    frame: { x: number; y: number; width: number; height: number },
+  ): DesktopSharedStateSnapshot;
+  popOutPane(
+    paneId: string,
+    frame: { x: number; y: number; width: number; height: number },
+  ): DesktopSharedStateSnapshot;
+  dockDetachedPane(
+    paneId: string,
+    edge?: "left" | "right" | "top" | "bottom",
+  ): DesktopSharedStateSnapshot;
+  closeDetachedPane(paneId: string): DesktopSharedStateSnapshot;
+}
+
+export function createDesktopWorkspace(
+  config: AppConfig,
+  sessionSnapshot: AppSessionSnapshot | null,
+): DesktopWorkspace {
+  let sharedState: DesktopSharedStateSnapshot = {
+    config: syncActiveLayout(config),
+    paneState: filterPaneState(config.layout, clonePaneStateMap(sessionSnapshot?.paneState ?? {})),
+    focusedPaneId: sessionSnapshot?.focusedPaneId ?? null,
+    activePanel: sessionSnapshot?.activePanel === "right" ? "right" : "left",
+    statusBarVisible: sessionSnapshot?.statusBarVisible !== false,
+  };
+
+  const updateConfig = (nextConfig: AppConfig, options?: { layoutChanged?: boolean }) => {
+    const syncedConfig = syncActiveLayout(nextConfig);
+    sharedState = {
+      ...sharedState,
+      config: {
+        ...syncedConfig,
+        layout: cloneLayout(syncedConfig.layout),
+        layouts: syncedConfig.layouts.map((entry) => ({ ...entry, layout: cloneLayout(entry.layout) })),
+      },
+      paneState: filterPaneState(syncedConfig.layout, sharedState.paneState),
+      layoutChanged: options?.layoutChanged,
+    };
+    return getSnapshot();
+  };
+
+  const getSnapshot = (): DesktopSharedStateSnapshot => ({
+    config: {
+      ...sharedState.config,
+      layout: cloneLayout(sharedState.config.layout),
+      layouts: sharedState.config.layouts.map((entry) => ({ ...entry, layout: cloneLayout(entry.layout) })),
+    },
+    paneState: clonePaneStateMap(sharedState.paneState),
+    focusedPaneId: sharedState.focusedPaneId,
+    activePanel: sharedState.activePanel,
+    statusBarVisible: sharedState.statusBarVisible,
+    layoutChanged: sharedState.layoutChanged,
+  });
+
+  return {
+    getSnapshot,
+    syncMainState(snapshot) {
+      const syncedConfig = syncActiveLayout(snapshot.config);
+      sharedState = {
+        config: {
+          ...syncedConfig,
+          layout: cloneLayout(syncedConfig.layout),
+          layouts: syncedConfig.layouts.map((entry) => ({ ...entry, layout: cloneLayout(entry.layout) })),
+        },
+        paneState: filterPaneState(syncedConfig.layout, clonePaneStateMap(snapshot.paneState)),
+        focusedPaneId: snapshot.focusedPaneId,
+        activePanel: snapshot.activePanel,
+        statusBarVisible: snapshot.statusBarVisible,
+        layoutChanged: snapshot.layoutChanged,
+      };
+      return getSnapshot();
+    },
+    replaceConfig(config: AppConfig, options) {
+      return updateConfig(config, options);
+    },
+    replaceDetachedPaneState(paneId, paneState) {
+      sharedState = {
+        ...sharedState,
+        paneState: filterPaneState(sharedState.config.layout, {
+          ...sharedState.paneState,
+          [paneId]: { ...paneState },
+        }),
+      };
+      return getSnapshot();
+    },
+    updateDetachedFrame(paneId, frame) {
+      return updateConfig({
+        ...sharedState.config,
+        layout: {
+          ...sharedState.config.layout,
+          detached: sharedState.config.layout.detached.map((entry) => (
+            entry.instanceId === paneId ? { ...entry, ...frame } : entry
+          )),
+        },
+      }, { layoutChanged: true });
+    },
+    popOutPane(paneId, frame) {
+      return updateConfig({
+        ...sharedState.config,
+        layout: detachPaneToFrame(sharedState.config.layout, paneId, frame),
+      }, { layoutChanged: true });
+    },
+    dockDetachedPane(paneId, edge) {
+      return updateConfig({
+        ...sharedState.config,
+        layout: edge
+          ? insertAtRootEdge(sharedState.config.layout, paneId, edge)
+          : dockPane(sharedState.config.layout, paneId),
+      }, { layoutChanged: true });
+    },
+    closeDetachedPane(paneId) {
+      const nextLayout = removePane(sharedState.config.layout, paneId);
+      sharedState = {
+        ...sharedState,
+        paneState: filterPaneState(nextLayout, sharedState.paneState),
+      };
+      return updateConfig({
+        ...sharedState.config,
+        layout: nextLayout,
+      }, { layoutChanged: true });
+    },
+  };
+}