gloomberb 0.9.9 → 0.10.0

package/src/remote/controller.test.ts

@@ -17,13 +17,37 @@ function createRegistryHarness() {
     actions.push(action);
     state = appReducer(state, action);
   };
+  const invokedCapabilities: Array<{ capabilityId: string; operationId: string; payload: unknown }> = [];
+  const marketDataQueries: Array<{ operation: string; input: unknown }> = [];
   const registry = {
     panes: new Map(),
     paneTemplates: new Map(),
     commands: new Map(),
     capabilities: {
       manifests: () => [],
-      invoke: async () => ({ invoked: true }),
+      invoke: async (capabilityId: string, operationId: string, payload: unknown) => {
+        invokedCapabilities.push({ capabilityId, operationId, payload });
+        return { invoked: true, capabilityId, operationId, payload };
+      },
+    },
+    marketData: {
+      search: async (query: string) => {
+        marketDataQueries.push({ operation: "search", input: { query } });
+        return [{
+          symbol: "NVDA",
+          name: "NVIDIA Corporation",
+          exchange: "NASDAQ",
+          type: "Equity",
+        }];
+      },
+      getQuote: async (symbol: string, exchange?: string) => {
+        marketDataQueries.push({ operation: "quote", input: { symbol, exchange } });
+        return { symbol, exchange, price: 180 };
+      },
+      getTickerFinancials: async (symbol: string, exchange?: string) => {
+        marketDataQueries.push({ operation: "financials", input: { symbol, exchange } });
+        return { quote: { symbol, exchange, price: 180 } };
+      },
     },
     resolvePaneSettings: () => null,
     showPane: () => {},
@@ -62,7 +86,9 @@ function createRegistryHarness() {
     actions,
     controller,
     getState: () => state,
+    invokedCapabilities,
     invokedUiActions,
+    marketDataQueries,
     setUiNodes: (nodes: RemoteUiNodeSnapshot[]) => {
       uiNodes = nodes;
     },
@@ -101,6 +127,47 @@ describe("createAppRemoteController", () => {
     }
   });
 
+  test("queries configured market data without dispatching app-control actions", async () => {
+    const { actions, controller, marketDataQueries } = createRegistryHarness();
+
+    const search = await controller.handle({
+      type: "data",
+      operation: "search",
+      query: "NVIDIA",
+    });
+    const quote = await controller.handle({
+      type: "data",
+      operation: "quote",
+      symbol: "nvda",
+      exchange: "nasdaq",
+    });
+
+    expect(search).toMatchObject({
+      ok: true,
+      data: [{ symbol: "NVDA", exchange: "NASDAQ" }],
+    });
+    expect(quote).toMatchObject({
+      ok: true,
+      data: { symbol: "NVDA", exchange: "NASDAQ", price: 180 },
+    });
+    expect(marketDataQueries).toEqual([
+      { operation: "search", input: { query: "NVIDIA" } },
+      { operation: "quote", input: { symbol: "NVDA", exchange: "NASDAQ" } },
+    ]);
+    expect(actions).toEqual([]);
+
+    const appControlAttempt = await controller.handle({
+      type: "data",
+      operation: "app.openCommandBar",
+      query: "NVDA",
+    } as never);
+    expect(appControlAttempt).toMatchObject({
+      ok: false,
+      error: { message: expect.stringContaining("Unknown market data operation") },
+    });
+    expect(actions).toEqual([]);
+  });
+
   test("dispatches semantic app operations", async () => {
     const { actions, controller, getState } = createRegistryHarness();
 
@@ -292,6 +359,40 @@ describe("createAppRemoteController", () => {
     }
   });
 
+  test("forwards plugin capability operations without narrowing their payload", async () => {
+    const { controller, invokedCapabilities } = createRegistryHarness();
+    const payload = {
+      instanceId: "broker-main",
+      operation: "placeOrder",
+      args: [{ symbol: "NVDA", side: "BUY", quantity: 5 }],
+    };
+
+    const response = await controller.handle({
+      type: "call",
+      operation: "capability.invoke",
+      input: {
+        capabilityId: "desktop.broker",
+        operationId: "invoke",
+        payload,
+      },
+    });
+
+    expect(response.ok).toBe(true);
+    expect(invokedCapabilities).toEqual([{
+      capabilityId: "desktop.broker",
+      operationId: "invoke",
+      payload,
+    }]);
+    if (response.ok) {
+      expect(response.data).toEqual({
+        invoked: true,
+        capabilityId: "desktop.broker",
+        operationId: "invoke",
+        payload,
+      });
+    }
+  });
+
   test("runs sequential batches with halt-on-error and final state", async () => {
     const { controller } = createRegistryHarness();
 

package/src/remote/controller.ts

@@ -17,6 +17,7 @@ import type {
   RemoteControlRequest,
   RemoteControlResponse,
   RemoteJsonPatchOperation,
+  RemoteMarketDataRequest,
   RemoteStateInclude,
 } from "./types";
 import type { RemoteUiRegistry } from "./semantic-tree";
@@ -51,6 +52,26 @@ interface AppRemoteControllerOptions {
 }
 
 const DEFAULT_MUTATION_INCLUDE: RemoteStateInclude[] = ["app", "layout", "panes", "commandBar"];
+const MAX_MARKET_DATA_SEARCH_RESULTS = 20;
+const MAX_MARKET_DATA_FILINGS = 20;
+const MAX_MARKET_DATA_EARNINGS_SYMBOLS = 25;
+const MAX_MARKET_DATA_HOLDERS = 25;
+const MAX_MARKET_DATA_EVENT_ROWS = 20;
+
+function requiredMarketDataText(value: string, field: string): string {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`Market data ${field} is required.`);
+  return normalized;
+}
+
+function normalizedMarketDataSymbol(symbol: string): string {
+  return requiredMarketDataText(symbol, "symbol").toUpperCase();
+}
+
+function normalizedOptionalExchange(exchange: string | undefined): string | undefined {
+  const normalized = exchange?.trim().toUpperCase();
+  return normalized || undefined;
+}
 
 export function createAppRemoteController({
   dispatch,
@@ -72,6 +93,105 @@ export function createAppRemoteController({
     return mutationSummary(getState(), extra);
   };
 
+  const queryMarketData = async (request: RemoteMarketDataRequest): Promise<unknown> => {
+    const marketData = pluginRegistry.marketData;
+    switch (request.operation) {
+      case "search":
+        return (await marketData.search(requiredMarketDataText(request.query, "query")))
+          .slice(0, MAX_MARKET_DATA_SEARCH_RESULTS)
+          .map((result) => ({
+            providerId: result.providerId,
+            symbol: result.symbol,
+            name: result.name,
+            exchange: result.exchange,
+            primaryExchange: result.primaryExchange,
+            type: result.type,
+            currency: result.currency,
+          }));
+      case "quote":
+        return marketData.getQuote(
+          normalizedMarketDataSymbol(request.symbol),
+          normalizedOptionalExchange(request.exchange),
+        );
+      case "financials": {
+        const financials = await marketData.getTickerFinancials(
+          normalizedMarketDataSymbol(request.symbol),
+          normalizedOptionalExchange(request.exchange),
+        );
+        return {
+          quote: financials.quote,
+          fundamentals: financials.fundamentals,
+          profile: financials.profile,
+          annualStatements: financials.annualStatements.slice(0, 5),
+          quarterlyStatements: financials.quarterlyStatements.slice(0, 8),
+        };
+      }
+      case "secFilings": {
+        if (!marketData.getSecFilings) throw new Error("The configured market data sources do not provide SEC filings.");
+        const count = Math.max(1, Math.min(
+          MAX_MARKET_DATA_FILINGS,
+          Number.isFinite(request.count) ? Math.trunc(request.count!) : 10,
+        ));
+        return (await marketData.getSecFilings(
+          normalizedMarketDataSymbol(request.symbol),
+          count,
+          normalizedOptionalExchange(request.exchange),
+        )).slice(0, count);
+      }
+      case "holders": {
+        if (!marketData.getHolders) throw new Error("The configured market data sources do not provide holder data.");
+        const holders = await marketData.getHolders(
+          normalizedMarketDataSymbol(request.symbol),
+          normalizedOptionalExchange(request.exchange),
+        );
+        return {
+          ...holders,
+          holders: holders.holders.slice(0, MAX_MARKET_DATA_HOLDERS),
+        };
+      }
+      case "analystResearch": {
+        if (!marketData.getAnalystResearch) throw new Error("The configured market data sources do not provide analyst research.");
+        const research = await marketData.getAnalystResearch(
+          normalizedMarketDataSymbol(request.symbol),
+          normalizedOptionalExchange(request.exchange),
+        );
+        return {
+          ...research,
+          recommendations: research.recommendations.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+          ratings: research.ratings.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+          earningsEstimates: research.earningsEstimates.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+          revenueEstimates: research.revenueEstimates.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+        };
+      }
+      case "corporateActions": {
+        if (!marketData.getCorporateActions) throw new Error("The configured market data sources do not provide corporate actions.");
+        const actions = await marketData.getCorporateActions(
+          normalizedMarketDataSymbol(request.symbol),
+          normalizedOptionalExchange(request.exchange),
+        );
+        return {
+          ...actions,
+          dividends: actions.dividends.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+          splits: actions.splits.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+          earnings: actions.earnings.slice(0, MAX_MARKET_DATA_EVENT_ROWS),
+        };
+      }
+      case "earningsCalendar": {
+        if (!marketData.getEarningsCalendar) throw new Error("The configured market data sources do not provide an earnings calendar.");
+        const symbols = request.symbols
+          .map((symbol) => normalizedMarketDataSymbol(symbol))
+          .filter((symbol, index, all) => all.indexOf(symbol) === index)
+          .slice(0, MAX_MARKET_DATA_EARNINGS_SYMBOLS);
+        if (symbols.length === 0) throw new Error("Market data symbols are required.");
+        return marketData.getEarningsCalendar(symbols);
+      }
+      default:
+        throw new Error(
+          `Unknown market data operation "${String((request as { operation?: unknown }).operation)}".`,
+        );
+    }
+  };
+
   const openCommandBar = async (input: Record<string, unknown>): Promise<unknown> => {
     const mode = optionalString(input, "mode") ?? "command";
     const query = optionalString(input, "query") ?? "";
@@ -370,6 +490,8 @@ export function createAppRemoteController({
           const data = getResource(request.resource);
           return ok(data, revisionFor(data), buildIncludedState(request.include));
         }
+        case "data":
+          return ok(await queryMarketData(request));
         case "call": {
           const data = await call(request.operation, request.input, request.dryRun);
           return ok(data, undefined, buildIncludedState(request.include, request.dryRun ? [] : DEFAULT_MUTATION_INCLUDE));

package/src/remote/types.ts

@@ -28,10 +28,21 @@ export type RemoteStateInclude =
   | "help"
   | "all";
 
+export type RemoteMarketDataRequest =
+  | { type: "data"; operation: "search"; query: string }
+  | { type: "data"; operation: "quote"; symbol: string; exchange?: string }
+  | { type: "data"; operation: "financials"; symbol: string; exchange?: string }
+  | { type: "data"; operation: "secFilings"; symbol: string; exchange?: string; count?: number }
+  | { type: "data"; operation: "holders"; symbol: string; exchange?: string }
+  | { type: "data"; operation: "analystResearch"; symbol: string; exchange?: string }
+  | { type: "data"; operation: "corporateActions"; symbol: string; exchange?: string }
+  | { type: "data"; operation: "earningsCalendar"; symbols: string[] };
+
 export type RemoteControlRequest =
   | { type: "help"; topic?: string }
   | { type: "schema" }
   | { type: "get"; resource: string; include?: RemoteStateInclude[] }
+  | RemoteMarketDataRequest
   | { type: "call"; operation: string; input?: unknown; dryRun?: boolean; include?: RemoteStateInclude[] }
   | {
     type: "patch";

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

@@ -8,8 +8,20 @@ import {
   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 {
+  isAiProviderId,
+  type AiProviderId,
+} from "../../../plugins/builtin/ai/providers";
+import { createPiAiHost } from "../../../plugins/builtin/ai/pi";
+import {
+  isAiRunCancelled,
+  type AiConversationMessage,
+  type AiRuntimeAuthType,
+} from "../../../plugins/builtin/ai/runner";
+import {
+  normalizeAiAgentHistory,
+  type AiAgentHistoryMessage,
+} from "../../../plugins/builtin/ai/agent-history";
 import type { BrokerAdapter } from "../../../types/broker";
 import type { AppConfig, BrokerInstanceConfig } from "../../../types/config";
 
@@ -265,48 +277,132 @@ function createNotesFilesCapability(): PluginCapability {
   };
 }
 
-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 {
+  const aiHost = createPiAiHost({
+    appKind: "desktop",
+    dataDir: options.getConfig().dataDir,
+  });
+  const requireProviderId = (value: unknown): AiProviderId => {
+    const providerId = requireString(value, "AI provider");
+    if (!isAiProviderId(providerId)) {
+      throw new Error(`Unknown AI provider: ${providerId}`);
+    }
+    return providerId;
+  };
+  const requireCatalogProvider = async (value: unknown): Promise<AiProviderId> => {
+    const providerId = requireProviderId(value);
+    const catalog = await aiHost.getCatalog?.();
+    if (!catalog?.providers.some((provider) => provider.providerId === providerId)) {
+      throw new Error(`Unknown AI provider: ${providerId}`);
+    }
+    return providerId;
+  };
+  const optionalAuthType = (value: unknown): AiRuntimeAuthType | undefined => {
+    if (value === undefined || value === null || value === "") return undefined;
+    if (value === "oauth" || value === "api_key") return value;
+    throw new Error(`Unknown AI authentication method: ${String(value)}`);
+  };
+  const optionalMessages = (value: unknown): AiConversationMessage[] | undefined => {
+    if (value === undefined || value === null) return undefined;
+    if (!Array.isArray(value)) throw new Error("AI conversation messages must be an array.");
+    return value.map((message, index) => {
+      if (!message || typeof message !== "object") {
+        throw new Error(`AI conversation message ${index + 1} is invalid.`);
+      }
+      const role = (message as { role?: unknown }).role;
+      const content = (message as { content?: unknown }).content;
+      if ((role !== "user" && role !== "assistant") || typeof content !== "string") {
+        throw new Error(`AI conversation message ${index + 1} is invalid.`);
+      }
+      return { role, content };
+    });
+  };
+  const optionalAgentMessages = (value: unknown): AiAgentHistoryMessage[] | undefined => {
+    if (value === undefined || value === null) return undefined;
+    if (!Array.isArray(value)) throw new Error("AI agent messages must be an array.");
+    const messages = normalizeAiAgentHistory(value);
+    if (messages.length !== value.length) {
+      throw new Error("AI agent message history is invalid.");
+    }
+    return messages;
+  };
+
   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}`);
+      getCatalog: op(async () => aiHost.getCatalog?.() ?? { providers: [], accounts: [], models: [] }),
+      connectProvider: stream(async (input: any, emit) => {
+        const providerId = await requireCatalogProvider(input.providerId);
+        const authType = optionalAuthType(input.authType);
+        if (!aiHost.connect) throw new Error("In-app AI sign-in is unavailable.");
+        let disposed = false;
+        aiHost.connect(providerId, authType, (event) => {
+          if (!disposed) emit({ kind: "account-auth", event });
+        }).then((catalog) => {
+          if (!disposed) emit({ kind: "account-connected", catalog });
+        }).catch((error) => {
+          if (!disposed) emit({
+            kind: "account-error",
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+        return () => {
+          disposed = true;
+        };
+      }),
+      disconnectProvider: op(async (input: any) => {
+        const providerId = await requireCatalogProvider(input.providerId);
+        if (!aiHost.disconnect) throw new Error("In-app AI account disconnection is unavailable.");
+        return aiHost.disconnect(providerId);
+      }, "action"),
+      checkProviderStatus: op(async (input: any) => {
+        const providerId = await requireCatalogProvider(input.providerId);
+        if (!aiHost.checkStatus) {
+          throw new Error("AI provider status checks are unavailable.");
         }
-        if (typeof Bun === "undefined" || typeof Bun.which !== "function" || !Bun.which(providerDefinition.command)) {
-          throw new Error(`${providerDefinition.name} is not installed on this system.`);
+        return aiHost.checkStatus(providerId);
+      }),
+      run: stream(async (input: any, emit) => {
+        const providerId = await requireCatalogProvider(input.providerId);
+        const prompt = requireString(input.prompt, "AI prompt");
+        const messages = optionalMessages(input.messages);
+        const agentMessages = optionalAgentMessages(input.agentMessages);
+        let completedAgentMessages: AiAgentHistoryMessage[] | undefined;
+        const modelId = optionalString(input.modelId);
+        const providerStatus = await aiHost.checkStatus?.(providerId);
+        if (providerStatus && !providerStatus.authenticated) {
+          throw new Error(
+            providerStatus.message
+              ?? `${providerId} is not connected.`,
+          );
         }
 
         let disposed = false;
-        const controller = runAiPrompt({
-          provider: {
-            ...providerDefinition,
-            available: true,
-          },
+        const controller = aiHost.run({
+          providerId,
           prompt,
-          cwd: optionalString(input.cwd) ?? options.getConfig().dataDir,
+          messages,
+          agentMessages,
+          modelId: modelId ?? undefined,
+          outputMode: input.outputMode === "structured" || input.outputMode === "screener"
+            ? input.outputMode
+            : "plain",
           onChunk: (output) => {
             if (!disposed) emit({ kind: "chunk", output });
           },
+          onAgentMessages: (nextMessages) => {
+            completedAgentMessages = nextMessages;
+          },
         });
 
         controller.done.then((output) => {
-          if (!disposed) emit({ kind: "done", output });
+          if (!disposed) emit({
+            kind: "done",
+            output,
+            ...(completedAgentMessages ? { agentMessages: completedAgentMessages } : {}),
+          });
         }).catch((error) => {
           if (disposed) return;
           if (isAiRunCancelled(error)) {

package/src/renderers/electrobun/bun/desktop/backend-requests.ts

@@ -1,4 +1,5 @@
 import { createAppServices, type AppServices } from "../../../../core/app-services";
+import { getDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
 import {
   exportConfig,
@@ -80,7 +81,10 @@ async function importDesktopConfig({
   setDesktopWorkspace(null);
   teardownServices();
   setCurrentConfig(await importConfig(payload.dataDir as string, payload.srcPath as string));
-  setServices(createAppServices({ config: getConfig(), externalPlugins: [] }));
+  setServices(createAppServices({
+    config: getConfig(),
+    plugins: getDesktopBackendPlugins(),
+  }));
   syncConfigAccessors();
   registerCoreCapabilities();
   const desktopWorkspace = createDesktopWorkspace(getConfig(), getSessionSnapshot());

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { createAppServices, type AppServices } from "../../../../core/app-services";
+import { getDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
 import {
   getDataDir,
@@ -126,7 +127,10 @@ export async function initializeDesktopBackend<TRpc>(
   const config = options.getCurrentConfig();
   if (!config) throw new Error("Desktop config failed to initialize.");
 
-  const services = createAppServices({ config, externalPlugins: [] });
+  const services = createAppServices({
+    config,
+    plugins: getDesktopBackendPlugins(),
+  });
   options.setServices(services);
   options.syncConfigAccessors();
   options.registerCoreCapabilities();

package/src/renderers/electrobun/bun/desktop/media.ts

@@ -0,0 +1,15 @@
+import type { LiveStreamResolveRequest, ResolvedLiveStream } from "../../../../types/media";
+import { getTvChannel, TV_CHANNELS } from "../../../../plugins/builtin/tv/channels";
+import { resolveTvStream } from "../../../../plugins/builtin/tv/youtube-stream";
+
+export async function resolveDesktopLiveStream(payload: Record<string, unknown>): Promise<ResolvedLiveStream> {
+  const request = payload as Partial<LiveStreamResolveRequest>;
+  if (request.provider !== "youtube") {
+    throw new Error("Unsupported live-stream provider.");
+  }
+  const channel = TV_CHANNELS.find((item) => item.id === request.sourceId);
+  if (!channel) {
+    throw new Error("Unknown TV channel.");
+  }
+  return resolveTvStream(getTvChannel(channel.id), { force: request.force === true });
+}

package/src/renderers/electrobun/bun/desktop/window-style.ts

@@ -15,7 +15,10 @@ export function desktopTitleBarStyle(): DesktopTitleBarStyle {
 }
 
 export function desktopWindowRenderer(): DesktopWindowRenderer {
-  if (process.platform === "win32") return "cef";
+  if (process.platform === "win32") {
+    const hostArchitecture = process.env.PROCESSOR_ARCHITEW6432 ?? process.env.PROCESSOR_ARCHITECTURE;
+    return hostArchitecture?.toLowerCase() === "arm64" ? "native" : "cef";
+  }
   return "native";
 }
 

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { createDefaultConfig } from "../../../../../types/config";
+import { cloneLayout, createDefaultConfig } from "../../../../../types/config";
 import { createDesktopWorkspace } from "./index";
 
 describe("desktop workspace", () => {
@@ -60,4 +60,35 @@ describe("desktop workspace", () => {
       { instanceId: "chat:main", x: 220, y: 260, width: 640, height: 480 },
     ]);
   });
+
+  test("ignores main-window state that arrives behind a newer layout revision", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-desktop-layout-revision");
+    const workspace = createDesktopWorkspace(config, null);
+    const initialSnapshot = workspace.getSnapshot();
+    const monitorLayout = config.layouts[1]!;
+
+    const newerSnapshot = {
+      ...initialSnapshot,
+      config: {
+        ...initialSnapshot.config,
+        layout: cloneLayout(monitorLayout.layout),
+        activeLayoutIndex: 1,
+      },
+      paneState: monitorLayout.paneState ?? {},
+      focusedPaneId: monitorLayout.focusedPaneId ?? null,
+      activePanel: monitorLayout.activePanel ?? "left" as const,
+      mainStateRevision: 2,
+    };
+    const staleSnapshot = {
+      ...initialSnapshot,
+      mainStateRevision: 1,
+    };
+
+    workspace.syncMainState(newerSnapshot);
+    const result = workspace.syncMainState(staleSnapshot);
+
+    expect(result.mainStateRevision).toBe(2);
+    expect(result.config.activeLayoutIndex).toBe(1);
+    expect(result.config.layout).toEqual(monitorLayout.layout);
+  });
 });

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

@@ -62,6 +62,7 @@ export function createDesktopWorkspace(
     focusedPaneId: initialFocusedPaneId,
     activePanel: initialActivePanel,
     statusBarVisible: sessionSnapshot?.statusBarVisible !== false,
+    mainStateRevision: 0,
   };
 
   const updateConfig = (nextConfig: AppConfig, options?: { layoutChanged?: boolean }) => {
@@ -94,12 +95,20 @@ export function createDesktopWorkspace(
     focusedPaneId: sharedState.focusedPaneId,
     activePanel: sharedState.activePanel,
     statusBarVisible: sharedState.statusBarVisible,
+    mainStateRevision: sharedState.mainStateRevision,
     layoutChanged: sharedState.layoutChanged,
   });
 
   return {
     getSnapshot,
     syncMainState(snapshot) {
+      const currentRevision = sharedState.mainStateRevision ?? 0;
+      if (
+        typeof snapshot.mainStateRevision === "number"
+        && snapshot.mainStateRevision <= currentRevision
+      ) {
+        return getSnapshot();
+      }
       const syncedConfig = syncConfigActiveLayoutState(
         snapshot.config,
         snapshot.paneState,
@@ -116,6 +125,7 @@ export function createDesktopWorkspace(
         focusedPaneId: snapshot.focusedPaneId,
         activePanel: snapshot.activePanel,
         statusBarVisible: snapshot.statusBarVisible,
+        mainStateRevision: snapshot.mainStateRevision ?? currentRevision,
         layoutChanged: snapshot.layoutChanged,
       };
       return getSnapshot();

package/src/renderers/electrobun/bun/index.ts

@@ -46,6 +46,7 @@ import { DesktopDetachedWindowManager } from "./desktop/detached-windows";
 import { handleDesktopHostRequest } from "./desktop/host-requests";
 import { handleDesktopWorkspaceRequest } from "./desktop/workspace/requests";
 import { handleDesktopBackendRequest } from "./desktop/backend-requests";
+import { resolveDesktopLiveStream } from "./desktop/media";
 import { initializeDesktopBackend } from "./desktop/initialization";
 import { applyWindowsCustomChrome } from "./desktop/windows-custom-chrome";
 import { applyWindowsWindowIcon } from "./desktop/windows-icons";
@@ -429,6 +430,10 @@ async function handleBackendRequest(
 
   if (method === "init") return initialize(rpc, payload);
   if (method === "http.fetch") return handleHttpFetch(payload);
+  if (method === "media.resolveLiveStream") return resolveDesktopLiveStream(payload);
+  if (method === "remote.forward") {
+    return forwardRemoteControlRequest(payload.request as RemoteControlRequest);
+  }
   if (method.startsWith("capability.")) return capabilityBridge.handle(rpc, method, payload);
   if (method.startsWith("desktop.")) {
     return handleDesktopWorkspaceRequest({

package/src/renderers/electrobun/bun/tui-entry.ts

@@ -1,6 +1 @@
-import { startOpenTuiApp } from "../../opentui/start";
-
-startOpenTuiApp().catch((err) => {
-  console.error("Fatal error:", err);
-  process.exitCode = 1;
-});
+import "../../../cli/entry";