gloomberb 0.18.2 → 0.18.4

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

@@ -1,3 +1,5 @@
+import { readdir, rm } from "fs/promises";
+import { basename, dirname, join } from "path";
 import type Electrobun from "electrobun/bun";
 import type { UpdateStatusEntry } from "electrobun/bun";
 import type { UpdateChannel } from "../../../../types/config";
@@ -15,6 +17,20 @@ import {
   type GitHubReleaseListing,
 } from "../../../../updater/github-releases";
 import { stagedUpdateFitsChannel } from "../../../../updater/channel";
+import {
+  classifyUpdateError,
+  httpStatusFailureCode,
+  type UpdateFailure,
+  type UpdateFailureCode,
+} from "../../../../updater/failure";
+import {
+  forgetStagedUpdate,
+  noteUpdateApplying,
+  noteUpdateStaged,
+  reportUpdateFailure,
+  type UpdateInstallKind,
+} from "../../../../telemetry/update-failures";
+import { logFailure } from "../../../../utils/log-failure";
 import { compareSemver, isPrereleaseVersion } from "../../../../utils/semver";
 import { VERSION } from "../../../../version";
 
@@ -27,7 +43,14 @@ type ElectrobunUpdater = typeof Electrobun.Updater;
  */
 export type ElectrobunUpdaterApi = Pick<
   ElectrobunUpdater,
-  "checkForUpdate" | "downloadUpdate" | "applyUpdate" | "updateInfo" | "clearStatusHistory" | "onStatusChange" | "setUpdateSource"
+  | "checkForUpdate"
+  | "downloadUpdate"
+  | "applyUpdate"
+  | "updateInfo"
+  | "clearStatusHistory"
+  | "getStatusHistory"
+  | "onStatusChange"
+  | "setUpdateSource"
 > & {
   localInfo: Pick<ElectrobunUpdater["localInfo"], "channel" | "baseUrl">;
 };
@@ -37,12 +60,111 @@ type ListReleases = () => Promise<GitHubReleaseListing[]>;
 
 const NIGHTLY_RELEASE_WINDOW = 30;
 
