gloomberb 0.10.4 → 0.11.0

package/src/plugins/registry/index.ts

@@ -1,8 +1,13 @@
 import type { ReactNode } from "react";
 import type { AppPersistencePort, AppTickerRepositoryPort } from "../../core/app-service-ports";
+import {
+  connectionHealth as sharedConnectionHealth,
+  type ConnectionHealthRegistry,
+} from "../../core/connection-health";
 import type { BrokerAdapter } from "../../types/broker";
 import {
   CapabilityRegistry,
+  type CapabilityManifest,
   type NewsCapability,
   type PluginCapability,
 } from "../../capabilities";
@@ -10,6 +15,7 @@ import type { BrokerInstanceConfig, LayoutConfig } from "../../types/config";
 import type { DataProvider } from "../../types/data-provider";
 import type { TickerFinancials } from "../../types/financials";
 import type {
+  AppNotificationDelivery,
   AppNotificationRequest,
   BrokerInstanceUpdateOptions,
   CommandDef,
@@ -62,6 +68,14 @@ import { isReservedBuiltinPluginId } from "../ownership";
 interface PluginRegistryOptions {
   enableCapabilityHandlers?: boolean;
   wrapBrokerAdapter?: (broker: BrokerAdapter, pluginId: string) => BrokerAdapter;
+  connectionHealth?: ConnectionHealthRegistry;
+  remoteCapabilityManifests?: () => CapabilityManifest[];
+  remoteCapabilityInvoke?: <T>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    options?: { signal?: AbortSignal },
+  ) => Promise<T>;
 }
 
 export type WindowEditMode = "move" | "resize";
@@ -80,11 +94,19 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
   readonly events: EventBus;
   readonly capabilities: CapabilityRegistry;
+  readonly connectionHealth: ConnectionHealthRegistry;
   readonly marketData: DataProvider;
   readonly tickerRepository: AppTickerRepositoryPort;
   readonly persistence: AppPersistencePort;
   private readonly enableCapabilityHandlers: boolean;
   private readonly wrapBrokerAdapter?: (broker: BrokerAdapter, pluginId: string) => BrokerAdapter;
+  private readonly remoteCapabilityManifests?: () => CapabilityManifest[];
+  private readonly remoteCapabilityInvoke?: <T>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    options?: { signal?: AbortSignal },
+  ) => Promise<T>;
 
   getTickerFn: ((symbol: string) => TickerRecord | null) = () => null;
   getDataFn: ((symbol: string) => TickerFinancials | null) = () => null;
@@ -112,7 +134,20 @@ export class PluginRegistry implements PluginRuntimeAccess {
   pinTickerFn: ((symbol: string, options?: PinTickerOptions) => void) = () => {};
   navigateTickerFn: ((symbol: string, options?: { sourcePaneId?: string | null }) => void) = () => {};
   getMarketData = () => this.marketData;
+  getConnectionHealth = () => this.connectionHealth;
   getCapability = (capabilityId: string) => this.capabilities.get(capabilityId)?.capability ?? null;
+  capabilityManifests = (kind?: string) => (this.remoteCapabilityManifests?.() ?? this.capabilities.manifests({ rendererOnly: true }))
+    .filter((manifest) => !kind || manifest.kind === kind);
+  invokeCapability = <T = unknown>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    options: { signal?: AbortSignal } = {},
+  ): Promise<T> => (
+    this.remoteCapabilityInvoke
+      ? this.remoteCapabilityInvoke<T>(capabilityId, operationId, payload, options)
+      : this.capabilities.invoke<T>(capabilityId, operationId, payload, { renderer: true, signal: options.signal })
+  );
   getBrokerAdapter = (brokerType: string) => this.contributions.brokersMap.get(brokerType) ?? null;
   connectBrokerInstance = (instanceId: string) => this.connectBrokerInstanceFn(instanceId);
   updateBrokerInstance = (instanceId: string, values: Record<string, unknown>, options?: BrokerInstanceUpdateOptions) => (
@@ -170,7 +205,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
     listener: (state: import("../../types/news-source").NewsQueryState) => void,
   ) => () => void) = () => () => {};
 
-  notifyFn: ((notification: AppNotificationRequest) => void) = () => {};
+  notifyFn: ((notification: AppNotificationRequest) => AppNotificationDelivery | void) = () => {};
   getPaneRuntimeStateFn: ((paneId: string) => PaneRuntimeState | null) = () => null;
   updatePaneRuntimeStateFn: ((paneId: string, patch: Partial<PaneRuntimeState>) => void) = () => {};
   applyPaneSettingValueFn: ((paneId: string, field: import("../../types/plugin").PaneSettingField, value: unknown) => Promise<void>) = async () => {};
