gloomberb 0.9.0 → 0.9.1

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

@@ -0,0 +1,5 @@
+type DesktopTitleBarStyle = "default" | "hidden" | "hiddenInset";
+
+export function desktopTitleBarStyle(): DesktopTitleBarStyle {
+  return process.platform === "darwin" ? "hiddenInset" : "hidden";
+}

package/src/renderers/electrobun/bun/desktop/windows-icons.ts

@@ -0,0 +1,123 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { dlopen, FFIType, ptr, type Pointer } from "bun:ffi";
+
+const WM_SETICON = 0x0080;
+const ICON_SMALL = 0;
+const ICON_BIG = 1;
+const IMAGE_ICON = 1;
+const LR_LOADFROMFILE = 0x0010;
+const LR_DEFAULTSIZE = 0x0040;
+const GCLP_HICON = -14;
+const GCLP_HICONSM = -34;
+const MAX_ATTEMPTS = 20;
+const RETRY_DELAY_MS = 100;
+
+type Win32 = ReturnType<typeof loadWin32>;
+
+let cachedWin32: Win32 | null | undefined;
+let smallIconHandle: Pointer | null = null;
+let bigIconHandle: Pointer | null = null;
+
+function loadWin32() {
+  return dlopen("user32.dll", {
+    FindWindowW: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    GetWindowThreadProcessId: {
+      args: [FFIType.ptr, FFIType.ptr],
+      returns: FFIType.u32,
+    },
+    LoadImageW: {
+      args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.int, FFIType.int, FFIType.u32],
+      returns: FFIType.ptr,
+    },
+    SendMessageW: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    SetClassLongPtrW: {
+      args: [FFIType.ptr, FFIType.int, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+  });
+}
+
+function win32OrNull(): Win32 | null {
+  if (process.platform !== "win32") return null;
+  if (cachedWin32 !== undefined) return cachedWin32;
+
+  try {
+    cachedWin32 = loadWin32();
+  } catch {
+    cachedWin32 = null;
+  }
+  return cachedWin32;
+}
+
+function wideString(value: string): Buffer {
+  return Buffer.from(`${value}\0`, "utf16le");
+}
+
+function readWindowProcessId(win32: Win32, windowHandle: Pointer): number {
+  const processIdBuffer = new Uint32Array(1);
+  win32.symbols.GetWindowThreadProcessId(windowHandle, ptr(processIdBuffer));
+  return processIdBuffer[0] ?? 0;
+}
+
+function findCurrentProcessWindow(win32: Win32, title: string): Pointer | null {
+  const titleBuffer = wideString(title);
+  const windowHandle = win32.symbols.FindWindowW(null, ptr(titleBuffer));
+  if (!windowHandle) return null;
+  if (readWindowProcessId(win32, windowHandle) !== process.pid) return null;
+  return windowHandle;
+}
+
+function loadIconHandle(win32: Win32, iconPath: string, size: number): Pointer | null {
+  const iconPathBuffer = wideString(iconPath);
+  const iconHandle = win32.symbols.LoadImageW(
+    null,
+    ptr(iconPathBuffer),
+    IMAGE_ICON,
+    size,
+    size,
+    LR_LOADFROMFILE | LR_DEFAULTSIZE,
+  );
+
+  return iconHandle || null;
+}
+
+function ensureIconHandles(win32: Win32): boolean {
+  if (smallIconHandle && bigIconHandle) return true;
+
+  const iconPath = resolve("../Resources/app.ico");
+  if (!existsSync(iconPath)) return false;
+
+  smallIconHandle = smallIconHandle ?? loadIconHandle(win32, iconPath, 16);
+  bigIconHandle = bigIconHandle ?? loadIconHandle(win32, iconPath, 32);
+
+  return Boolean(smallIconHandle && bigIconHandle);
+}
+
+function setWindowIcon(win32: Win32, windowHandle: Pointer): boolean {
+  if (!ensureIconHandles(win32) || !smallIconHandle || !bigIconHandle) return false;
+
+  win32.symbols.SendMessageW(windowHandle, WM_SETICON, ICON_SMALL, smallIconHandle);
+  win32.symbols.SendMessageW(windowHandle, WM_SETICON, ICON_BIG, bigIconHandle);
+  win32.symbols.SetClassLongPtrW(windowHandle, GCLP_HICONSM, smallIconHandle);
+  win32.symbols.SetClassLongPtrW(windowHandle, GCLP_HICON, bigIconHandle);
+  return true;
+}
+
+export function applyWindowsWindowIcon(title: string, attempt = 1): void {
+  const win32 = win32OrNull();
+  if (!win32) return;
+
+  const windowHandle = findCurrentProcessWindow(win32, title);
+  if (windowHandle && setWindowIcon(win32, windowHandle)) return;
+
+  if (attempt < MAX_ATTEMPTS) {
+    setTimeout(() => applyWindowsWindowIcon(title, attempt + 1), RETRY_DELAY_MS);
+  }
+}

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

@@ -16,7 +16,7 @@ import { ELECTROBUN_CONTEXT_MENU_ACTION, type DesktopRestartMessage, type Electr
 import { decodeRpcValue, encodeRpcValue } from "../view/rpc-codec";
 import { contextMenuSelectionMessage } from "./context-menu/click";
 import type { DesktopWorkspace } from "./desktop/workspace";
-import { buildApplicationMenu } from "./application-menu";
+import { buildDesktopApplicationMenu } from "./application-menu";
 import { applicationMenuCommand } from "./application-menu/click";
 import { registerElectrobunCoreCapabilities } from "./core-capabilities";
 import { setNativeIbkrGatewayModuleLoader } from "../../../plugins/ibkr/gateway/service";
@@ -25,8 +25,8 @@ import {
 } from "./desktop/update";
 import { DesktopCapabilityBridge } from "./desktop/capability-bridge";
 import {
-  DEFAULT_WINDOW_FRAME,
   MAIN_WINDOW_MIN_SIZE,
+  defaultMainWindowFrame,
   normalizeWindowFrameWithMinimum,
 } from "./window/frame";
 import { MAIN_WINDOW_RPC_KEY } from "./window/focus";
@@ -47,6 +47,9 @@ import { handleDesktopHostRequest } from "./desktop/host-requests";
 import { handleDesktopWorkspaceRequest } from "./desktop/workspace/requests";
 import { handleDesktopBackendRequest } from "./desktop/backend-requests";
 import { initializeDesktopBackend } from "./desktop/initialization";
+import { applyWindowsWindowIcon } from "./desktop/windows-icons";
+import { desktopTitleBarStyle } from "./desktop/window-style";
+import { applyDesktopWindowControl, type DesktopWindowControlAction } from "./desktop/window-controls";
 
 type DesktopRpc = ReturnType<typeof BrowserView.defineRPC<ElectrobunDesktopRpcSchema>>;
 
@@ -273,6 +276,18 @@ function closeAllDetachedWindows(): void {
   detachedWindowManager.closeAll();
 }
 
+function controlWindowForRpcKey(windowKey: string | undefined, action: DesktopWindowControlAction): boolean {
+  const targetWindow = windowKey === MAIN_WINDOW_RPC_KEY
+    ? mainWindow
+    : detachedWindowManager.getWindowForRpcKey(windowKey);
+  if (!targetWindow) return false;
+  if (action !== "close") {
+    detachedWindowManager.suppressAutoDockForRpcKey(windowKey);
+  }
+  applyDesktopWindowControl(targetWindow, action);
+  return true;
+}
+
 async function initialize(
   rpc: DesktopRpc,
   payload: Record<string, unknown>,
@@ -343,6 +358,7 @@ async function handleBackendRequest(
       restartDesktopApp,
       rpc,
       teardownServices,
+      controlWindowForRpcKey,
       trackContextMenuRequest: (requestId, targetRpc) => {
         contextMenuRequestRpcs.clear();
         contextMenuRequestRpcs.set(requestId, targetRpc);
@@ -383,7 +399,7 @@ async function handleBackendRequest(
 }
 
 function installApplicationMenu() {
-  ApplicationMenu.setApplicationMenu(buildApplicationMenu());
+  ApplicationMenu.setApplicationMenu(buildDesktopApplicationMenu());
 }
 
 function createWindowRpc(key: string): DesktopRpc {
@@ -432,18 +448,24 @@ ApplicationMenu.on("application-menu-clicked", (event: unknown) => {
 installApplicationMenu();
 
 const mainRpc = createWindowRpc(MAIN_WINDOW_RPC_KEY);
+const initialMainWindowFrame = normalizeWindowFrameWithMinimum(
+  defaultMainWindowFrame(),
+  defaultMainWindowFrame(),
+  MAIN_WINDOW_MIN_SIZE,
+);
 
 mainWindow = new BrowserWindow({
   title: "Gloomberb",
-  frame: normalizeWindowFrameWithMinimum(DEFAULT_WINDOW_FRAME, DEFAULT_WINDOW_FRAME, MAIN_WINDOW_MIN_SIZE),
+  frame: initialMainWindowFrame,
   url: "views://mainview/index.html",
   renderer: "native",
   rpc: mainRpc,
-  titleBarStyle: "hiddenInset",
+  titleBarStyle: desktopTitleBarStyle(),
   navigationRules: JSON.stringify(["views://*"]),
   sandbox: false,
 });
-updateWindowFrameCache(mainWindow, DEFAULT_WINDOW_FRAME, MAIN_WINDOW_MIN_SIZE);
+applyWindowsWindowIcon("Gloomberb");
+updateWindowFrameCache(mainWindow, initialMainWindowFrame, MAIN_WINDOW_MIN_SIZE);
 detachedWindowManager.focusWindowForRpcKey(MAIN_WINDOW_RPC_KEY);
 (mainWindow as any).on?.("move", (event: WindowMoveEvent) => {
   applyWindowMoveEvent(mainWindow, event);

package/src/renderers/electrobun/bun/window/frame.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
   DEFAULT_WINDOW_FRAME,
+  DEFAULT_WINDOWS_WINDOW_FRAME,
   MAIN_WINDOW_MIN_SIZE,
   constrainWindowFrame,
+  defaultMainWindowFrame,
   normalizeWindowFrameWithMinimum,
 } from "./frame";
 
@@ -37,4 +39,9 @@ describe("electrobun window frames", () => {
   test("uses the default frame when no frame data is available", () => {
     expect(normalizeWindowFrameWithMinimum(null)).toEqual(DEFAULT_WINDOW_FRAME);
   });
+
+  test("uses a compact default main window frame on Windows", () => {
+    expect(defaultMainWindowFrame("win32")).toEqual(DEFAULT_WINDOWS_WINDOW_FRAME);
+    expect(defaultMainWindowFrame("darwin")).toEqual(DEFAULT_WINDOW_FRAME);
+  });
 });

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

@@ -11,11 +11,16 @@ export interface WindowMinimumSize {
 }
 
 export const DEFAULT_WINDOW_FRAME: WindowFrame = { x: 64, y: 48, width: 1440, height: 920 };
+export const DEFAULT_WINDOWS_WINDOW_FRAME: WindowFrame = { x: 32, y: 32, width: 960, height: 680 };
 // Emergency fallback until Electrobun exposes stable native minimum-size handling:
 // https://github.com/blackboardsh/electrobun/issues/188
 export const MAIN_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 640, height: 400 };
 export const DETACHED_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 360, height: 240 };
 
+export function defaultMainWindowFrame(platform = process.platform): WindowFrame {
+  return platform === "win32" ? DEFAULT_WINDOWS_WINDOW_FRAME : DEFAULT_WINDOW_FRAME;
+}
+
 export function normalizeWindowFrame(
   frame: Partial<WindowFrame> | null | undefined,
   fallback: WindowFrame = DEFAULT_WINDOW_FRAME,

package/src/renderers/electrobun/view/build-assets.ts

@@ -108,10 +108,11 @@ ${bootstrapScript}
 }
 
 function resolveAlias(args: { path: string; importer?: string }, aliasRules: AliasRule[]) {
+  const importer = args.importer?.replaceAll("\\", "/");
   for (const rule of aliasRules) {
     const target = rule.length === 2
       ? args.path.endsWith(rule[0]) && rule[1]
-      : args.path === rule[0] && args.importer?.endsWith(rule[1]) && rule[2];
+      : args.path === rule[0] && importer?.endsWith(rule[1]) && rule[2];
     if (target) return { path: electrobunViewPath(target) };
   }
 }

package/src/renderers/electrobun/view/host/text.tsx

@@ -8,9 +8,20 @@ import {
   type TextProps,
 } from "../../../../ui/host";
 import { renderAsciiText } from "../../../../ui/ascii-font";
+import { WEB_CELL_WIDTH } from "../input-host";
 import { hasDirectMouseHandler, mouseHandlers } from "./mouse";
 import { cleanDomProps, commonStyle, textStyle } from "./style";
 
+const WEB_GLOOMBERB_WORDMARK = [
+  "  ____ _                       _               _     ",
+  " / ___| | ___   ___  _ __ ___ | |__   ___ _ __| |__  ",
+  "| |  _| |/ _ \\ / _ \\| '_ ` _ \\| '_ \\ / _ \\ '__| '_ \\ ",
+  "| |_| | | (_) | (_) | | | | | | |_) |  __/ |  | |_) |",
+  " \\____|_|\\___/ \\___/|_| |_| |_|_.__/ \\___|_|  |_.__/ ",
+];
+
+const WEB_WORDMARK_CHAR_WIDTH_PX = Math.max(10, WEB_CELL_WIDTH);
+
 function isStyledTextContent(value: unknown): value is { chunks: StyledTextChunk[] } {
   return value instanceof StyledText
     || (!!value && typeof value === "object" && Array.isArray((value as { chunks?: unknown }).chunks));
@@ -91,31 +102,40 @@ export function WebAsciiText({
   selectable = false,
   ...props
 }: AsciiTextProps) {
-  const lines = renderAsciiText(text, font);
+  const isWordmark = font === "wordmark";
+  const lines = isWordmark && text.trim().toLowerCase() === "gloomberb"
+    ? WEB_GLOOMBERB_WORDMARK
+    : renderAsciiText(text, font);
   const resolvedColor = color ?? fg;
   const resolvedBackground = bg ?? backgroundColor;
+  const lineHeightPx = isWordmark ? 16 : 12;
+  const wordmarkWidthPx = isWordmark
+    ? Math.max(...lines.map((line) => line.length)) * WEB_WORDMARK_CHAR_WIDTH_PX
+    : undefined;
   return (
     <div
       {...cleanDomProps(props)}
       data-gloom-role={(props["data-gloom-role"] as string | undefined) ?? "ascii-text"}
       style={{
         ...commonStyle({ ...props, fg: resolvedColor, bg: resolvedBackground }),
-        display: "flex",
-        flexDirection: "column",
+        display: "block",
         flexShrink: 0,
+        ...(wordmarkWidthPx != null && props.width == null
+          ? { width: `${wordmarkWidthPx}px`, minWidth: `${wordmarkWidthPx}px` }
+          : {}),
         color: resolvedColor,
         backgroundColor: resolvedBackground,
-        lineHeight: "12px",
+        fontFamily: isWordmark ? "\"Cascadia Mono\", Consolas, \"Courier New\", monospace" : undefined,
+        fontSize: isWordmark ? "16px" : undefined,
+        fontVariantLigatures: "none",
+        lineHeight: `${lineHeightPx}px`,
         whiteSpace: "pre",
+        letterSpacing: 0,
         userSelect: selectable ? "text" : "none",
         ...(props.style as CSSProperties | undefined),
       }}
     >
-      {lines.map((line, index) => (
-        <span key={index} style={{ display: "block", height: "12px", lineHeight: "12px" }}>
-          {line}
-        </span>
-      ))}
+      {lines.join("\n")}
     </div>
   );
 }

package/src/renderers/electrobun/view/styles.css

@@ -58,6 +58,26 @@ button, [data-gloom-interactive="true"] { cursor: pointer; }
   -webkit-app-region: no-drag;
   app-region: no-drag;
 }
+[data-gloom-role="window-controls"] {
+  height: 100%;
+  color: var(--gloom-header-text, #f2f2f2);
+}
+[data-gloom-role="window-control"] {
+  color: color-mix(in srgb, var(--gloom-header-text, #f2f2f2) 86%, transparent);
+  transition: background-color 90ms linear, color 90ms linear;
+}
+[data-gloom-role="window-control"] svg {
+  display: block;
+  pointer-events: none;
+}
+[data-gloom-role="window-control"]:hover {
+  background: color-mix(in srgb, var(--gloom-header-text, #f2f2f2) 13%, transparent);
+  color: var(--gloom-header-text, #f2f2f2);
+}
+[data-gloom-role="window-control"][data-window-control-action="close"]:hover {
+  background: #c42b1c;
+  color: #ffffff;
+}
 [data-gloom-role="pane-window"][data-floating="true"] {
   border: 0;
   border-radius: 6px;

package/src/renderers/electrobun/view/ui-host.tsx

@@ -27,6 +27,16 @@ import { cleanDomProps, commonStyle } from "./host/style";
 import { WebAsciiText, WebSpan, WebStrong, WebText, WebUnderline } from "./host/text";
 import { WebTabs } from "./host/tabs";
 
+function currentDesktopPlatform(): string {
+  const navigatorWithUserAgentData = navigator as Navigator & {
+    userAgentData?: { platform?: string };
+  };
+  return navigatorWithUserAgentData.userAgentData?.platform ?? navigator.platform ?? "";
+}
+
+const DESKTOP_PLATFORM = currentDesktopPlatform();
+const USES_WINDOWS_CONTROLS = /win/i.test(DESKTOP_PLATFORM);
+
 export const webUiHost: UiHost = {
   kind: "desktop-web",
   capabilities: {
@@ -39,6 +49,7 @@ export const webUiHost: UiHost = {
     pixelRatio: Math.min(window.devicePixelRatio || 1, 2),
     canvasCharts: true,
     nativeContextMenu: NATIVE_CONTEXT_MENU_SUPPORTED,
+    windowControls: USES_WINDOWS_CONTROLS ? "windows" : undefined,
   },
   Box: WebBox,
   Text: WebText,
@@ -115,6 +126,9 @@ export const webRendererHost: RendererHost = {
   startWindowDrag() {
     startElectrobunWindowDrag();
   },
+  async controlWindow(action) {
+    await backendRequest("host.windowControl", { action });
+  },
   async openExternal(url) {
     await backendRequest("host.openExternal", { url });
   },

package/src/ui/host.tsx

@@ -260,6 +260,7 @@ export interface UiHost {
     canvasCharts?: boolean;
     nativeCharts?: boolean;
     nativeContextMenu?: boolean;
+    windowControls?: "windows";
   };
   Box: ComponentType<BoxProps>;
   Text: ComponentType<TextProps>;
@@ -289,6 +290,7 @@ export interface UiHost {
 export interface RendererHost {
   requestExit(): void;
   startWindowDrag?(): Promise<void> | void;
+  controlWindow?(action: "minimize" | "toggle-maximize" | "close"): Promise<void> | void;
   openExternal(url: string): Promise<void>;
   copyText(text: string): Promise<void>;
   copyPngImage?(pngBase64: string): Promise<void>;

package/src/updater.test.ts

@@ -8,6 +8,7 @@ import {
   checkForUpdate,
   checkForUpdateDetailed,
   detectUpdateAction,
+  getAssetBaseNameForRuntime,
   performUpdate,
   resolveSelfUpdateTargetPath,
   setUpdateHost,
@@ -23,11 +24,21 @@ afterEach(() => {
 });
 
 function expectedAssetName(compressed = false): string {
-  const os = process.platform === "darwin" ? "darwin" : "linux";
+  const os = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
   const arch = os === "darwin" || process.arch === "arm64" ? "arm64" : "x64";
-  return compressed ? `gloomberb-${os}-${arch}.gz` : `gloomberb-${os}-${arch}`;
+  const extension = os === "windows" ? ".exe" : "";
+  return compressed ? `gloomberb-${os}-${arch}${extension}.gz` : `gloomberb-${os}-${arch}${extension}`;
 }
 
+describe("getAssetBaseNameForRuntime", () => {
+  test("uses the Windows executable release asset name on win32", () => {
+    expect(getAssetBaseNameForRuntime({
+      platform: "win32",
+      arch: "x64",
+    })).toBe("gloomberb-windows-x64.exe");
+  });
+});
+
 describe("detectUpdateAction", () => {
   test("uses self-update for standalone binaries", () => {
     expect(detectUpdateAction(
@@ -46,6 +57,16 @@ describe("detectUpdateAction", () => {
     });
   });
 
+  test("uses manual bun updates for Windows bun-managed installs", () => {
+    expect(detectUpdateAction(
+      "C:\\Program Files\\Bun\\bun.exe",
+      ["C:\\Program Files\\Bun\\bun.exe", "C:\\Users\\vince\\.bun\\install\\global\\node_modules\\gloomberb\\bin\\gloomberb"],
+    )).toEqual({
+      kind: "manual",
+      command: "bun install -g gloomberb@latest",
+    });
+  });
+
   test("uses manual npm updates for node-managed installs", () => {
     expect(detectUpdateAction(
       "/opt/homebrew/bin/node",
@@ -56,6 +77,13 @@ describe("detectUpdateAction", () => {
     });
   });
 
+  test("does not offer self-update for standalone Windows executables", () => {
+    expect(detectUpdateAction(
+      "C:\\Users\\vince\\Downloads\\gloomberb.exe",
+      ["C:\\Users\\vince\\Downloads\\gloomberb.exe"],
+    )).toBeNull();
+  });
+
   test("skips updates when launched from source under bun", () => {
     expect(detectUpdateAction(
       "/opt/homebrew/bin/bun",
@@ -76,6 +104,16 @@ describe("detectUpdateAction", () => {
       ["/Applications/Gloomberb.app/Contents/MacOS/bun", "/Applications/Gloomberb.app/Contents/Resources/gloomberb-tui/tui-entry.js"],
     )).toBeNull();
   });
+
+  test("does not suggest Bun-managed updates for the bundled Windows app TUI runtime", () => {
+    expect(detectUpdateAction(
+      "C:\\Users\\vince\\AppData\\Local\\Programs\\Gloomberb\\bin\\bun.exe",
+      [
+        "C:\\Users\\vince\\AppData\\Local\\Programs\\Gloomberb\\bin\\bun.exe",
+        "C:\\Users\\vince\\AppData\\Local\\Programs\\Gloomberb\\Resources\\gloomberb-tui\\tui-entry.js",
+      ],
+    )).toBeNull();
+  });
 });
 
 describe("resolveSelfUpdateTargetPath", () => {
@@ -93,6 +131,13 @@ describe("resolveSelfUpdateTargetPath", () => {
     )).toBeNull();
   });
 
+  it("rejects Windows Bun runtime paths", () => {
+    expect(resolveSelfUpdateTargetPath(
+      "C:\\Program Files\\Bun\\bun.exe",
+      ["C:\\Program Files\\Bun\\bun.exe", "dist\\index.js"],
+    )).toBeNull();
+  });
+
   it("accepts packaged gloomberb binaries", () => {
     expect(resolveSelfUpdateTargetPath(
       "/Applications/gloomberb",

package/src/updater.ts

@@ -52,12 +52,22 @@ function compareSemver(a: string, b: string): number {
   return 0;
 }
 
-function getAssetBaseName(): string {
-  const runtimeProcess = getRuntimeProcess();
-  const os = runtimeProcess?.platform === "darwin" ? "darwin" : "linux";
+export function getAssetBaseNameForRuntime(
+  runtimeProcess: Pick<NodeJS.Process, "platform" | "arch"> | null = getRuntimeProcess(),
+): string {
+  const os = runtimeProcess?.platform === "darwin"
+    ? "darwin"
+    : runtimeProcess?.platform === "win32"
+      ? "windows"
+      : "linux";
   // macOS x64 uses arm64 binary (runs via Rosetta 2)
   const arch = os === "darwin" || runtimeProcess?.arch === "arm64" ? "arm64" : "x64";
-  return `gloomberb-${os}-${arch}`;
+  const extension = os === "windows" ? ".exe" : "";
+  return `gloomberb-${os}-${arch}${extension}`;
+}
+
+function getAssetBaseName(): string {
+  return getAssetBaseNameForRuntime();
 }
 
 function resolveReleaseAsset(
@@ -90,6 +100,29 @@ function basename(value: string): string {
   return normalized.slice(normalized.lastIndexOf("/") + 1);
 }
 
+const runtimeExecutables = new Set([
+  "bun",
+  "bun.exe",
+  "bunx",
+  "bunx.exe",
+  "node",
+  "node.exe",
+  "nodejs",
+  "nodejs.exe",
+  "npm",
+  "npm.cmd",
+  "npm.exe",
+  "npx",
+  "npx.cmd",
+  "npx.exe",
+  "pnpm",
+  "pnpm.cmd",
+  "pnpm.exe",
+  "yarn",
+  "yarn.cmd",
+  "yarn.exe",
+]);
+
 function resolveEntrypointPath(argv = process.argv): string {
   return tryRealpath(argv[1] ?? "");
 }
@@ -104,6 +137,15 @@ function isMacAppBundleExecutable(execPath: string): boolean {
   return normalizePath(execPath).includes(".app/contents/macos/");
 }
 
+function isBundledDesktopTuiRuntime(execPath: string, argv: string[]): boolean {
+  const normalizedExecPath = normalizePath(tryRealpath(execPath));
+  const entrypoint = normalizePath(resolveEntrypointPath(argv));
+  if (!entrypoint.endsWith("/resources/gloomberb-tui/tui-entry.js")) return false;
+  return normalizedExecPath.endsWith("/contents/macos/bun")
+    || normalizedExecPath.endsWith("/bin/bun")
+    || normalizedExecPath.endsWith("/bin/bun.exe");
+}
+
 export function resolveSelfUpdateTargetPath(
   execPath = getRuntimeProcess()?.execPath ?? "",
   argv = getRuntimeProcess()?.argv ?? [],
@@ -113,7 +155,6 @@ export function resolveSelfUpdateTargetPath(
   if (isMacAppBundleExecutable(resolvedExecPath)) return null;
 
   const execBase = basename(normalizedExecPath);
-  const runtimeExecutables = new Set(["bun", "bunx", "node", "nodejs", "npm", "npx", "pnpm", "yarn"]);
   if (runtimeExecutables.has(execBase)) return null;
   if (normalizedExecPath.includes("/.bun/bin/")) return null;
 
@@ -128,20 +169,24 @@ export function detectUpdateAction(
   argv = getRuntimeProcess()?.argv ?? [],
 ): UpdateAction | null {
   if (isMacAppBundleExecutable(execPath)) return null;
-
-  if (resolveSelfUpdateTargetPath(execPath, argv)) {
-    return { kind: "self" };
-  }
+  if (isBundledDesktopTuiRuntime(execPath, argv)) return null;
 
   const normalizedExecPath = normalizePath(tryRealpath(execPath));
   const execBase = basename(normalizedExecPath);
   const entrypoint = normalizePath(resolveEntrypointPath(argv));
+  if (execBase === "gloomberb.exe") return null;
+
+  if (resolveSelfUpdateTargetPath(execPath, argv)) {
+    return { kind: "self" };
+  }
 
   if (!entrypoint || isSourceEntrypoint(entrypoint)) return null;
 
   if (
     execBase === "bun"
+    || execBase === "bun.exe"
     || execBase === "bunx"
+    || execBase === "bunx.exe"
     || normalizedExecPath.includes("/.bun/bin/")
     || entrypoint.includes("/.bun/install/")
     || entrypoint.includes("/install/global/")
@@ -151,11 +196,21 @@ export function detectUpdateAction(
 
   if (
     execBase === "node"
+    || execBase === "node.exe"
     || execBase === "nodejs"
+    || execBase === "nodejs.exe"
     || execBase === "npm"
+    || execBase === "npm.cmd"
+    || execBase === "npm.exe"
     || execBase === "npx"
+    || execBase === "npx.cmd"
+    || execBase === "npx.exe"
     || execBase === "pnpm"
+    || execBase === "pnpm.cmd"
+    || execBase === "pnpm.exe"
     || execBase === "yarn"
+    || execBase === "yarn.cmd"
+    || execBase === "yarn.exe"
     || entrypoint.includes("/lib/node_modules/")
     || entrypoint.includes("/node_modules/")
   ) {
@@ -283,6 +338,7 @@ export async function performUpdate(
 
   const updatePath = execPath + ".update";
   const oldPath = execPath + ".old";
+  let unlinkUpdatePath: ((path: string) => void) | null = null;
 
   try {
     const fsModulePath = "fs";
@@ -293,6 +349,7 @@ export async function performUpdate(
       unlinkSync,
       chmodSync,
     } = await import(fsModulePath) as typeof import("fs");
+    unlinkUpdatePath = unlinkSync;
     const { gunzipSync } = await import(zlibModulePath) as typeof import("zlib");
 
     onProgress({ phase: "downloading", percent: 0 });
@@ -343,7 +400,7 @@ export async function performUpdate(
   } catch (err: unknown) {
     // Clean up temp file on failure
     try {
-      unlinkSync(updatePath);
+      unlinkUpdatePath?.(updatePath);
     } catch {}
     onProgress({
       phase: "error",

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.9.0";
+export const VERSION = "0.9.1";