+/** A step that failed for a reason known where it was thrown. */
+class DesktopUpdateError extends Error {
+  constructor(message: string, readonly code: UpdateFailureCode) {
+    super(message);
+    this.name = "DesktopUpdateError";
+  }
+}
+
+/** `<app>.previous` and `<app>.previous-<suffix>`: what an install moves the old app to. */
+function isUpdateAside(entry: string, appName: string): boolean {
+  if (!entry.startsWith(`${appName}.previous`)) return false;
+  const rest = entry.slice(appName.length + ".previous".length);
+  return rest === "" || /^-[0-9a-z]+(?:-\d+)?$/.test(rest);
+}
+
+/**
+ * Removes the copies of the app an install moved aside and could not remove
+ * then (the Electrobun patch's `replaceAppBundle`), from beside the app this
+ * process runs from: starting from it means the install that left them worked.
+ * macOS keeps the app in its bundle, Linux in `<app data>/app` (`bin/bun`
+ * inside it); Windows installs through its own script and leaves none.
+ * Resolves to the paths it removed.
+ */
+export async function removeUpdateAsides(
+  execPath: string = process.execPath,
+  platform: string = process.platform,
+): Promise<string[]> {
+  const app = platform === "darwin"
+    ? /^(.*?\.app)\/Contents\/MacOS\/[^/]+$/.exec(execPath)?.[1]
+    : platform === "linux" && basename(dirname(execPath)) === "bin" ? dirname(dirname(execPath)) : undefined;
+  if (!app) return [];
+  const folder = dirname(app);
+  const removed: string[] = [];
+  for (const entry of await readdir(folder).catch(() => [] as string[])) {
+    if (!isUpdateAside(entry, basename(app))) continue;
+    const path = join(folder, entry);
+    // One that still cannot be removed (another user's) is tried again at the next start.
+    const done = await rm(path, { recursive: true, force: true }).then(() => true, logFailure("desktop-update", "Could not remove an old copy of the app", false));
+    if (done) removed.push(path);
+  }
+  return removed;
+}
+
+/**
+ * Where the running app sits, for update failure reports and for what an
+ * install that cannot replace it means. Electrobun replaces the macOS bundle
+ * the app runs from; on Windows and Linux it always installs into its own
+ * folder under the user's app data.
+ */
+export function detectDesktopInstallKind(
+  execPath: string = process.execPath,
+  platform: string = process.platform,
+  homeDir: string = process.env.HOME ?? "",
+): UpdateInstallKind {
+  if (platform !== "darwin") return platform === "win32" || platform === "linux" ? "desktop-app-data" : "unknown";
+  const bundle = /^(.*?\.app)\/Contents\//.exec(execPath)?.[1];
+  if (!bundle) return "unknown";
+  if (bundle.includes("/AppTranslocation/")) return "desktop-translocated";
+  if (bundle.startsWith("/Volumes/")) return "desktop-volume";
+  if (bundle.startsWith("/Applications/") || (homeDir && bundle.startsWith(`${homeDir}/Applications/`))) return "desktop-applications";
+  return "desktop-elsewhere";
+}
+
+/**
+ * On macOS a bundle that cannot be replaced where it runs (a disk image, the
+ * read-only copy App Translocation runs, another volume) is fixed by moving
+ * the app to Applications, which is what the header then says. Anywhere else
+ * a move across disks keeps its own reason: from Applications, moving the app
+ * again would not help.
+ */
+function installFailureCode(code: UpdateFailureCode, installKind: UpdateInstallKind): UpdateFailureCode {
+  const movable = installKind === "desktop-translocated" || installKind === "desktop-volume";
+  if (movable && (code === "permission_denied" || code === "read_only" || code === "wrong_location" || code === "cross_device")) return "wrong_location";
+  return code;
+}
+
+/**
+ * Why Electrobun's check failed. It returns one message for every failure, so
+ * the status it emitted just before says whether the server answered (with
+ * which status) or could not be reached.
+ */
+function checkFailureCode(error: string, history: UpdateStatusEntry[]): UpdateFailureCode {
+  const last = history.at(-1);
+  const status = last?.status === "error" ? /HTTP (\d{3})/.exec(last.message)?.[1] : undefined;
+  if (status) return httpStatusFailureCode(Number(status));
+  if (/Invalid update\.json/i.test(error)) return "bad_response";
+  const code = classifyUpdateError(error);
+  // "Failed to fetch update info" with no status before it: the request itself threw.
+  return code === "unknown" ? "offline" : code;
+}
+
+/** Why a download that Electrobun returned from did not leave an update ready. */
+function downloadFailureCode(error: string, lastErrorStatus: UpdateStatusEntry | null): UpdateFailure {
+  if (/zstd/i.test(error)) return { phase: "verify", code: "corrupt" };
+  if (lastErrorStatus?.message.startsWith("Failed to download:")) return { phase: "download", code: "http_error" };
+  const code = classifyUpdateError(error);
+  return { phase: "download", code: code === "unknown" ? "interrupted" : code };
+}
+
 async function listGitHubReleases(): Promise<GitHubReleaseListing[]> {
   const response = await fetch(`${GITHUB_RELEASES_API_URL}?per_page=${NIGHTLY_RELEASE_WINDOW}`, {
     headers: { Accept: "application/vnd.github+json" },
     signal: AbortSignal.timeout(10_000),
   });
-  if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
+  if (!response.ok) throw new DesktopUpdateError(`GitHub returned ${response.status}`, httpStatusFailureCode(response.status));
   const data: unknown = await response.json();
   if (!Array.isArray(data)) throw new Error("GitHub returned an unexpected releases payload");
   return data as GitHubReleaseListing[];
@@ -88,6 +210,12 @@ function hasDesktopManifest(release: GitHubReleaseListing): boolean {
   return release.assets?.some((asset) => asset.name === manifest) === true;
 }
 
+/**
+ * The progress an Electrobun status means. An `error` status is left to the
+ * caller: during a download Electrobun emits some it recovers from (a patch
+ * that does not apply falls back to the full download), so only the outcome
+ * says whether the download failed.
+ */
 function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null {
   const progress = entry.details?.progress;
   switch (entry.status) {
@@ -120,11 +248,6 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
     // once `updateInfo().updateReady` confirms it.
     case "complete":
       return { phase: "done", message: "Update installed, restarting..." };
-    case "error":
-      return {
-        phase: "error",
-        error: entry.details?.errorMessage || entry.message,
-      };
     default:
       return null;
   }
@@ -133,9 +256,12 @@ function mapDesktopUpdateStatus(entry: UpdateStatusEntry): UpdateProgress | null
 export function createElectrobunDesktopUpdater(
   updater: ElectrobunUpdaterApi,
   {
+    installKind = detectDesktopInstallKind(),
     listReleases = listGitHubReleases,
     runningVersion = VERSION,
   }: {
+    /** Where the app runs from, which an install that cannot replace it is blamed on. */
+    installKind?: UpdateInstallKind;
     listReleases?: ListReleases;
     /** The version of the installed app, which a download checks as. */
     runningVersion?: string;
@@ -152,6 +278,15 @@ export function createElectrobunDesktopUpdater(
   /** An apply is under way, or finished and the app is quitting. */
   let applyInProgress = false;
 
+  /** The error progress for a failed step, reported to error tracking on the way. */
+  function failed(failure: UpdateFailure, error: string, release?: { version?: string; channel?: UpdateChannel } | null): UpdateProgress {
+    reportUpdateFailure(failure, {
+      targetVersion: release?.version,
+      channel: release?.channel === "nightly" ? "nightly" : "stable",
+    });
+    return { phase: "error", error, failure };
+  }
+
   /**
    * Forgets a downloaded update `updateChannel` does not allow: a nightly
    * build staged before the switch back to stable. Electrobun's own ready
@@ -159,7 +294,10 @@ export function createElectrobunDesktopUpdater(
    * a restart cannot install it, and its files go with the next download.
    */
   function dropStagedMisfit(updateChannel: UpdateChannel): void {
-    if (readyRelease && !applyInProgress && !stagedUpdateFitsChannel(readyRelease, updateChannel)) readyRelease = null;
+    if (readyRelease && !applyInProgress && !stagedUpdateFitsChannel(readyRelease, updateChannel)) {
+      readyRelease = null;
+      forgetStagedUpdate();
+    }
   }
 
   async function releaseInfo(updateInfo: { version?: string; hash?: string }, currentVersion: string): Promise<ReleaseInfo> {
@@ -177,6 +315,13 @@ export function createElectrobunDesktopUpdater(
     };
   }
 
+  /** Electrobun's check, with the failure it ended in named. */
+  async function checkElectrobun(): Promise<Awaited<ReturnType<ElectrobunUpdaterApi["checkForUpdate"]>> | { error: string; code: UpdateFailureCode }> {
+    const info = await updater.checkForUpdate();
+    if (!info.error) return info;
+    return { error: info.error, code: checkFailureCode(info.error, updater.getStatusHistory()) };
+  }
+
   /**
    * Nightly: the highest version among the newest releases that has this
    * platform's desktop manifest, nightly or stable, fetched from that release's
@@ -192,8 +337,8 @@ export function createElectrobunDesktopUpdater(
     const baseUrl = githubReleaseDownloadBaseUrl(target.tag_name);
     updater.setUpdateSource({ channel: filesChannel, baseUrl });
 
-    const info = await updater.checkForUpdate();
-    if (info.error) return { kind: "error", error: info.error };
+    const info = await checkElectrobun();
+    if ("code" in info) throw new DesktopUpdateError(info.error, info.code);
     // The same build as the one installed.
     if (!info.updateAvailable) return { kind: "current" };
 
@@ -210,7 +355,11 @@ export function createElectrobunDesktopUpdater(
     };
   }
 
-  async function check(currentVersion: string, updateChannel: UpdateChannel = "stable"): Promise<UpdateCheckResult> {
+  /**
+   * The check, without reporting: a download runs it first and reports what
+   * went wrong itself.
+   */
+  async function checkQuietly(currentVersion: string, updateChannel: UpdateChannel): Promise<UpdateCheckResult> {
     dropStagedMisfit(updateChannel);
     // A downloaded update the channel still allows stays the answer until the
     // user restarts into it, and asking Electrobun again would discard its
@@ -229,9 +378,9 @@ export function createElectrobunDesktopUpdater(
 
       // Stable is the release version.json names, as it always was.
       updater.setUpdateSource(null);
-      const info = await updater.checkForUpdate();
-      if (info.error) {
-        return { kind: "error", error: info.error };
+      const info = await checkElectrobun();
+      if ("code" in info) {
+        return { kind: "error", error: info.error, failure: { phase: "check", code: info.code } };
       }
       if (!info.updateAvailable) {
         return { kind: "current" };
@@ -247,13 +396,21 @@ export function createElectrobunDesktopUpdater(
         release: await releaseInfo(info, currentVersion),
       };
     } catch (error) {
+      const code = error instanceof DesktopUpdateError ? error.code : classifyUpdateError(error);
       return {
         kind: "error",
         error: error instanceof Error ? error.message : "Desktop update check failed",
+        failure: { phase: "check", code },
       };
     }
   }
 
+  async function check(currentVersion: string, updateChannel: UpdateChannel = "stable"): Promise<UpdateCheckResult> {
+    const result = await checkQuietly(currentVersion, updateChannel);
+    if (result.kind === "error" && result.failure) reportUpdateFailure(result.failure, { channel: updateChannel });
+    return result;
+  }
+
   async function download(
     release: Pick<ReleaseInfo, "channel">,
     onProgress: (progress: UpdateProgress) => void,
@@ -277,17 +434,25 @@ export function createElectrobunDesktopUpdater(
     }
 
     downloadInProgress = true;
+    /** The last error Electrobun emitted on the way, which may or may not have ended the download. */
+    let lastErrorStatus: UpdateStatusEntry | null = null;
+    /** The release the download is for, once the check has found it. */
+    let target: ReleaseInfo | null = null;
     updater.clearStatusHistory();
     updater.onStatusChange((entry) => {
+      if (entry.status === "error") {
+        lastErrorStatus = entry;
+        return;
+      }
       const progress = mapDesktopUpdateStatus(entry);
       if (progress) onProgress(progress);
     });
 
     try {
       onProgress({ phase: "downloading", percent: 0 });
-      const result = await check(runningVersion, updateChannel);
+      const result = await checkQuietly(runningVersion, updateChannel);
       if (result.kind === "error") {
-        onProgress({ phase: "error", error: result.error });
+        onProgress(failed(result.failure ?? { phase: "check", code: "unknown" }, result.error, { channel: updateChannel }));
         return;
       }
       if (result.kind !== "available") {
@@ -297,27 +462,31 @@ export function createElectrobunDesktopUpdater(
         });
         return;
       }
+      target = result.release;
 
       await updater.downloadUpdate();
       const updateInfo = updater.updateInfo();
       if (updateInfo?.error) {
-        onProgress({ phase: "error", error: updateInfo.error });
+        onProgress(failed(downloadFailureCode(updateInfo.error, lastErrorStatus), updateInfo.error, result.release));
         return;
       }
       if (!updateInfo?.updateReady) {
-        onProgress({ phase: "error", error: "Desktop update did not finish downloading." });
+        onProgress(failed({ phase: "download", code: "interrupted" }, "Desktop update did not finish downloading.", result.release));
         return;
       }
 
       // Downloaded, not installed: applying relaunches the app, and that waits
       // for the user's explicit request (`apply`).
       readyRelease = result.release;
+      noteUpdateStaged(result.release.version, updateChannel);
       onProgress({ phase: "ready", canRestart: true });
     } catch (error) {
-      onProgress({
-        phase: "error",
-        error: error instanceof Error ? error.message : "Desktop update failed",
-      });
+      const code = classifyUpdateError(error);
+      onProgress(failed(
+        { phase: "download", code: code === "unknown" ? "interrupted" : code },
+        error instanceof Error ? error.message : "Desktop update failed",
+        { version: target?.version, channel: updateChannel },
+      ));
     } finally {
       downloadInProgress = false;
       updater.onStatusChange(null);
@@ -327,11 +496,13 @@ export function createElectrobunDesktopUpdater(
   async function apply(onProgress: (progress: UpdateProgress) => void): Promise<void> {
     if (applyInProgress || downloadInProgress) return;
     if (!readyRelease || !updater.updateInfo()?.updateReady) {
+      const missing = readyRelease;
       readyRelease = null;
-      onProgress({ phase: "error", error: "The downloaded update is no longer available." });
+      onProgress(failed({ phase: "apply", code: "staged_missing" }, "The downloaded update is no longer available.", missing));
       return;
     }
 
+    const target = readyRelease;
     applyInProgress = true;
     let relaunching = false;
     let reportedError = false;
@@ -339,7 +510,19 @@ export function createElectrobunDesktopUpdater(
       if (progress.phase === "error") reportedError = true;
       onProgress(progress);
     };
+    const installFailed = (error: unknown, message: string) => {
+      // Electrobun names the system error in its message ("Failed to replace app: EACCES: ...").
+      const code = installFailureCode(classifyUpdateError(error), installKind);
+      report(failed({ phase: relaunching ? "relaunch" : "apply", code }, message, target));
+    };
+    // Kept before Electrobun quits the app, so the next launch can tell whether it took.
+    noteUpdateApplying(target.version, target.channel === "nightly" ? "nightly" : "stable");
     updater.onStatusChange((entry) => {
+      if (entry.status === "error") {
+        const message = entry.details?.errorMessage || entry.message;
+        installFailed(message, message);
+        return;
+      }
       if (entry.status === "launching-new-version" || entry.status === "complete") relaunching = true;
       const progress = mapDesktopUpdateStatus(entry);
       if (progress) report(progress);
@@ -348,16 +531,13 @@ export function createElectrobunDesktopUpdater(
     try {
       report({ phase: "replacing" });
       await updater.applyUpdate();
-      // Electrobun returns without a status when it cannot install, for example
-      // when a newer release replaced the one that was downloaded.
+      // Electrobun returns without a status when it finds nothing to install:
+      // the downloaded files are gone, or hold no app.
       if (!relaunching && !reportedError) {
-        report({ phase: "error", error: "Desktop update could not be installed." });
+        report(failed({ phase: "apply", code: "staged_missing" }, "Desktop update could not be installed.", target));
       }
     } catch (error) {
-      report({
-        phase: "error",
-        error: error instanceof Error ? error.message : "Desktop update failed",
-      });
+      installFailed(error, error instanceof Error ? error.message : "Desktop update failed");
     } finally {
       updater.onStatusChange(null);
     }

package/src/renderers/electrobun/bun/external-plugins.ts

@@ -14,6 +14,7 @@ import {
   loadExternalPlugin,
 } from "../../../plugins/loader";
 import { createNodePluginManager } from "../../../plugins/manager-node";
+import { deactivatePluginForRemoval } from "../../../plugins/marketplace/deactivation";
 import { readPluginIcon } from "../../../plugins/plugin-icon";
 import type { PluginRegistry } from "../../../plugins/registry";
 import { desktopRendererCapabilityManifests } from "./desktop/initialization";
@@ -157,6 +158,33 @@ export async function collectExternalPluginBundles(): Promise<DesktopExternalPlu
   return bundles;
 }
 
+let prefetchedBundles: Promise<DesktopExternalPluginBundle[]> | null = null;
+
+/**
+ * Starts compiling every plugin for the view before it asks. The bundle cache
+ * above lives in memory, so the first window of a launch always compiles;
+ * started at launch, that runs while the view loads its own bundle.
+ */
+export function prefetchExternalPluginBundles(): void {
+  if (prefetchedBundles) return;
+  const bundles = collectExternalPluginBundles();
+  // The view's request reports a failure; this one only must not go unhandled.
+  bundles.catch(() => {
+    // Intentional ignore: the window that takes these bundles reports the failure.
+  });
+  prefetchedBundles = bundles;
+}
+
+/**
+ * The bundles for a window: the launch's prefetch once, then a new collection,
+ * which the mtime cache keeps cheap, so a later window sees plugins installed since.
+ */
+export function takeExternalPluginBundles(): Promise<DesktopExternalPluginBundle[]> {
+  const prefetched = prefetchedBundles;
+  prefetchedBundles = null;
+  return prefetched ?? collectExternalPluginBundles();
+}
+
 /** One plugin, compiled fresh, so the view can activate what was just installed or updated. */
 export function bundleExternalPluginDirectory(directory: string): Promise<DesktopExternalPluginBundle | null> {
   return bundlePluginDirectory(join(getPluginsDir(), directory), { fresh: true });
@@ -209,12 +237,6 @@ export function deactivateExternalPlugin(
   registry: PluginRegistry,
   pluginId: string,
 ): { capabilityManifests: ReturnType<typeof desktopRendererCapabilityManifests> } {
-  if (registry.allPlugins.has(pluginId)) {
-    try {
-      registry.unregister(pluginId);
-    } catch (error) {
-      log.error(`Deactivating ${pluginId} failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
+  deactivatePluginForRemoval(registry, pluginId);
   return { capabilityManifests: desktopRendererCapabilityManifests(registry.capabilities) };
 }

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

@@ -6,6 +6,7 @@ import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
 import { contextMenuSelectionMessage } from "./context-menu/click";
 import { applicationMenuCommand, createApplicationMenuGate } from "./application-menu/click";
 import { DesktopBackend } from "./desktop/backend";
+import { startDesktopBackend } from "./desktop/initialization";
 import {
   MAIN_WINDOW_MIN_SIZE,
   defaultMainWindowFrame,
@@ -13,6 +14,7 @@ import {
 } from "./window/frame";
 import { MAIN_WINDOW_RPC_KEY } from "./window/focus";
 import { createAppWindow } from "./window/create";
+import { desktopBootFramePath, desktopBootFramePreload, readDesktopBootFrame } from "./window/boot-frame";
 import { getWindowFrame } from "./window/events";
 import {
   fitWindowFrameToDisplays,
@@ -135,13 +137,21 @@ function scheduleRememberedWindow(): void {
 }
 
 const mainWindow = createAppWindow({
-  title: "Gloomberb",
+  title: "Gloom",
   frame: initialMainWindowFrame,
   rpc: mainRpc,
   minSize: MAIN_WINDOW_MIN_SIZE,
   onFrameChange: scheduleRememberedWindow,
+  // The layout the window last drew, which its page draws before its script
+  // has loaded (dom/boot-frame.ts).
+  preload: desktopBootFramePreload(readDesktopBootFrame(desktopBootFramePath())),
 });
 backend.mainWindow = mainWindow;
+// The window is loading its view; the services it will ask for start now
+// rather than when it asks. Its `init` reports a failure, and retries.
+startDesktopBackend(backend).catch((error) => {
+  console.error("[desktop] startup failed", error instanceof Error ? error.stack ?? error.message : String(error));
+});
 if (rememberedWindow?.fullscreen) {
   try { mainWindow.setFullScreen(true); } catch { /* the framed window is still the one they sized */ }
 } else if (rememberedWindow?.maximized) {

package/src/renderers/electrobun/bun/window/boot-frame.ts

@@ -0,0 +1,67 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { getGloomberbDirs } from "../../../../data/config/home";
+import { isBootFrame, type BootFrame } from "../../../dom/boot-frame-page";
+import { DESKTOP_BOOT_FRAME_GLOBAL } from "../../shared/boot-frame";
+
+/**
+ * The main window's launch frame lives beside the remembered window frame:
+ * read before the config, and drawn for this machine's screen.
+ */
+const FILE_NAME = "desktop-boot-frame.json";
+
+export function desktopBootFramePath(env: NodeJS.ProcessEnv = process.env): string {
+  return join(dirname(getGloomberbDirs(env).configFile), FILE_NAME);
+}
+
+export function readDesktopBootFrame(path: string): BootFrame | null {
+  try {
+    const frame: unknown = JSON.parse(readFileSync(path, "utf8"));
+    return isBootFrame(frame) ? frame : null;
+  } catch {
+    return null;
+  }
+}
+
+interface BootFrameSender {
+  /** The main window's view; a popped-out pane's draws no frame. */
+  mainWindow: boolean;
+  /** A session is up. After all data was reset there is none until the next launch. */
+  session: boolean;
+}
+
+/**
+ * Keeps the frame a view sent, if it may: from the main window, while a
+ * session is up, and of the right shape and size. A closing window's last
+ * frame, sent after a reset, is dropped. Returns whether it was written.
+ */
+export function saveDesktopBootFrame(path: string, frame: unknown, sender: BootFrameSender): boolean {
+  if (!sender.mainWindow || !sender.session || !isBootFrame(frame)) return false;
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, JSON.stringify(frame));
+  renameSync(temporary, path);
+  return true;
+}
+
+/**
+ * Forgets the frame, with the rest of the data on a reset. It sits beside
+ * the config, which a custom data folder is not, so removing the data folder
+ * alone could leave it behind.
+ */
+export function removeDesktopBootFrame(path: string): void {
+  rmSync(path, { force: true });
+}
+
+/**
+ * The main window's preload: the frame its page draws before its script
+ * loads, or null for the bare shell. Set either way, which is how the page
+ * tells the main window from a popped-out pane's.
+ */
+export function desktopBootFramePreload(frame: BootFrame | null): string {
+  const json = JSON.stringify(frame)
+    .replace(/</g, "\\u003c")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+  return `window.${DESKTOP_BOOT_FRAME_GLOBAL} = ${json};`;
+}

package/src/renderers/electrobun/bun/window/create.ts

@@ -51,17 +51,20 @@ interface AppWindowOptions {
   minSize: WindowMinimumSize;
   /** Runs after each move or resize has been applied to the cached frame. */
   onFrameChange?: () => void;
+  /** Script run in the page before its own. */
+  preload?: string;
 }
 
 /**
  * Opens a window on the app view with this platform's chrome and icon, keeps
  * its cached frame current as it moves, and holds it to `minSize` on resize.
  */
-export function createAppWindow({ title, frame, rpc, minSize, onFrameChange }: AppWindowOptions): BrowserWindow {
+export function createAppWindow({ title, frame, rpc, minSize, onFrameChange, preload }: AppWindowOptions): BrowserWindow {
   const window = new BrowserWindow({
     title,
     frame,
     url: "views://mainview/index.html",
+    ...(preload ? { preload } : {}),
     renderer: desktopWindowRenderer(),
     rpc,
     styleMask: desktopWindowStyleMask(),

package/src/renderers/electrobun/shared/boot-frame.ts

@@ -0,0 +1,7 @@
+/**
+ * Where the main window's page finds the launch frame (dom/boot-frame.ts):
+ * the Bun process sets it in the window's preload, before the page's own
+ * scripts run. A window it is not set in, one holding a popped-out pane,
+ * draws no frame.
+ */
+export const DESKTOP_BOOT_FRAME_GLOBAL = "__gloomDesktopBootFrame";

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

@@ -10,6 +10,7 @@ import type { CapabilityManifest } from "../../../capabilities";
 import type { PluginOperationResult, PluginPin } from "../../../plugins/marketplace/store";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 import type { HttpProxyRequestEnvelope, HttpProxyResponseEnvelope } from "../../../utils/http-proxy-response";
+import type { BootFrame } from "../../dom/boot-frame-page";
 
 export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
 
@@ -27,6 +28,8 @@ export interface ElectrobunBackendInit {
   hostName?: string;
   windowKind: "main" | "detached";
   paneId?: string;
+  /** What the launch's plugin seed could not install, for the main window to say once. */
+  pluginSeedNotice?: { body: string; type: "error" | "info" };
   /** What the view needs to send crash reports and usage counts the same way the Bun process would. */
   telemetry: ElectrobunTelemetryInit;
 }
@@ -203,7 +206,7 @@ interface DesktopBackendRequestMap {
   "host.exit": { request: null; response: null };
   "host.windowControl": { request: { action: DesktopWindowControlAction }; response: null };
   "host.windowFullscreen": { request: null; response: boolean };
-  "host.openExternal": { request: { url: string }; response: null };
+  "host.openExternal": { request: { url: string }; response: boolean };
   "host.copyText": { request: { text: string }; response: null };
   "host.focusWindow": { request: null; response: null };
   "host.copyPngImage": { request: { pngBase64: string }; response: null };
@@ -217,6 +220,8 @@ interface DesktopBackendRequestMap {
     response: null;
   };
   "host.showContextMenu": { request: { menu: DesktopContextMenuItem[] }; response: boolean };
+  /** The layout the main window draws at the next launch before its script loads (dom/boot-frame.ts). Only the main window's is kept. */
+  "host.saveBootFrame": { request: { frame: BootFrame }; response: null };
   /** The unread count for the Dock icon badge: `""` (none), `"1"` to `"99"` or `"99+"`. Only the main window's is applied. */
   "host.setAppBadge": { request: { label: string }; response: null };
   /** `channel` absent (an older view) means stable. */

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

@@ -185,7 +185,7 @@ async function restoreShotCloudSession(): Promise<void> {
 
 /**
  * Runs an asset-data request in the Bun process so the page sees exactly what
- * `gloomberb fn` sees. The page can only reach the cloud API on its own, and
+ * `gloom fn` sees. The page can only reach the cloud API on its own, and
  * the cloud is one source among several: analyst rating price targets and part
  * of the corporate action history come from providers the router merges in.
  */

package/src/renderers/electrobun/view/config-host.ts

@@ -1,4 +1,5 @@
 import { setConfigStoreHost, type ConfigStoreHost } from "../../../data/config/store";
+import { stopBootFrameRecorders } from "../../dom/boot-frame";
 import type { AppConfig } from "../../../types/config";
 import { backendRequest, getElectrobunBackendInitSnapshot } from "./backend-rpc";
 
@@ -20,6 +21,8 @@ const electrobunConfigStoreHost: ConfigStoreHost = {
     return config;
   },
   async resetAllData(dataDir: string) {
+    // Before the reset, or the frame saved as the window closes would bring the old layout back.
+    stopBootFrameRecorders();
     await backendRequest("config.resetAllData", { dataDir });
   },
   async exportConfig(config: AppConfig, destPath: string) {