@@ -190,10 +225,13 @@ export class PluginRegistry implements PluginRuntimeAccess {
     options: PluginRegistryOptions = {},
   ) {
     this.marketData = marketData;
+    this.connectionHealth = options.connectionHealth ?? sharedConnectionHealth;
     this.tickerRepository = tickerRepository;
     this.persistence = persistence;
     this.enableCapabilityHandlers = options.enableCapabilityHandlers ?? true;
     this.wrapBrokerAdapter = options.wrapBrokerAdapter;
+    this.remoteCapabilityManifests = options.remoteCapabilityManifests;
+    this.remoteCapabilityInvoke = options.remoteCapabilityInvoke;
     this.events = new EventBus();
     this.contributions = new RegistryContributions({
       wrapPaneDef: (pluginId, pane) => wrapPaneDefWithRuntime(pluginId, pane, this),
@@ -208,6 +246,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
         const disabledSources = this.getConfigFn().disabledSources ?? [];
         return !disabledSources.includes(capability.sourceId ?? capability.id) && !this.getConfigFn().disabledPlugins.includes(pluginId);
       },
+      connectionHealth: this.connectionHealth,
     });
     this.Slot = ({ name, ...props }: { name: keyof GloomSlots } & Record<string, unknown>) => (
       this.renderSlot(name, props as any)
@@ -278,8 +317,8 @@ export class PluginRegistry implements PluginRuntimeAccess {
     return this.contributions.pluginItems.get(pluginId)?.paneTemplates ?? [];
   }
 
-  notify(notification: AppNotificationRequest): void {
-    this.notifyFn(notification);
+  notify(notification: AppNotificationRequest): AppNotificationDelivery | void {
+    return this.notifyFn(notification);
   }
 
   renderSlot<K extends keyof GloomSlots>(name: K, props: GloomSlots[K]): ReactNode {
@@ -299,6 +338,16 @@ export class PluginRegistry implements PluginRuntimeAccess {
     const disposeCapability = this.capabilities.register(pluginId, ownedCapability);
     this.contributions.registerCapability(pluginId, capability.id, items);
     items.capabilityDisposers.push(disposeCapability);
+    if (ownedCapability.kind === "asset-data" || ownedCapability.kind === "news") {
+      items.capabilityDisposers.push(this.connectionHealth.registerSource({
+        id: ownedCapability.id,
+        name: `${ownedCapability.name} ${ownedCapability.kind === "news" ? "News" : "Market Data"}`,
+        kind: ownedCapability.kind,
+        ownerId: pluginId,
+        priority: ownedCapability.priority,
+        detail: ownedCapability.sourceId,
+      }));
+    }
 
     if (ownedCapability.kind === "news") {
       const dispose = this.registerNewsCapabilityFn(ownedCapability as NewsCapability);
@@ -412,6 +461,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
       contributions: this.contributions,
       enableCapabilityHandlers: this.enableCapabilityHandlers,
       marketData: this.marketData,
+      connectionHealth: this.connectionHealth,
       tickerRepository: this.tickerRepository,
       persistence: this.persistence,
       getLayout: () => this.getLayoutFn(),

package/src/plugins/runtime/context.tsx

@@ -5,7 +5,8 @@ import {
   type ReactNode,
 } from "react";
 import type { BrokerAdapter } from "../../types/broker";
-import type { PluginCapability } from "../../capabilities";
+import type { ConnectionHealthRegistry } from "../../core/connection-health";
+import type { CapabilityInvoker, PluginCapability } from "../../capabilities";
 import type { DataProvider } from "../../types/data-provider";
 import type {
   AppNotificationRequest,
@@ -16,8 +17,9 @@ import type {
   TickerResearchTabDef,
 } from "../../types/plugin";
 
-export interface PluginRuntimeAccess {
+export interface PluginRuntimeAccess extends CapabilityInvoker {
   getMarketData(): DataProvider | null;
+  getConnectionHealth(): ConnectionHealthRegistry;
   getCapability(capabilityId: string): PluginCapability | null;
   getBrokerAdapter(brokerType: string): BrokerAdapter | null;
   connectBrokerInstance(instanceId: string): Promise<void>;

package/src/plugins/runtime/index.tsx

@@ -103,6 +103,15 @@ export function useAssetData(): ReturnType<PluginRuntimeAccess["getMarketData"]>
   return useMarketData();
 }
 
+export function useConnectionHealth(): ReturnType<PluginRuntimeAccess["getConnectionHealth"]> {
+  const { runtime } = usePluginRenderContext();
+  return runtime.getConnectionHealth();
+}
+
+export function useCapabilityInvoker(): PluginRuntimeAccess {
+  return usePluginRenderContext().runtime;
+}
+
 export function usePluginBrokerActions() {
   const { runtime } = usePluginRenderContext();
   return {

package/src/remote/controller.test.ts

@@ -7,11 +7,24 @@ import { createAppRemoteController } from "./controller";
 import type { RemoteControlSchema, RemoteUiNodeSnapshot } from "./types";
 import type { RemoteUiRegistry } from "./semantic-tree";
 
-function createRegistryHarness() {
-  let state = createInitialState({
+function createRegistryHarness(options: { withFloatingPane?: boolean } = {}) {
+  const config = {
     ...createDefaultConfig("/tmp/gloom-remote-controller"),
     onboardingComplete: true,
-  });
+  };
+  if (options.withFloatingPane) {
+    const instance = {
+      instanceId: "help:test",
+      paneId: "help",
+      binding: { kind: "none" as const },
+    };
+    config.layout = {
+      ...config.layout,
+      instances: [...config.layout.instances, instance],
+      floating: [{ instanceId: instance.instanceId, x: 8, y: 4, width: 60, height: 24 }],
+    };
+  }
+  let state = createInitialState(config);
   const actions: AppAction[] = [];
   const dispatch: Dispatch<AppAction> = (action) => {
     actions.push(action);
@@ -440,7 +453,7 @@ describe("createAppRemoteController", () => {
   });
 
   test("closes floating panes and grids visible panes through layout helpers", async () => {
-    const { controller, getState } = createRegistryHarness();
+    const { controller, getState } = createRegistryHarness({ withFloatingPane: true });
     expect(getState().config.layout.floating.length).toBeGreaterThan(0);
 
     const closeResponse = await controller.handle({

package/src/renderers/electrobun/bun/application-menu/index.ts

@@ -2,7 +2,7 @@ import type { ApplicationMenuItemConfig } from "electrobun/bun";
 import type { DesktopApplicationMenuCommand } from "../../../../types/desktop-menu";
 
 export const ELECTROBUN_APPLICATION_MENU_ACTION = "gloom.application-menu.select";
-const GITHUB_ISSUE_URL = "https://github.com/vincelwt/gloomberb/issues/new/choose";
+const GITHUB_ISSUE_URL = "https://github.com/gloom-sh/gloomberb/issues/new/choose";
 
 export type ElectrobunApplicationMenuCommand =
   | DesktopApplicationMenuCommand

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

@@ -225,8 +225,8 @@ async function writeTextEnsuringParent(path: string, value: string): Promise<voi
 async function deleteFileIfPresent(path: string): Promise<void> {
   try {
     await unlink(path);
-  } catch {
-    // ignore missing files
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
   }
 }
 

package/src/renderers/electrobun/bun/desktop/capability-bridge.test.ts

@@ -0,0 +1,64 @@
+import { expect, test } from "bun:test";
+import { CapabilityRegistry } from "../../../../capabilities/registry";
+import { DesktopCapabilityBridge } from "./capability-bridge";
+
+type TestRpc = {
+  key: string;
+  send: { "capability.event": (_payload: { subscriptionId: string; event: unknown }) => void };
+};
+
+const rpc = (key: string): TestRpc => ({
+  key,
+  send: { "capability.event": () => {} },
+});
+
+test("desktop capability cancellation is window-scoped and window cleanup aborts active work", async () => {
+  const signals = new Map<string, AbortSignal>();
+  const registry = new CapabilityRegistry();
+  registry.register("test", {
+    id: "test.capability",
+    kind: "plugin-service",
+    name: "Test",
+    operations: {
+      wait: {
+        kind: "query",
+        rendererSafe: true,
+        handler: (input: { name: string }, context) => new Promise((_resolve, reject) => {
+          const signal = context.signal!;
+          signals.set(input.name, signal);
+          signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+        }),
+      },
+    },
+  });
+  const bridge = new DesktopCapabilityBridge<TestRpc>({
+    getRegistry: () => registry,
+    getWindowKey: (client) => client.key,
+  });
+  const windowA = rpc("window-a");
+  const windowB = rpc("window-b");
+  const invoke = (client: TestRpc, name: string) => bridge.handle(client, {
+    method: "capability.invoke",
+    payload: {
+      capabilityId: "test.capability",
+      operationId: "wait",
+      payload: { name },
+      invocationId: "same-client-id",
+    },
+  });
+
+  const first = invoke(windowA, "first").catch((error) => error);
+  const second = invoke(windowB, "second").catch((error) => error);
+
+  await bridge.handle(windowA, {
+    method: "capability.cancel",
+    payload: { invocationId: "same-client-id" },
+  });
+  expect(await first).toMatchObject({ name: "AbortError" });
+  expect(signals.get("first")?.aborted).toBe(true);
+  expect(signals.get("second")?.aborted).toBe(false);
+
+  bridge.disposeWindow("window-b");
+  expect(await second).toMatchObject({ name: "AbortError" });
+  expect(signals.get("second")?.aborted).toBe(true);
+});

package/src/renderers/electrobun/bun/desktop/capability-bridge.ts

@@ -17,6 +17,7 @@ interface DesktopCapabilityBridgeOptions<Rpc extends DesktopCapabilityRpc> {
 
 export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
   private readonly subscriptions = new Map<string, () => void>();
+  private readonly invocations = new Map<string, AbortController>();
 
   constructor(private readonly options: DesktopCapabilityBridgeOptions<Rpc>) {}
 
@@ -29,6 +30,8 @@ export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
       }
     }
     this.subscriptions.clear();
+    for (const controller of this.invocations.values()) controller.abort();
+    this.invocations.clear();
   }
 
   disposeWindow(windowKey: string): void {
@@ -42,6 +45,11 @@ export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
       }
       this.subscriptions.delete(id);
     }
+    for (const [id, controller] of this.invocations) {
+      if (!id.startsWith(scopedPrefix)) continue;
+      controller.abort();
+      this.invocations.delete(id);
+    }
   }
 
   async handle(
@@ -50,13 +58,39 @@ export class DesktopCapabilityBridge<Rpc extends DesktopCapabilityRpc> {
   ): Promise<unknown> {
     const registry = this.options.getRegistry();
     switch (request.method) {
-      case "capability.invoke":
-        return registry.invoke(
-          request.payload.capabilityId,
-          request.payload.operationId,
-          request.payload.payload,
-          { renderer: true },
-        );
+      case "capability.invoke": {
+        const clientInvocationId = request.payload.invocationId;
+        if (!clientInvocationId) {
+          return registry.invoke(
+            request.payload.capabilityId,
+            request.payload.operationId,
+            request.payload.payload,
+            { renderer: true },
+          );
+        }
+        const scopedInvocationId = this.scopeClientId(rpc, clientInvocationId);
+        if (this.invocations.has(scopedInvocationId)) {
+          throw new Error(`Capability invocation "${clientInvocationId}" is already active.`);
+        }
+        const controller = new AbortController();
+        this.invocations.set(scopedInvocationId, controller);
+        try {
+          return await registry.invoke(
+            request.payload.capabilityId,
+            request.payload.operationId,
+            request.payload.payload,
+            { renderer: true, signal: controller.signal },
+          );
+        } finally {
+          if (this.invocations.get(scopedInvocationId) === controller) {
+            this.invocations.delete(scopedInvocationId);
+          }
+        }
+      }
+      case "capability.cancel": {
+        this.invocations.get(this.scopeClientId(rpc, request.payload.invocationId))?.abort();
+        return null;
+      }
       case "capability.subscribe": {
         const clientSubscriptionId = request.payload.subscriptionId;
         const scopedSubscriptionId = this.scopeClientId(rpc, clientSubscriptionId);

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

@@ -7,6 +7,7 @@ import type {
   DesktopRestartMessage,
   DesktopWindowControlAction,
 } from "../../shared/protocol";
+import { safeExternalUrl } from "../../../../utils/external-url";
 import { getContextMenuRequestId, normalizeContextMenuItems } from "../context-menu/normalize";
 import { MAIN_WINDOW_RPC_KEY } from "../window/focus";
 
@@ -102,12 +103,14 @@ export function handleDesktopHostRequest<TRpc>({
       }
       return null;
     }
-    case "host.openExternal":
+    case "host.openExternal": {
       if (typeof request.payload.url !== "string") {
         throw new Error("host.openExternal requires a URL.");
       }
-      Utils.openExternal(request.payload.url);
+      const externalUrl = safeExternalUrl(request.payload.url);
+      if (externalUrl) Utils.openExternal(externalUrl);
       return null;
+    }
     case "host.copyText":
       Utils.clipboardWriteText(normalizeText(request.payload.text) ?? "");
       return null;

package/src/renderers/electrobun/bun/desktop/http-fetch.test.ts

@@ -1,11 +1,21 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import {
+  connectionHealth,
+  registerGloomCloudConnectionSources,
+} from "../../../../core/connection-health";
 import { handleHttpFetch } from "./http-fetch";
 
 let server: ReturnType<typeof Bun.serve> | null = null;
+let disposeConnections: (() => void) | null = null;
+const originalApiUrl = process.env.GLOOMBERB_API_URL;
 
 afterEach(() => {
   server?.stop(true);
   server = null;
+  disposeConnections?.();
+  disposeConnections = null;
+  if (originalApiUrl === undefined) delete process.env.GLOOMBERB_API_URL;
+  else process.env.GLOOMBERB_API_URL = originalApiUrl;
 });
 
 describe("handleHttpFetch", () => {
@@ -40,6 +50,29 @@ describe("handleHttpFetch", () => {
     expect(response.setCookie).toEqual(["substack.sid=sid123; Path=/; HttpOnly"]);
   });
 
+  test("reports proxied Gloom FRED requests in the backend registry", async () => {
+    server = Bun.serve({
+      port: 0,
+      fetch: () => Response.json({ observations: [], info: null }),
+    });
+    process.env.GLOOMBERB_API_URL = server.url.origin;
+    disposeConnections = registerGloomCloudConnectionSources(connectionHealth);
+
+    await handleHttpFetch({
+      url: new URL("/cloud/econ/series/VIXCLS", server.url).toString(),
+    });
+
+    expect(connectionHealth.getSnapshot().sources.map((source) => ({
+      id: source.id,
+      status: source.status,
+      operation: source.lastOperation,
+    }))).toEqual([
+      { id: "gloom-cloud-http", status: "connected", operation: "GET /cloud/econ/series/VIXCLS" },
+      { id: "gloom-cloud-socket", status: "idle", operation: null },
+      { id: "gloom-cloud-fred", status: "connected", operation: "GET /cloud/econ/series/VIXCLS" },
+    ]);
+  });
+
   test("aborts the backend fetch at the requested deadline", async () => {
     server = Bun.serve({
       port: 0,

package/src/renderers/electrobun/bun/desktop/http-fetch.ts

@@ -1,5 +1,38 @@
+import {
+  connectionHealth,
+  GLOOM_CLOUD_FRED_CONNECTION_ID,
+  GLOOM_CLOUD_HTTP_CONNECTION_ID,
+} from "../../../../core/connection-health";
 import type { DesktopBackendRequestPayload, DesktopHttpFetchResponse } from "../../shared/protocol";
 
+function isGloomCloudUrl(url: URL): boolean {
+  try {
+    return url.origin === new URL(process.env.GLOOMBERB_API_URL ?? "https://api.gloom.sh").origin;
+  } catch {
+    return false;
+  }
+}
+
+function reportCloudRequest(
+  url: URL,
+  method: string,
+  latencyMs: number,
+  success: boolean,
+  error?: unknown,
+): void {
+  if (!isGloomCloudUrl(url)) return;
+  const report = {
+    operation: `${method} ${url.pathname}`,
+    success,
+    latencyMs,
+    ...(error === undefined ? {} : { error }),
+  };
+  connectionHealth.reportRequest(GLOOM_CLOUD_HTTP_CONNECTION_ID, report);
+  if (url.pathname.startsWith("/cloud/econ/series/")) {
+    connectionHealth.reportRequest(GLOOM_CLOUD_FRED_CONNECTION_ID, report);
+  }
+}
+
 function normalizeHttpFetchHeaders(headers: unknown): Record<string, string> {
   if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
     return {};
@@ -46,13 +79,27 @@ export async function handleHttpFetch(
       ? init.timeoutMs
       : undefined;
 
-  const response = await fetch(url, {
+  const startedAt = performance.now();
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers: normalizeHttpFetchHeaders(init.headers),
+      body,
+      redirect,
+      signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
+    });
+  } catch (error) {
+    reportCloudRequest(url, method, performance.now() - startedAt, false, error);
+    throw error;
+  }
+  reportCloudRequest(
+    url,
     method,
-    headers: normalizeHttpFetchHeaders(init.headers),
-    body,
-    redirect,
-    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
-  });
+    performance.now() - startedAt,
+    response.ok,
+    response.ok ? undefined : new Error(`${response.status} ${response.statusText}`.trim()),
+  );
   const responseHeaders: Record<string, string> = {};
   response.headers.forEach((value, key) => {
     responseHeaders[key] = value;

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

@@ -0,0 +1,27 @@
+import { expect, test } from "bun:test";
+import { CapabilityRegistry } from "../../../../capabilities";
+import { desktopRendererCapabilityManifests } from "./initialization";
+
+test("desktop init includes disabled renderer-safe manifests while invocation stays disabled", async () => {
+  let enabled = false;
+  const registry = new CapabilityRegistry({ isPluginEnabled: () => enabled });
+  registry.register("charts", {
+    id: "charts.test",
+    kind: "chart-series",
+    name: "Test Charts",
+    operations: {
+      resolve: { kind: "query", rendererSafe: true, handler: () => "ok" },
+      private: { kind: "read", handler: () => "private" },
+    },
+  });
+
+  expect(desktopRendererCapabilityManifests(registry)).toEqual([expect.objectContaining({
+    id: "charts.test",
+    operations: [expect.objectContaining({ id: "resolve" })],
+  })]);
+  await expect(registry.invoke("charts.test", "resolve", {}, { renderer: true }))
+    .rejects.toThrow("not available");
+
+  enabled = true;
+  await expect(registry.invoke("charts.test", "resolve", {}, { renderer: true })).resolves.toBe("ok");
+});

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

@@ -25,6 +25,7 @@ import {
   paneIdFromDetachedRpcKey,
 } from "../window/focus";
 import type { DesktopBackendRequestPayload, ElectrobunBackendInit } from "../../shared/protocol";
+import type { CapabilityRegistry } from "../../../../capabilities";
 
 interface DesktopWindowTarget {
   kind: "main" | "detached";
@@ -81,6 +82,10 @@ function normalizeInitWindowTarget<TRpc>(
   };
 }
 
+export function desktopRendererCapabilityManifests(registry: CapabilityRegistry) {
+  return registry.manifests({ rendererOnly: true, includeDisabled: true });
+}
+
 function buildInitializationPayload(
   config: AppConfig,
   services: AppServices,
@@ -93,7 +98,7 @@ function buildInitializationPayload(
     desktopSnapshot: options.getDesktopSnapshot(),
     desktopThemePreview: options.desktopThemePreview,
     pluginState: loadDesktopPluginState(services.pluginRegistry),
-    capabilityManifests: services.pluginRegistry.capabilities.manifests({ rendererOnly: true }),
+    capabilityManifests: desktopRendererCapabilityManifests(services.pluginRegistry.capabilities),
     desktopPlatform: process.platform,
     windowKind: windowTarget.kind,
     paneId: windowTarget.paneId,

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

@@ -441,6 +441,7 @@ async function handleBackendRequest(
     case "remote.forward":
       return forwardRemoteControlRequest(request.payload.request);
     case "capability.invoke":
+    case "capability.cancel":
     case "capability.subscribe":
     case "capability.unsubscribe":
       return capabilityBridge.handle(rpc, request);

package/src/renderers/electrobun/shared/protocol.ts

@@ -76,6 +76,7 @@ export interface DesktopCapabilityInvokeRequest {
   capabilityId: string;
   operationId: string;
   payload?: unknown;
+  invocationId?: string;
 }
 
 export interface DesktopCapabilitySubscribeRequest extends DesktopCapabilityInvokeRequest {
@@ -91,6 +92,7 @@ export interface DesktopBackendRequestMap {
   "media.resolveLiveStream": { request: LiveStreamResolveRequest; response: ResolvedLiveStream };
   "remote.forward": { request: { request: RemoteControlRequest }; response: RemoteControlResponse };
   "capability.invoke": { request: DesktopCapabilityInvokeRequest; response: unknown };
+  "capability.cancel": { request: { invocationId: string }; response: null };
   "capability.subscribe": { request: DesktopCapabilitySubscribeRequest; response: null };
   "capability.unsubscribe": { request: { subscriptionId: string }; response: null };
   "desktop.syncMainState": { request: { snapshot: DesktopSharedStateSnapshot }; response: null };