gloomberb 0.9.7 → 0.9.9

package/src/plugins/registry/index.ts

@@ -27,6 +27,12 @@ import type {
 } from "../../types/plugin";
 import type { ContextMenuContext, ContextMenuItem } from "../../types/context-menu";
 import type { TickerRecord } from "../../types/ticker";
+import type {
+  RegisteredSyncContributor,
+  RegisteredSyncTransport,
+  SyncContributor,
+  SyncTransport,
+} from "../../sync/types";
 import { EventBus } from "../event-bus";
 import { resolvePaneInstance } from "../../types/config";
 import { debugLog } from "../../utils/debug-log";
@@ -49,6 +55,7 @@ import {
   releaseSharedRegistry,
 } from "./shared";
 import { RegistryResumeStateListeners } from "./plugin-state";
+import { cloudSyncController } from "../../sync/controller";
 
 interface PluginRegistryOptions {
   enableCapabilityHandlers?: boolean;
@@ -215,6 +222,28 @@ export class PluginRegistry implements PluginRuntimeAccess {
   get tickerActions(): ReadonlyMap<string, TickerAction> { return this.contributions.tickerActionsMap; }
   get allPlugins(): ReadonlyMap<string, GloomPlugin> { return this.plugins; }
 
+  registerSyncContributorForPlugin(pluginId: string, contributor: SyncContributor): () => void {
+    return cloudSyncController.registerContributor(pluginId, contributor);
+  }
+
+  registerSyncTransportForPlugin(pluginId: string, transport: SyncTransport): () => void {
+    return cloudSyncController.registerTransport(pluginId, transport);
+  }
+
+  getEnabledSyncContributors(): RegisteredSyncContributor[] {
+    const disabledPlugins = new Set(this.getConfigFn().disabledPlugins ?? []);
+    return cloudSyncController
+      .getRegisteredContributors()
+      .filter((entry) => !disabledPlugins.has(entry.pluginId));
+  }
+
+  getActiveSyncTransport(): RegisteredSyncTransport | null {
+    const disabledPlugins = new Set(this.getConfigFn().disabledPlugins ?? []);
+    return cloudSyncController
+      .getRegisteredTransports()
+      .find((entry) => !disabledPlugins.has(entry.pluginId) && entry.transport.isAvailable()) ?? null;
+  }
+
   getContextMenuItems(context: ContextMenuContext): ContextMenuItem[] {
     return resolveRegistryContextMenuItems({
       context,
@@ -373,6 +402,8 @@ export class PluginRegistry implements PluginRuntimeAccess {
       updateLayout: (layout) => this.updateLayoutFn(layout),
       resolvePaneTarget: (paneId) => this.resolvePaneTarget(paneId),
       registerCapabilityForPlugin: (targetPluginId, capability, pluginItems) => this.registerCapabilityForPlugin(targetPluginId, capability, pluginItems),
+      registerSyncContributorForPlugin: (targetPluginId, contributor) => this.registerSyncContributorForPlugin(targetPluginId, contributor),
+      registerSyncTransportForPlugin: (targetPluginId, transport) => this.registerSyncTransportForPlugin(targetPluginId, transport),
       watchNewsQuery: (query, listener) => this.watchNewsQueryFn(query, listener),
       getData: (ticker) => this.getDataFn(ticker),
       getTicker: (symbol) => this.getTickerFn(symbol),
@@ -410,35 +441,47 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
   async register(plugin: GloomPlugin): Promise<void> {
     this.registryLog.info(`Registering plugin: ${plugin.id} v${plugin.version ?? "?"}`);
-    const items = this.contributions.getOrCreatePluginItems(plugin.id);
-    if (plugin.panes) {
-      for (const pane of plugin.panes) {
-        this.contributions.registerPane(plugin.id, pane, items);
+    if (this.plugins.has(plugin.id)) throw new Error(`Plugin already registered: ${plugin.id}`);
+    this.plugins.set(plugin.id, plugin);
+    try {
+      const items = this.contributions.getOrCreatePluginItems(plugin.id);
+      if (plugin.panes) {
+        for (const pane of plugin.panes) {
+          this.contributions.registerPane(plugin.id, pane, items);
+        }
       }
-    }
 
-    if (plugin.paneTemplates) {
-      for (const template of plugin.paneTemplates) {
-        this.contributions.registerPaneTemplate(plugin.id, template, items);
+      if (plugin.paneTemplates) {
+        for (const template of plugin.paneTemplates) {
+          this.contributions.registerPaneTemplate(plugin.id, template, items);
+        }
       }
-    }
-
-    if (plugin.broker) {
-      this.contributions.registerBroker(plugin.id, plugin.broker, items);
-    }
 
-    if (this.enableCapabilityHandlers && plugin.capabilities) {
-      for (const capability of plugin.capabilities) {
-        this.registerCapabilityForPlugin(plugin.id, capability, items);
+      if (plugin.broker) {
+        this.contributions.registerBroker(plugin.id, plugin.broker, items);
       }
-    }
 
-    this.slots.register(plugin, this);
+      if (this.enableCapabilityHandlers && plugin.capabilities) {
+        for (const capability of plugin.capabilities) {
+          this.registerCapabilityForPlugin(plugin.id, capability, items);
+        }
+      }
 
-    this.plugins.set(plugin.id, plugin);
+      this.slots.register(plugin, this);
 
-    if (plugin.setup) {
-      await plugin.setup(this.createContext(plugin.id));
+      if (plugin.setup) {
+        await plugin.setup(this.createContext(plugin.id));
+      }
+    } catch (error) {
+      try {
+        this.removePlugin(plugin.id);
+      } catch (cleanupError) {
+        this.registryLog.error("Failed to clean up rejected plugin registration", {
+          pluginId: plugin.id,
+          error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+        });
+      }
+      throw error;
     }
 
     this.events.emit("plugin:registered", { pluginId: plugin.id });
@@ -449,13 +492,19 @@ export class PluginRegistry implements PluginRuntimeAccess {
     if (!plugin) return;
     this.registryLog.info(`Unregistering plugin: ${pluginId}`);
 
-    plugin.dispose?.();
-    this.slots.unregister(pluginId);
-
-    this.contributions.unregister(pluginId);
+    this.removePlugin(pluginId);
+    this.events.emit("plugin:unregistered", { pluginId });
+  }
 
+  private removePlugin(pluginId: string): void {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) return;
+    let cleanupError: unknown;
+    try { plugin.dispose?.(); } catch (error) { cleanupError = error; }
+    try { this.slots.unregister(pluginId); } catch (error) { cleanupError ??= error; }
+    try { this.contributions.unregister(pluginId); } catch (error) { cleanupError ??= error; }
     this.plugins.delete(pluginId);
-    this.events.emit("plugin:unregistered", { pluginId });
+    if (cleanupError) throw cleanupError;
   }
 
   destroy(): void {

package/src/remote/controller.ts

@@ -51,7 +51,6 @@ interface AppRemoteControllerOptions {
 }
 
 const DEFAULT_MUTATION_INCLUDE: RemoteStateInclude[] = ["app", "layout", "panes", "commandBar"];
-const DEFAULT_BATCH_INCLUDE: RemoteStateInclude[] = ["app", "layout", "panes", "commandBar"];
 
 export function createAppRemoteController({
   dispatch,
@@ -68,11 +67,6 @@ export function createAppRemoteController({
     uiRegistry,
   });
 
-  const getAfterMutation = async (resource: string): Promise<unknown> => {
-    await afterMutation();
-    return getResource(resource);
-  };
-
   const getAfterMutationSummary = async (extra?: Record<string, unknown>): Promise<unknown> => {
     await afterMutation();
     return mutationSummary(getState(), extra);
@@ -420,7 +414,7 @@ export function createAppRemoteController({
             ok: responses.every((response) => response.ok),
             haltedAt,
             responses,
-          }, undefined, buildIncludedState(request.include, request.dryRun ? [] : DEFAULT_BATCH_INCLUDE));
+          }, undefined, buildIncludedState(request.include, request.dryRun ? [] : DEFAULT_MUTATION_INCLUDE));
         }
         default:
           throw new Error(`Unknown remote request type: ${(request as { type?: unknown }).type}`);

package/src/remote/json-patch.ts

@@ -12,6 +12,14 @@ function pointerSegments(path: string): string[] {
   return path.slice(1).split("/").map(decodePointerSegment);
 }
 
+const UNSAFE_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function assertSafeObjectKey(key: string): void {
+  if (UNSAFE_OBJECT_KEYS.has(key)) {
+    throw new Error(`Unsafe object key in JSON patch path: ${key}`);
+  }
+}
+
 function cloneJson<T>(value: T): T {
   return value == null ? value : JSON.parse(JSON.stringify(value)) as T;
 }
@@ -30,12 +38,18 @@ function containerFor(root: unknown, path: string): { parent: unknown; key: stri
       }
       parent = parent[index];
     } else if (parent && typeof parent === "object") {
+      assertSafeObjectKey(segment);
+      if (!Object.prototype.hasOwnProperty.call(parent, segment)) {
+        throw new Error(`Cannot descend into missing object key: ${segment}`);
+      }
       parent = (parent as Record<string, unknown>)[segment];
     } else {
       throw new Error(`Cannot descend into non-object patch path: ${path}`);
     }
   }
-  return { parent, key: segments[segments.length - 1]! };
+  const key = segments[segments.length - 1]!;
+  if (!Array.isArray(parent)) assertSafeObjectKey(key);
+  return { parent, key };
 }
 
 function applyOperation(root: unknown, operation: RemoteJsonPatchOperation): void {

package/src/remote/server.ts

@@ -45,21 +45,31 @@ export async function startRemoteControlServer(options: RemoteControlServerOptio
     token,
     startedAt: new Date().toISOString(),
   };
-  await writeRemoteEndpointFiles(options.dataDir, endpoint);
+  try {
+    await writeRemoteEndpointFiles(options.dataDir, endpoint);
+  } catch (error) {
+    await closeHttpServer(httpServer);
+    await removeRemoteEndpointFiles(options.dataDir, endpoint).catch(() => {});
+    throw error;
+  }
 
   return {
     endpoint,
     close: async () => {
-      await new Promise<void>((resolve, reject) => {
-        httpServer.close((error) => (error ? reject(error) : resolve()));
-      }).catch((error) => {
-        if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
-      });
+      await closeHttpServer(httpServer);
       await removeRemoteEndpointFiles(options.dataDir, endpoint);
     },
   };
 }
 
+async function closeHttpServer(httpServer: ReturnType<typeof createServer>): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    httpServer.close((error) => (error ? reject(error) : resolve()));
+  }).catch((error) => {
+    if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
+  });
+}
+
 async function handleHttpRequest(
   handle: RemoteControlServerOptions["handle"],
   token: string,

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

@@ -26,7 +26,7 @@ function openCommandBar(label: string, query: string, options?: { accelerator?:
   return commandItem(label, { type: "open-command-bar", query }, options);
 }
 
-export function buildApplicationMenu(): ApplicationMenuItemConfig[] {
+function buildApplicationMenu(): ApplicationMenuItemConfig[] {
   return [
     {
       label: "Gloomberb",

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

@@ -19,6 +19,7 @@ const NOTES_INDEX_FILE = "__quick-notes-index__.json";
 const BROKER_INVOKE_OPERATIONS = new Set([
   "validate",
   "importPositions",
+  "importPortfolioSnapshot",
   "connect",
   "disconnect",
   "getPersistedConfigUpdate",
@@ -96,6 +97,7 @@ function invokeBrokerOperation(
   switch (operation) {
     case "validate":
     case "importPositions":
+    case "importPortfolioSnapshot":
     case "connect":
     case "disconnect":
     case "getPersistedConfigUpdate":

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

@@ -39,4 +39,18 @@ describe("handleHttpFetch", () => {
     expect(response.headers.location).toBe("/reader");
     expect(response.setCookie).toEqual(["substack.sid=sid123; Path=/; HttpOnly"]);
   });
+
+  test("aborts the backend fetch at the requested deadline", async () => {
+    server = Bun.serve({
+      port: 0,
+      fetch() {
+        return new Promise<Response>(() => {});
+      },
+    });
+
+    await expect(handleHttpFetch({
+      url: server.url.toString(),
+      init: { timeoutMs: 10 },
+    })).rejects.toThrow();
+  });
 });

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

@@ -34,12 +34,20 @@ export async function handleHttpFetch(payload: Record<string, unknown>) {
     typeof init.body === "string" && method !== "GET" && method !== "HEAD"
       ? init.body
       : undefined;
+  const timeoutMs =
+    typeof init.timeoutMs === "number"
+      && Number.isFinite(init.timeoutMs)
+      && init.timeoutMs > 0
+      && init.timeoutMs <= 120_000
+      ? init.timeoutMs
+      : undefined;
 
   const response = await fetch(url, {
     method,
     headers: normalizeHttpFetchHeaders(init.headers),
     body,
     redirect,
+    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
   });
   const responseHeaders: Record<string, string> = {};
   response.headers.forEach((value, key) => {

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

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
 import { join } from "path";
 import { createAppServices, type AppServices } from "../../../../core/app-services";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
@@ -98,7 +99,7 @@ function buildInitializationPayload(
 }
 
 async function resolveDesktopDataDir(): Promise<string> {
-  const dataDir = await getDataDir() ?? join(process.env.HOME || "~", ".gloomberb");
+  const dataDir = await getDataDir() ?? join(process.env.HOME || homedir(), ".gloomberb");
   if (!existsSync(dataDir)) {
     mkdirSync(dataDir, { recursive: true });
   }

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

@@ -103,6 +103,41 @@ function requireDesktopWorkspace(): DesktopWorkspace {
   return desktopWorkspace;
 }
 
+const pendingDesktopDeepLinks: string[] = [];
+
+function isGloomberbDeepLink(rawUrl: string): boolean {
+  try {
+    return new URL(rawUrl).protocol === "gloomberb:";
+  } catch {
+    return false;
+  }
+}
+
+function readOpenUrlEvent(event: unknown): string | null {
+  const data = event && typeof event === "object" ? (event as { data?: unknown }).data : null;
+  if (!data || typeof data !== "object") return null;
+  const url = (data as { url?: unknown }).url;
+  return typeof url === "string" && url ? url : null;
+}
+
+function sendDesktopDeepLink(rawUrl: string): void {
+  if (!isGloomberbDeepLink(rawUrl)) return;
+  const rpc = getWindowRpc(MAIN_WINDOW_RPC_KEY);
+  if (!rpc || !isWindowRpcReady(MAIN_WINDOW_RPC_KEY)) {
+    pendingDesktopDeepLinks.push(rawUrl);
+    if (pendingDesktopDeepLinks.length > 20) pendingDesktopDeepLinks.shift();
+    return;
+  }
+  detachedWindowManager.focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY);
+  rpc.send["desktop.deepLink"]({ url: rawUrl });
+}
+
+function flushPendingDesktopDeepLinks(): void {
+  if (pendingDesktopDeepLinks.length === 0) return;
+  const urls = pendingDesktopDeepLinks.splice(0);
+  for (const url of urls) sendDesktopDeepLink(url);
+}
+
 function remoteFailure(code: string, message: string): RemoteControlResponse {
   return { ok: false, error: { code, message } };
 }
@@ -377,6 +412,7 @@ async function initialize(
     syncConfigAccessors,
   });
   if (init.windowKind === "main") {
+    flushPendingDesktopDeepLinks();
     void ensureDesktopRemoteControlServer().catch((error) => {
       console.error("[remote] desktop control endpoint failed", summarizeError(error));
     });
@@ -502,6 +538,12 @@ Electrobun.events.on("context-menu-clicked", (event: unknown) => {
   });
 });
 
+Electrobun.events.on("open-url", (event: unknown) => {
+  const url = readOpenUrlEvent(event);
+  if (!url) return;
+  sendDesktopDeepLink(url);
+});
+
 ApplicationMenu.on("application-menu-clicked", (event: unknown) => {
   const command = applicationMenuCommand(event);
   if (!command) return;

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

@@ -60,6 +60,10 @@ export interface DesktopRestartMessage {
   source?: string;
 }
 
+export interface DesktopDeepLinkMessage {
+  url: string;
+}
+
 export interface RemoteControlRequestMessage {
   request: RemoteControlRequest;
 }
@@ -89,6 +93,7 @@ export interface ElectrobunDesktopRpcSchema {
       "desktop.state": DesktopStateMessage;
       "desktop.dockPreview": DesktopDockPreviewMessage;
       "desktop.themePreview": DesktopThemePreviewMessage;
+      "desktop.deepLink": DesktopDeepLinkMessage;
       "update.progress": UpdateProgressMessage;
       "capability.event": CapabilityEventMessage;
     };

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -4,6 +4,7 @@ import {
   type ApplicationMenuSelectMessage,
   type CapabilityEventMessage,
   type ContextMenuSelectMessage,
+  type DesktopDeepLinkMessage,
   type DesktopDockPreviewMessage,
   type DesktopRestartMessage,
   type DesktopStateMessage,
@@ -18,6 +19,7 @@ import type { RemoteControlRequest, RemoteControlResponse } from "../../../remot
 
 type ContextMenuSelectListener = (message: ContextMenuSelectMessage) => void;
 type ApplicationMenuSelectListener = (message: ApplicationMenuSelectMessage) => void;
+type DesktopDeepLinkListener = (message: DesktopDeepLinkMessage) => void;
 type DesktopStateListener = (message: DesktopStateMessage) => void;
 type DesktopDockPreviewListener = (message: DesktopDockPreviewMessage) => void;
 type DesktopThemePreviewListener = (message: DesktopThemePreviewMessage) => void;
@@ -29,6 +31,8 @@ let initSnapshot: ElectrobunBackendInit | null = null;
 let remoteControlRequestHandler: RemoteControlRequestHandler | null = null;
 const contextMenuSelectListeners = new Map<string, Set<ContextMenuSelectListener>>();
 const applicationMenuSelectListeners = new Set<ApplicationMenuSelectListener>();
+const desktopDeepLinkListeners = new Set<DesktopDeepLinkListener>();
+const pendingDesktopDeepLinks: DesktopDeepLinkMessage[] = [];
 const desktopStateListeners = new Set<DesktopStateListener>();
 const desktopDockPreviewListeners = new Set<DesktopDockPreviewListener>();
 const desktopThemePreviewListeners = new Set<DesktopThemePreviewListener>();
@@ -64,6 +68,17 @@ function subscribe<T>(
   };
 }
 
+function dispatchDesktopDeepLink(message: DesktopDeepLinkMessage): void {
+  if (desktopDeepLinkListeners.size === 0) {
+    pendingDesktopDeepLinks.push(message);
+    if (pendingDesktopDeepLinks.length > 20) pendingDesktopDeepLinks.shift();
+    return;
+  }
+  for (const listener of desktopDeepLinkListeners) {
+    listener(message);
+  }
+}
+
 const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
   maxRequestTime: 120_000,
   handlers: {
@@ -92,6 +107,10 @@ const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
           listener(decoded);
         }
       },
+      "desktop.deepLink": (message) => {
+        if (typeof message.url !== "string" || !message.url) return;
+        dispatchDesktopDeepLink({ url: message.url });
+      },
       "desktop.state": (message) => {
         for (const listener of desktopStateListeners) {
           listener({ snapshot: decodeRpcValue(message.snapshot) });
@@ -188,6 +207,16 @@ export function onApplicationMenuSelect(listener: ApplicationMenuSelectListener)
   };
 }
 
+export function onDesktopDeepLink(listener: DesktopDeepLinkListener): () => void {
+  desktopDeepLinkListeners.add(listener);
+  for (const message of pendingDesktopDeepLinks.splice(0)) {
+    listener(message);
+  }
+  return () => {
+    desktopDeepLinkListeners.delete(listener);
+  };
+}
+
 export function onDesktopState(listener: DesktopStateListener): () => void {
   desktopStateListeners.add(listener);
   return () => {

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -261,6 +261,7 @@ function createRuntime(payload: CliPaneShotPayload): PluginRuntimeAccess {
     switchPanel: () => {},
     openCommandBar: () => {},
     showPane: () => {},
+    createPaneFromTemplate: () => {},
     hidePane: () => {},
     focusPane: () => {},
     openPaneSettings: () => {},

package/src/renderers/electrobun/view/data-table/dom.ts

@@ -19,7 +19,6 @@ export const CSS_TEXT_DIM = "var(--gloom-text-dim)";
 export const CSS_TEXT_BRIGHT = "var(--gloom-text-bright)";
 export const CSS_SELECTED = "var(--gloom-selected)";
 export const CSS_SELECTED_TEXT = "var(--gloom-selected-text)";
-export const CSS_HOVER_BG = "var(--gloom-hover-bg)";
 
 function hasAttribute(attributes: unknown, flag: number): boolean {
   return typeof attributes === "number" && (attributes & flag) !== 0;