gloomberb 0.11.3 → 0.12.0

package/src/app.tsx

@@ -17,6 +17,7 @@ import { DetachedPaneShell } from "./components/layout/detached-pane-shell";
 import { TransientLayoutProvider } from "./components/layout/transient-layout";
 import { CommandBar } from "./components/command-bar/surface";
 import { OnboardingWizard } from "./components/onboarding/onboarding-wizard";
+import { SignInGate } from "./components/sign-in-gate";
 import { useDialog } from "./ui/dialog";
 import { PluginRegistry } from "./plugins/registry";
 import type { LoadedExternalPlugin } from "./plugins/loader";
@@ -55,10 +56,12 @@ import { measurePerf } from "./utils/perf-marks";
 import { useAppLanguage } from "./i18n/react";
 import { AppLanguageConfigObserver } from "./app/language-observer";
 import { isPaneShareHandoff } from "./shares/location";
+import { apiClient } from "./api-client";
 
 const EMPTY_EXTERNAL_PLUGINS: LoadedExternalPlugin[] = [];
 
 interface AppInnerProps {
+  externalPlugins: readonly LoadedExternalPlugin[];
   pluginRegistry: PluginRegistry;
   tickerRepository: AppTickerRepositoryPort;
   dataProvider: DataProvider;
@@ -71,6 +74,8 @@ interface AppInnerProps {
   updatesEnabled?: boolean;
   onboardingActive?: boolean;
   onOnboardingComplete?: (config: AppConfig) => void | Promise<void>;
+  /** Hosted browser terminal: nothing is reachable until a session exists. */
+  signInGateActive?: boolean;
 }
 
 function ThemedAppRoot({ children }: { children: ReactNode }) {
@@ -92,6 +97,7 @@ function ThemedAppRoot({ children }: { children: ReactNode }) {
 }
 
 function AppInner({
+  externalPlugins,
   pluginRegistry,
   tickerRepository,
   dataProvider,
@@ -104,6 +110,7 @@ function AppInner({
   updatesEnabled = true,
   onboardingActive = false,
   onOnboardingComplete,
+  signInGateActive = false,
 }: AppInnerProps) {
   const dispatch = useAppDispatch();
   const stateRef = useAppStateRef();
@@ -158,6 +165,13 @@ function AppInner({
     renderToast: (notification) => {
       const type = notification.type ?? "info";
       let toastId: string | number | undefined;
+      const dismissAfter = (run: () => void) => () => {
+        try {
+          run();
+        } finally {
+          if (toastId != null) toast.dismiss(toastId);
+        }
+      };
       const options = {
         title: notification.title,
         subtitle: notification.subtitle,
@@ -165,13 +179,13 @@ function AppInner({
         action: notification.action
           ? {
             label: notification.action.label,
-            onClick: () => {
-              try {
-                notification.action?.onClick();
-              } finally {
-                if (toastId != null) toast.dismiss(toastId);
-              }
-            },
+            onClick: dismissAfter(() => notification.action?.onClick()),
+          }
+          : undefined,
+        secondaryAction: notification.secondaryAction
+          ? {
+            label: notification.secondaryAction.label,
+            onClick: dismissAfter(() => notification.secondaryAction?.onClick()),
           }
           : undefined,
       };
@@ -249,7 +263,10 @@ function AppInner({
     desktopDeepLinkBridge,
     desktopWindowKind: desktopWindowBridge?.kind,
     dispatch,
-    initialized: state.initialized,
+    // The browser bridge re-emits from the URL on subscribe and nothing rewrites
+    // it, so a `?layout=` / `?share=` intent survives the gate and lands once a
+    // session exists. Running it earlier would only 401 behind the scrim.
+    initialized: state.initialized && !signInGateActive,
     pluginRegistry,
     stateRef,
   });
@@ -294,16 +311,23 @@ function AppInner({
     // onboarding finishes, the normal pull-before-push sync starts immediately.
     initialized: state.initialized
       && desktopWindowBridge?.kind !== "detached"
-      && !onboardingActive,
+      && !onboardingActive
+      && !signInGateActive,
   });
 
+  const persistConfig = useCallback((nextConfig: AppState["config"]) => {
+    scheduleConfigSave(nextConfig);
+  }, []);
+
   useAppPaneRuntime({
     dataProvider,
     detachedPaneId,
     dialog,
     dispatch,
+    externalPlugins,
     isDetachedWindow,
     notify,
+    persistConfig,
     pluginRegistry,
     state,
     stateRef,
@@ -376,14 +400,7 @@ function AppInner({
         desktopWindowBridge={desktopWindowBridge}
       >
         <ThemedAppRoot>
-          <Header
-            onOpenHelp={() => pluginRegistry.showPane("help")}
-            onOpenChangelog={(version) => {
-              void pluginRegistry.createPaneFromTemplateAsyncFn("changelog-pane", {
-                values: { version },
-              }).catch(() => {});
-            }}
-          />
+          <Header onOpenHelp={() => pluginRegistry.showPane("help")} />
           <TransientLayoutProvider>
             <Shell
               pluginRegistry={pluginRegistry}
@@ -391,7 +408,13 @@ function AppInner({
               desktopDockPreview={desktopDockPreview}
               commandBarNativeOccluder={commandBarNativeOccluder}
             />
-            <StatusBar />
+            <StatusBar
+              onOpenChangelog={(version) => {
+                void pluginRegistry.createPaneFromTemplateAsyncFn("changelog-pane", {
+                  values: { version },
+                }).catch(() => {});
+              }}
+            />
           </TransientLayoutProvider>
           {onboardingActive && onOnboardingComplete ? (
             <OnboardingWizard
@@ -400,6 +423,7 @@ function AppInner({
               onComplete={onOnboardingComplete}
             />
           ) : null}
+          {signInGateActive ? <SignInGate /> : null}
           {state.commandBarOpen && (
             <CommandBar
               dataProvider={dataProvider}
@@ -430,6 +454,11 @@ interface AppProps {
   desktopThemePreview?: DesktopThemePreviewState | null;
   remoteControlAdapter?: RemoteControlAdapter;
   updatesEnabled?: boolean;
+  /**
+   * Requires a Gloom Cloud session before the app is usable. The hosted browser
+   * terminal sets this; desktop and the TUI keep sign-in optional.
+   */
+  requireSignIn?: boolean;
 }
 
 export function App({
@@ -445,6 +474,7 @@ export function App({
   desktopThemePreview = null,
   remoteControlAdapter,
   updatesEnabled = true,
+  requireSignIn = false,
 }: AppProps) {
   useAppLanguage();
   const externalPlugins = providedExternalPlugins ?? EMPTY_EXTERNAL_PLUGINS;
@@ -469,6 +499,16 @@ export function App({
   const [config, setConfig] = useState(() => {
     return initialCliLaunch.config;
   });
+  // Only the surfaces that require a session subscribe, so desktop and the
+  // terminal keep their current render profile.
+  const [signedIn, setSignedIn] = useState(() => !requireSignIn || apiClient.isSignedIn());
+  useEffect(() => {
+    if (!requireSignIn) return;
+    const sync = () => setSignedIn(apiClient.isSignedIn());
+    sync();
+    return apiClient.subscribeCurrentUser(sync);
+  }, [requireSignIn]);
+  const signInGateActive = requireSignIn && !signedIn;
   const shareHandoff = isPaneShareHandoff();
   const [showOnboarding, setShowOnboarding] = useState(() => (
     desktopWindowBridge?.kind !== "detached"
@@ -518,6 +558,7 @@ export function App({
       >
         <AppLanguageConfigObserver />
         <AppInner
+          externalPlugins={externalPlugins}
           pluginRegistry={services.pluginRegistry}
           tickerRepository={services.tickerRepository}
           dataProvider={services.dataProvider}
@@ -529,6 +570,7 @@ export function App({
           remoteControlAdapter={remoteControlAdapter}
           updatesEnabled={updatesEnabled}
           onboardingActive={showOnboarding}
+          signInGateActive={signInGateActive}
           onOnboardingComplete={(updatedConfig) => {
             setConfig(updatedConfig);
             setShowOnboarding(false);

package/src/architecture/browser-entry-graph.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync } from "fs";
+import { dirname, join, relative, resolve } from "path";
+
+const SOURCE_ROOT = process.cwd();
+const IMPORT_PATTERN = /\b(?:import|export)\s+(?:[^'"]*?\s+from\s+)?["']([^"']+)["']|import\(["']([^"']+)["']\)/g;
+const TYPE_ONLY_PATTERN = /\b(?:import|export)\s+type\s/;
+
+/**
+ * Entry points that run in a browser context: the Electrobun desktop view and
+ * the hosted web app. Neither has `process`, a filesystem, or a Bun runtime.
+ */
+const BROWSER_ENTRIES = [
+  "src/renderers/electrobun/view/main.tsx",
+  "src/renderers/browser/main.tsx",
+];
+
+/**
+ * Modules that only work under Bun. Each reads the filesystem or the process
+ * environment at module scope, so merely importing one from a browser bundle
+ * throws on load — the bundle still builds, which is exactly what makes this
+ * worth a test.
+ *
+ * `plugins/loader` reaching the desktop view through `plugins/bundle` shipped a
+ * broken desktop build: the view crashed with "Can't find variable: process"
+ * before rendering anything, while `desktop:view:build` reported success.
+ */
+const BUN_ONLY_MODULES = [
+  "src/plugins/loader.ts",
+  "src/plugins/bundle.ts",
+  "src/plugins/seed.ts",
+  "src/plugins/host-link.ts",
+  "src/cli/restore-plugins.ts",
+];
+
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+
+function resolveSpecifier(fromFile: string, specifier: string): string | null {
+  if (!specifier.startsWith(".")) return null;
+  const base = resolve(dirname(fromFile), specifier);
+  for (const candidate of [base, ...EXTENSIONS.map((ext) => `${base}${ext}`), ...EXTENSIONS.map((ext) => join(base, `index${ext}`))]) {
+    if (existsSync(candidate) && !candidate.endsWith("/")) {
+      try {
+        if (Bun.file(candidate).size >= 0 && !candidate.match(/\/$/)) return candidate;
+      } catch {
+        // Directory or unreadable entry: keep trying the other candidates.
+      }
+    }
+  }
+  return null;
+}
+
+/** Walks runtime imports only; `import type` is erased and cannot pull code in. */
+async function reachableFrom(entry: string): Promise<Map<string, string[]>> {
+  const seen = new Map<string, string[]>();
+  const queue: Array<{ file: string; path: string[] }> = [{ file: resolve(SOURCE_ROOT, entry), path: [entry] }];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const key = relative(SOURCE_ROOT, current.file);
+    if (seen.has(key)) continue;
+    seen.set(key, current.path);
+
+    let source: string;
+    try {
+      source = await Bun.file(current.file).text();
+    } catch {
+      continue;
+    }
+
+    for (const line of source.split("\n")) {
+      if (TYPE_ONLY_PATTERN.test(line)) continue;
+      for (const match of line.matchAll(IMPORT_PATTERN)) {
+        const specifier = match[1] ?? match[2] ?? "";
+        const resolved = resolveSpecifier(current.file, specifier);
+        if (resolved) queue.push({ file: resolved, path: [...current.path, relative(SOURCE_ROOT, resolved)] });
+      }
+    }
+  }
+
+  return seen;
+}
+
+describe("browser entry import graph", () => {
+  for (const entry of BROWSER_ENTRIES) {
+    test(`${entry} does not reach a Bun-only module`, async () => {
+      const reachable = await reachableFrom(entry);
+
+      const violations = BUN_ONLY_MODULES
+        .filter((module) => reachable.has(module))
+        .map((module) => `${module} via ${reachable.get(module)!.slice(-3).join(" -> ")}`);
+
+      expect(violations).toEqual([]);
+    });
+  }
+});

package/src/brokers/profile-form.test.ts

@@ -1,62 +1,60 @@
 import { describe, expect, test } from "bun:test";
 import type { BrokerAdapter } from "../types/broker";
 import type { BrokerInstanceConfig } from "../types/config";
-import { ibkrBroker } from "../plugins/ibkr/broker-adapter";
+import { testBroker } from "./test-broker";
 import {
   buildBrokerProfileConfig,
   createBrokerProfileDraft,
   validateBrokerProfileValues,
 } from "./profile-form";
 
-function createFlexInstance(): BrokerInstanceConfig {
+function createSavedInstance(): BrokerInstanceConfig {
   return {
-    id: "ibkr-flex",
-    brokerType: "ibkr",
-    label: "IBKR Flex",
-    connectionMode: "flex",
+    id: "saved-profile",
+    brokerType: "test-broker",
+    label: "Saved Profile",
+    connectionMode: "token",
     config: {
-      connectionMode: "flex",
-      gatewaySetupMode: "auto",
-      flex: { token: "saved-token", queryId: "123", endpoint: "https://example.test/flex" },
-      gateway: { host: "127.0.0.1", marketDataType: "auto" },
+      connectionMode: "token",
+      credentials: { token: "saved-token", accountId: "123" },
+      host: "127.0.0.1",
     },
     enabled: true,
   };
 }
 
 describe("broker profile form helpers", () => {
-  test("builds canonical IBKR Flex config from flat values", () => {
-    const config = buildBrokerProfileConfig(ibkrBroker, {
-      connectionMode: "flex",
+  test("builds a nested broker config from flat form values", () => {
+    const config = buildBrokerProfileConfig(testBroker, {
+      connectionMode: "token",
       token: "token",
-      queryId: "456",
-      endpoint: "",
-      gatewaySetupMode: "auto",
+      accountId: "456",
+      host: "",
     });
 
     expect(config).toMatchObject({
-      connectionMode: "flex",
-      flex: { token: "token", queryId: "456" },
+      connectionMode: "token",
+      credentials: { token: "token", accountId: "456" },
     });
   });
 
   test("preserves saved password fields when editing leaves them blank", () => {
-    const previous = createFlexInstance();
-    const draft = createBrokerProfileDraft(ibkrBroker, previous);
+    const previous = createSavedInstance();
+    const draft = createBrokerProfileDraft(testBroker, previous);
     draft.values.token = "";
 
-    expect(validateBrokerProfileValues(ibkrBroker, draft.values, previous)).toBeNull();
-    expect(buildBrokerProfileConfig(ibkrBroker, draft.values, previous)).toMatchObject({
-      flex: { token: "saved-token" },
+    expect(validateBrokerProfileValues(testBroker, draft.values, previous)).toBeNull();
+    expect(buildBrokerProfileConfig(testBroker, draft.values, previous)).toMatchObject({
+      credentials: { token: "saved-token" },
     });
   });
 
   test("requires password fields for new profiles", () => {
-    expect(validateBrokerProfileValues(ibkrBroker, {
-      connectionMode: "flex",
+    expect(validateBrokerProfileValues(testBroker, {
+      connectionMode: "token",
       token: "",
-      queryId: "123",
-    })).toBe("Flex Token is required.");
+      accountId: "123",
+    })).toBe("API Token is required.");
   });
 
   test("falls back to raw values for generic brokers", () => {

package/src/brokers/test-broker.ts

@@ -0,0 +1,68 @@
+import type { BrokerAdapter } from "../types/broker";
+
+/**
+ * A stand-in broker for tests of the generic broker machinery.
+ *
+ * These tests used to reach for the real IBKR adapter, which now lives in its
+ * own repository. Depending on a plugin to exercise host code is backwards
+ * anyway: it made a core test fail whenever that plugin's schema changed, and
+ * it hid which behaviour was actually under test.
+ *
+ * The shape mirrors what the machinery has to handle — a mode switch, a nested
+ * config, and a password field that must survive an edit left blank.
+ */
+export const testBroker: BrokerAdapter = {
+  id: "test-broker",
+  name: "Test Broker",
+  configSchema: [
+    {
+      key: "connectionMode",
+      label: "Connection",
+      type: "select",
+      options: [
+        { value: "token", label: "Token" },
+        { value: "local", label: "Local" },
+      ],
+      defaultValue: "token",
+    },
+    { key: "token", label: "API Token", type: "password", required: true, visibleWhen: { connectionMode: "token" } },
+    { key: "accountId", label: "Account", type: "text", required: true, visibleWhen: { connectionMode: "token" } },
+    { key: "host", label: "Host", type: "text", defaultValue: "127.0.0.1", visibleWhen: { connectionMode: "local" } },
+  ],
+
+  async validate() {
+    return true;
+  },
+
+  async importPositions() {
+    return [];
+  },
+
+  getStatus() {
+    return { state: "disconnected", message: "", updatedAt: 0 };
+  },
+
+  getProfileActions() {
+    // The pane renders and invokes profile actions; one is enough to cover that.
+    return [{ id: "test-console", label: "Console", paneId: "ibkr-trading" }];
+  },
+
+  toConfigValues(instance) {
+    const config = instance.config as Record<string, unknown>;
+    const credentials = (config.credentials ?? {}) as Record<string, unknown>;
+    return {
+      connectionMode: String(config.connectionMode ?? "token"),
+      token: String(credentials.token ?? ""),
+      accountId: String(credentials.accountId ?? ""),
+      host: String(config.host ?? "127.0.0.1"),
+    };
+  },
+
+  fromConfigValues(values) {
+    return {
+      connectionMode: values.connectionMode,
+      credentials: { token: values.token, accountId: values.accountId },
+      host: values.host,
+    };
+  },
+};

package/src/cli/commands/plugins.ts

@@ -2,6 +2,7 @@ import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from "fs";
 import { execFileSync } from "child_process";
 import { getPluginsDir } from "../../plugins/loader";
+import { linkHostPackages } from "../../plugins/host-link";
 import {
   cliStyles,
   renderSection,
@@ -50,7 +51,20 @@ function parseGitHubRef(rawRef: string): { url: string; name: string } {
   throw new Error(`Invalid plugin reference: ${ref}. Use user/repo or a GitHub URL.`);
 }
 
-export async function installPlugin(ref: string) {
+export interface InstallPluginOptions {
+  /**
+   * Suppress child-process output and progress logging. The marketplace pane
+   * installs while the terminal UI owns the screen, and git and bun writing to
+   * stdout corrupts the rendered frame.
+   */
+  quiet?: boolean;
+}
+
+export async function installPlugin(ref: string, options: InstallPluginOptions = {}) {
+  const stdio = options.quiet ? "pipe" : "inherit";
+  const say = (message: string) => {
+    if (!options.quiet) console.log(message);
+  };
   ensurePluginsDir();
   const { url, name } = parseGitHubRef(ref);
   const targetDir = join(PLUGINS_DIR, name);
@@ -59,11 +73,11 @@ export async function installPlugin(ref: string) {
     fail(`Plugin "${name}" already exists.`, `Use "gloomberb update ${name}" to refresh it.`);
   }
 
-  console.log(cliStyles.accent(`Installing ${name}`));
-  console.log(cliStyles.muted(url));
+  say(cliStyles.accent(`Installing ${name}`));
+  say(cliStyles.muted(url));
 
   try {
-    execFileSync("git", ["clone", "--depth", "1", url, targetDir], { stdio: "inherit" });
+    execFileSync("git", ["clone", "--depth", "1", url, targetDir], { stdio });
   } catch {
     rmSync(targetDir, { recursive: true, force: true });
     fail(`Failed to clone ${url}.`);
@@ -71,11 +85,24 @@ export async function installPlugin(ref: string) {
 
   const pkgPath = join(targetDir, "package.json");
   if (existsSync(pkgPath)) {
-    console.log(cliStyles.muted("Installing plugin dependencies..."));
+    say(cliStyles.muted("Installing plugin dependencies..."));
     try {
-      execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
+      // --production: plugin repos depend on `gloomberb` as a devDependency so
+      // their own CI can typecheck against the real API. At runtime the host is
+      // symlinked in instead, and pulling a second full copy here would both
+      // waste a lot of disk and risk a duplicate React.
+      execFileSync("bun", ["install", "--production"], { cwd: targetDir, stdio });
     } catch {
-      console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
+      if (!options.quiet) console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
+    }
+  }
+
+  // After `bun install`, which prunes links it does not know about.
+  const link = linkHostPackages(targetDir);
+  if (link.error) {
+    if (!options.quiet) {
+      console.error(cliStyles.warning(`Warning: could not link the Gloomberb runtime (${link.error}).`));
+      console.error(cliStyles.muted("The plugin's \"gloomberb/*\" imports will not resolve."));
     }
   }
 
@@ -98,13 +125,13 @@ export async function installPlugin(ref: string) {
       const mod = await import(entryFile);
       const plugin = mod.default ?? mod.plugin;
       if (plugin?.id && plugin?.name) {
-        console.log(cliStyles.success(`Installed ${plugin.name} v${plugin.version || "0.0.0"}`));
+        say(cliStyles.success(`Installed ${plugin.name} v${plugin.version || "0.0.0"}`));
         return;
       }
     }
-    console.log(cliStyles.warning("Installed files, but no valid GloomPlugin export was found."));
+    say(cliStyles.warning("Installed files, but no valid GloomPlugin export was found."));
   } catch (err) {
-    console.log(cliStyles.warning(`Plugin validation failed: ${err}`));
+    say(cliStyles.warning(`Plugin validation failed: ${err}`));
   }
 }
 
@@ -141,8 +168,9 @@ export async function updatePlugins(name?: string) {
       execFileSync("git", ["pull", "--ff-only"], { cwd: targetDir, stdio: "inherit" });
       const pkgPath = join(targetDir, "package.json");
       if (existsSync(pkgPath)) {
-        execFileSync("bun", ["install"], { cwd: targetDir, stdio: "inherit" });
+        execFileSync("bun", ["install", "--production"], { cwd: targetDir, stdio: "inherit" });
       }
+      linkHostPackages(targetDir);
     } catch {
       console.error(cliStyles.danger(`Failed to update ${dir}.`));
     }