@wrongstack/desktop 0.286.0 → 0.287.0

package/dist/main/main.js

@@ -1,12 +1,13 @@
 // src/main/main.ts
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import * as fs3 from "node:fs/promises";
 import { wstackGlobalRoot as wstackGlobalRoot3 } from "@wrongstack/core/utils";
 import {
   app,
   BaseWindow,
   dialog,
-  ipcMain,
+  ipcMain as ipcMain2,
+  nativeImage,
   screen,
   shell,
   WebContentsView
@@ -874,8 +875,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   }
   async openProject(projectRoot, options = {}) {
     const resolved = path2.resolve(projectRoot);
-    const stat2 = await fs2.stat(resolved).catch(() => null);
-    if (!stat2?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+    const stat3 = await fs2.stat(resolved).catch(() => null);
+    if (!stat3?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
     const kind = options.kind ?? "project";
     const touchRecent = options.touchRecent ?? kind === "project";
     const forceNew = options.forceNew === true;
@@ -1049,8 +1050,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   }
   async registerProject(projectRoot) {
     const resolved = path2.resolve(projectRoot);
-    const stat2 = await fs2.stat(resolved).catch(() => null);
-    if (!stat2?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+    const stat3 = await fs2.stat(resolved).catch(() => null);
+    if (!stat3?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       name: path2.basename(resolved) || resolved,
@@ -1389,16 +1390,16 @@ function resolveWebUiEntry() {
     if (existsSync(candidate)) return candidate;
   } catch {
   }
-  const serverIndex = require2.resolve("@wrongstack/webui/server");
-  return path2.join(path2.dirname(serverIndex), "entry.js");
+  const serverIndex = require2.resolve("@wrongstack/webui-server");
+  return path2.join(path2.dirname(serverIndex), "server", "entry.js");
 }
 function resolveWebUiDistDir() {
   if (process.env["WRONGSTACK_WEBUI_DIST"]) {
     return path2.resolve(process.env["WRONGSTACK_WEBUI_DIST"]);
   }
   const require2 = createRequire(import.meta.url);
-  const serverIndex = require2.resolve("@wrongstack/webui/server");
-  const candidate = path2.resolve(path2.dirname(serverIndex), "..");
+  const serverEntry = require2.resolve("@wrongstack/webui");
+  const candidate = path2.dirname(serverEntry);
   if (existsSync(candidate)) return candidate;
   throw new Error(
     `WebUI frontend assets not found at ${candidate}. Build @wrongstack/webui or set WRONGSTACK_WEBUI_DIST.`
@@ -1663,10 +1664,17 @@ function isRecord(value) {
 }
 
 // src/main/state/constants.ts
+var OPEN_EXTERNAL_ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
 var SIDEBAR_WIDTH_WIDE = 292;
 var SIDEBAR_WIDTH_MEDIUM = 276;
 var SIDEBAR_WIDTH_NARROW = 252;
 var SIDEBAR_WIDTH_COLLAPSED = 56;
+var MIN_WINDOW_WIDTH2 = 760;
+var MIN_WINDOW_HEIGHT2 = 520;
+var MAX_PENDING_WEBUI_COMMANDS = 50;
+var MAX_PENDING_FLUSH_ATTEMPTS = 80;
+var WEBUI_COMMAND_FALLBACK_MS = 350;
+var WEBUI_COMMAND_ACK_TIMEOUT_MS = 2e3;
 
 // src/main/layout/sidebar.ts
 function getSidebarWidth(windowWidth, collapsed) {
@@ -1680,7 +1688,7 @@ function getSidebarWidth(windowWidth, collapsed) {
 import { Menu } from "electron";
 
 // src/main/menu/projects-menu.ts
-var posix = (await import("node:path")).posix;
+import path3 from "node:path";
 function buildProjectsMenu(runtimes, actions, t) {
   const projectGroups = groupProjectRuntimesForMenu(runtimes);
   const menu = [
@@ -1688,9 +1696,11 @@ function buildProjectsMenu(runtimes, actions, t) {
       label: t("openProjectEllipsis"),
       accelerator: "CmdOrCtrl+O",
       click: () => actions.newSession("")
-      // Will open dialog
     },
-    { label: t("registerProjectEllipsis"), click: () => actions.newSession("") },
+    {
+      label: t("registerProjectEllipsis"),
+      click: () => actions.registerProject?.()
+    },
     { type: "separator" }
   ];
   if (projectGroups.length === 0) {
@@ -1812,7 +1822,7 @@ function groupProjectRuntimesForMenu(runtimes) {
     }
     groups.set(key, {
       key,
-      name: posix.basename(runtime.root) || runtime.name,
+      name: path3.basename(runtime.root) || runtime.name,
       root: runtime.root,
       sessions: [runtime]
     });
@@ -1983,6 +1993,7 @@ function configureApplicationMenu(ctx) {
   const actions = {
     activate: (runtimeId) => void ctx.activateRuntime(runtimeId),
     activateAndNavigate,
+    registerProject: () => void ctx.registerProject(),
     newSession: (runtimeId) => {
       if (runtimeId) void ctx.openProjectSession(runtimeId);
       else void ctx.openProject();
@@ -2010,16 +2021,295 @@ function configureApplicationMenu(ctx) {
   Menu.setApplicationMenu(Menu.buildFromTemplate(template));
 }
 
+// src/main/ipc-handlers/index.ts
+import { ipcMain } from "electron";
+
+// src/main/validation/index.ts
+function validate(schema, data) {
+  try {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return { success: false, error: formatZodError(result.error) };
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+}
+function validateOrDefault(schema, data, defaultValue) {
+  const result = validate(schema, data);
+  return result.success ? result.data : defaultValue;
+}
+function formatZodError(error) {
+  return error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+}
+function createValidationLogger(prefix) {
+  const loggedErrors = /* @__PURE__ */ new Set();
+  const maxErrors = 100;
+  return {
+    log(error) {
+      if (loggedErrors.size >= maxErrors) return;
+      const key = `${prefix}:${error}`;
+      if (!loggedErrors.has(key)) {
+        loggedErrors.add(key);
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "desktop.validation_error",
+            prefix,
+            message: error,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+    },
+    reset() {
+      loggedErrors.clear();
+    }
+  };
+}
+
+// src/main/validation/schemas.ts
+import { z } from "zod";
+var RUNTIME_ID_PATTERN = /^[a-zA-Z0-9._:-]{3,120}$/;
+var runtimeIdSchema = z.string().regex(RUNTIME_ID_PATTERN, "Invalid runtime ID format");
+var pathSchema = z.string().min(1).max(1e4);
+var nonEmptyStringSchema = z.string().min(1);
+var booleanSchema = z.boolean();
+var numberSchema = z.number().int().finite();
+var openProjectSchema = z.object({
+  requestedRoot: pathSchema.optional()
+});
+var registerProjectSchema = z.object({
+  requestedRoot: pathSchema.optional()
+});
+var unregisterProjectSchema = z.object({
+  root: pathSchema
+});
+var openProjectSessionSchema = z.object({
+  runtimeId: runtimeIdSchema.optional()
+});
+var activateRuntimeSchema = z.object({
+  id: runtimeIdSchema
+});
+var closeRuntimeSchema = z.object({
+  id: runtimeIdSchema
+});
+var sendMessageSchema = z.object({
+  id: runtimeIdSchema,
+  content: z.string()
+});
+var abortRuntimeSchema = z.object({
+  id: runtimeIdSchema
+});
+var openRuntimeInBrowserSchema = z.object({
+  id: runtimeIdSchema
+});
+var revealRuntimeRootSchema = z.object({
+  id: runtimeIdSchema
+});
+var setShellSidebarCollapsedSchema = z.object({
+  collapsed: booleanSchema
+});
+var navigateWebuiSchema = z.object({
+  command: z.unknown()
+});
+var getConversationSchema = z.object({
+  runtimeId: runtimeIdSchema
+});
+var webuiReadyChangedSchema = z.object({
+  ready: booleanSchema
+});
+var webuiPrefsChangedSchema = z.object({
+  prefs: z.record(z.string(), z.unknown())
+});
+var webuiCommandAckSchema = z.object({
+  requestId: z.string(),
+  handled: z.boolean(),
+  message: z.string().optional()
+});
+var setLocaleSchema = z.object({
+  locale: z.string().min(2).max(10)
+});
+
+// src/main/ipc-handlers/index.ts
+var validationLogger = createValidationLogger("IPC");
+function registerIpcHandlers(ctx) {
+  ipcMain.handle(IPC.getState, () => ctx.getRuntimeManager().snapshot());
+  ipcMain.handle(IPC.getConversation, (_event, runtimeId) => {
+    const result = validate(runtimeIdSchema, runtimeId);
+    if (!result.success) {
+      validationLogger.log(`getConversation: ${result.error}`);
+      return ctx.getAgentBridge().snapshot("");
+    }
+    return ctx.getAgentBridge().snapshot(result.data);
+  });
+  ipcMain.handle(IPC.getWebuiStatus, () => ctx.getWebuiStatus());
+  ipcMain.handle(IPC.navigateWebui, async (_event, command) => {
+    return ctx.dispatchWebuiCommand(command);
+  });
+  ipcMain.handle(IPC.reloadWebui, async () => ctx.reloadActiveWebuiView());
+  ipcMain.handle(IPC.setShellSidebarCollapsed, (_event, collapsed) => {
+    const result = validateOrDefault(
+      pathSchema.transform(() => collapsed === true),
+      collapsed,
+      true
+    );
+    ctx.setShellSidebarCollapsed(result);
+    return true;
+  });
+  ipcMain.handle(IPC.openSettings, async () => ctx.openSettings());
+  ipcMain.handle(IPC.openProjectSession, async (_event, runtimeId) => {
+    const validated = validateOptional(runtimeIdSchema, runtimeId);
+    return ctx.openProjectSession(validated);
+  });
+  ipcMain.handle(IPC.openProject, async (_event, requestedRoot) => {
+    const validated = validateOptional(pathSchema, requestedRoot);
+    return ctx.openProject(validated);
+  });
+  ipcMain.handle(IPC.registerProject, async (_event, requestedRoot) => {
+    const validated = validateOptional(pathSchema, requestedRoot);
+    return ctx.registerProject(validated);
+  });
+  ipcMain.handle(IPC.unregisterProject, async (_event, root) => {
+    const result = validate(pathSchema, root);
+    if (!result.success) {
+      validationLogger.log(`unregisterProject: ${result.error}`);
+      return ctx.getRuntimeManager().snapshot();
+    }
+    return ctx.unregisterProject(result.data);
+  });
+  ipcMain.handle(IPC.activateRuntime, async (_event, id) => {
+    const result = validate(runtimeIdSchema, id);
+    if (!result.success) {
+      validationLogger.log(`activateRuntime: ${result.error}`);
+      return ctx.getRuntimeManager().snapshot();
+    }
+    return ctx.activateRuntime(result.data);
+  });
+  ipcMain.handle(IPC.closeRuntime, async (_event, id) => {
+    const result = validate(runtimeIdSchema, id);
+    if (!result.success) {
+      validationLogger.log(`closeRuntime: ${result.error}`);
+      return ctx.getRuntimeManager().snapshot();
+    }
+    return ctx.closeRuntime(result.data);
+  });
+  ipcMain.handle(IPC.sendMessage, async (_event, id, content) => {
+    const idResult = validate(runtimeIdSchema, id);
+    if (!idResult.success) {
+      validationLogger.log(`sendMessage (id): ${idResult.error}`);
+      return ctx.sendMessage("", "", "");
+    }
+    const contentResult = validate(pathSchema.transform(() => String(content ?? "")), content);
+    const safeContent = contentResult.success ? contentResult.data : String(content ?? "");
+    return ctx.sendMessage(
+      idResult.data,
+      ctx.getRuntimeManager().getRuntimeWsUrlWithToken(idResult.data) ?? "",
+      safeContent
+    );
+  });
+  ipcMain.handle(IPC.abortRuntime, async (_event, id) => {
+    const result = validate(runtimeIdSchema, id);
+    if (!result.success) {
+      validationLogger.log(`abortRuntime: ${result.error}`);
+      return ctx.abortRuntime("", "");
+    }
+    return ctx.abortRuntime(
+      result.data,
+      ctx.getRuntimeManager().getRuntimeWsUrlWithToken(result.data) ?? ""
+    );
+  });
+  ipcMain.handle(IPC.openRuntimeInBrowser, async (_event, id) => {
+    const result = validate(runtimeIdSchema, id);
+    if (!result.success) {
+      validationLogger.log(`openRuntimeInBrowser: ${result.error}`);
+      return;
+    }
+    const url = ctx.getRuntimeManager().getRuntimeUrlWithToken(result.data);
+    if (url) ctx.openExternal(url);
+  });
+  ipcMain.handle(IPC.revealRuntimeRoot, async (_event, id) => {
+    const result = validate(runtimeIdSchema, id);
+    if (!result.success) {
+      validationLogger.log(`revealRuntimeRoot: ${result.error}`);
+      return;
+    }
+    const runtime = ctx.getRuntimeManager().getRuntime(result.data);
+    if (runtime) ctx.revealInExplorer(runtime.root);
+  });
+  ipcMain.on(IPC.webuiReadyChanged, (event, ready) => {
+    const entry = ctx.findWebuiEntryBySenderId(event.sender.id);
+    if (!entry) return;
+    const isReady = ready === true;
+    entry.bridgeReady = isReady;
+    if (entry.bridgeReady) {
+      ctx.setEntryWebuiStatus(entry, { ...entry.status, status: "ready" });
+      ctx.schedulePendingWebuiFlush(entry);
+    } else if (entry.status.status === "ready") {
+      ctx.setEntryWebuiStatus(entry, { ...entry.status, status: "loading" });
+    }
+  });
+  ipcMain.on(IPC.webuiPrefsChanged, (event, prefs) => {
+    const entry = ctx.findWebuiEntryBySenderId(event.sender.id);
+    if (!entry) return;
+    const sanitized = sanitizeWebuiPrefs(prefs);
+    if (Object.keys(sanitized).length === 0) return;
+    ctx.setEntryWebuiStatus(entry, {
+      ...entry.status,
+      prefs: { ...entry.status.prefs ?? {}, ...sanitized }
+    });
+  });
+  ipcMain.on(IPC.webuiCommandAck, (event, requestId, handled, _message) => {
+    const entry = ctx.findWebuiEntryBySenderId(event.sender.id);
+    if (!entry) return;
+    const result = validate(webuiCommandAckSchema, {
+      requestId,
+      handled,
+      message: _message
+    });
+    if (!result.success) {
+      validationLogger.log(`webuiCommandAck: ${result.error}`);
+      return;
+    }
+    const pending = ctx.getPendingWebuiCommandAcks().get(result.data.requestId);
+    if (!pending || pending.runtimeId !== entry.runtimeId) return;
+    ctx.settlePendingWebuiCommandAck(result.data.requestId, result.data.handled);
+  });
+  ipcMain.on(IPC.setLocale, (_event, locale) => {
+    const result = validate(setLocaleSchema, { locale });
+    if (!result.success) {
+      validationLogger.log(`setLocale: ${result.error}`);
+      return;
+    }
+    ctx.getI18n().setMainLocale(result.data.locale);
+    ctx.configureApplicationMenu();
+    ctx.broadcastLocaleToEmbeddedWebuis(result.data.locale);
+    void ctx.getConfigIo().writeUiLocale(result.data.locale);
+  });
+}
+function validateOptional(schema, value) {
+  if (value === void 0 || value === null) return void 0;
+  const result = schema.safeParse(value);
+  return result.success ? result.data : void 0;
+}
+function sanitizeWebuiPrefs(prefs) {
+  const next = {};
+  if (!isRecord2(prefs)) return next;
+  if (typeof prefs["yolo"] === "boolean") next.yolo = prefs["yolo"];
+  if (typeof prefs["nextPrediction"] === "boolean") next.nextPrediction = prefs["nextPrediction"];
+  if (typeof prefs["contextAutoCompact"] === "boolean") {
+    next.contextAutoCompact = prefs["contextAutoCompact"];
+  }
+  return next;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/main/main.ts
-var OPEN_EXTERNAL_ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
-var MIN_WINDOW_WIDTH2 = 760;
-var MIN_WINDOW_HEIGHT2 = 520;
-var MAX_PENDING_WEBUI_COMMANDS = 50;
-var MAX_PENDING_FLUSH_ATTEMPTS = 80;
-var WEBUI_COMMAND_FALLBACK_MS = 350;
-var WEBUI_COMMAND_ACK_TIMEOUT_MS = 2e3;
 app.setAppUserModelId("com.wrongstack.desktop");
-app.setPath("userData", path3.join(wstackGlobalRoot3(), "desktop", "electron-profile"));
+app.setPath("userData", path4.join(wstackGlobalRoot3(), "desktop", "electron-profile"));
 var manager = new DesktopRuntimeManager();
 var bridge = new DesktopAgentBridge();
 var mainWindow = null;
@@ -2051,14 +2341,6 @@ function sameOrigin(candidate, base) {
     return false;
   }
 }
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function runtimeWsUrlOrThrow(runtimeId) {
-  const wsUrl = manager.getRuntimeWsUrlWithToken(runtimeId);
-  if (!wsUrl) throw new Error(`Runtime not found: ${runtimeId}`);
-  return wsUrl;
-}
 function setShellSidebarCollapsed(collapsed) {
   shellSidebarCollapsed = collapsed;
   layoutWebuiViews();
@@ -2610,98 +2892,44 @@ function createMenuContext() {
 function configureApplicationMenu2() {
   configureApplicationMenu(createMenuContext());
 }
-function registerIpcHandlers() {
-  ipcMain.handle(IPC.getState, () => manager.snapshot());
-  ipcMain.handle(
-    IPC.getConversation,
-    (_event, runtimeId) => bridge.snapshot(runtimeId)
-  );
-  ipcMain.handle(IPC.getWebuiStatus, () => webuiStatus);
-  ipcMain.handle(
-    IPC.navigateWebui,
-    async (_event, command) => dispatchWebuiCommand(command)
-  );
-  ipcMain.handle(IPC.reloadWebui, async () => reloadActiveWebuiView());
-  ipcMain.handle(IPC.setShellSidebarCollapsed, (_event, collapsed) => {
-    setShellSidebarCollapsed(collapsed === true);
-    return true;
-  });
-  ipcMain.handle(IPC.openSettings, async () => openSettings());
-  ipcMain.handle(
-    IPC.openProjectSession,
-    async (_event, runtimeId) => openProjectSession(runtimeId)
-  );
-  ipcMain.handle(
-    IPC.openProject,
-    async (_event, requestedRoot) => openProject(requestedRoot)
-  );
-  ipcMain.handle(
-    IPC.registerProject,
-    async (_event, requestedRoot) => registerProject(requestedRoot)
-  );
-  ipcMain.handle(IPC.unregisterProject, async (_event, root) => unregisterProject(root));
-  ipcMain.handle(IPC.activateRuntime, async (_event, id) => activateRuntime(id));
-  ipcMain.handle(IPC.closeRuntime, async (_event, id) => closeRuntime(id));
-  ipcMain.handle(
-    IPC.sendMessage,
-    async (_event, id, content) => bridge.sendMessage(id, runtimeWsUrlOrThrow(id), content)
-  );
-  ipcMain.handle(
-    IPC.abortRuntime,
-    async (_event, id) => bridge.abort(id, runtimeWsUrlOrThrow(id))
-  );
-  ipcMain.handle(IPC.openRuntimeInBrowser, async (_event, id) => {
-    const url = manager.getRuntimeUrlWithToken(id);
-    if (url) safeOpenExternal(url);
-  });
-  ipcMain.handle(IPC.revealRuntimeRoot, async (_event, id) => {
-    const runtime = manager.getRuntime(id);
-    if (runtime) void shell.openPath(runtime.root);
-  });
-  ipcMain.on(IPC.webuiReadyChanged, (event, ready) => {
-    const entry = findWebuiEntryBySenderId(event.sender.id);
-    if (!entry) return;
-    entry.bridgeReady = ready === true;
-    if (entry.bridgeReady) {
-      setEntryWebuiStatus(entry, { ...entry.status, status: "ready" });
-      schedulePendingWebuiFlush(entry);
-    } else if (entry.status.status === "ready") {
-      setEntryWebuiStatus(entry, { ...entry.status, status: "loading" });
-    }
-  });
-  ipcMain.on(IPC.webuiPrefsChanged, (event, prefs) => {
-    const entry = findWebuiEntryBySenderId(event.sender.id);
-    if (!entry) return;
-    const next = {};
-    if (isRecord2(prefs) && typeof prefs["yolo"] === "boolean") next.yolo = prefs["yolo"];
-    if (isRecord2(prefs) && typeof prefs["nextPrediction"] === "boolean") {
-      next.nextPrediction = prefs["nextPrediction"];
-    }
-    if (isRecord2(prefs) && typeof prefs["contextAutoCompact"] === "boolean") {
-      next.contextAutoCompact = prefs["contextAutoCompact"];
-    }
-    if (Object.keys(next).length === 0) return;
-    setEntryWebuiStatus(entry, {
-      ...entry.status,
-      prefs: { ...entry.status.prefs ?? {}, ...next }
-    });
-  });
-  ipcMain.on(
-    IPC.webuiCommandAck,
-    (event, requestId, handled, _message) => {
-      const entry = findWebuiEntryBySenderId(event.sender.id);
-      if (!entry || typeof requestId !== "string") return;
-      const pending = pendingWebuiCommandAcks.get(requestId);
-      if (!pending || pending.runtimeId !== entry.runtimeId) return;
-      settlePendingWebuiCommandAck(requestId, handled === true);
-    }
-  );
-  ipcMain.on(IPC.setLocale, (_event, locale) => {
-    setMainLocale(locale);
-    configureApplicationMenu2();
-    broadcastLocaleToEmbeddedWebuis(locale);
-    void writeUiLocale(locale);
-  });
+function buildIpcHandlerContext() {
+  return {
+    getMainWindow: () => mainWindow,
+    getShellView: () => shellView,
+    getWebuiViews: () => webuiViews,
+    getWebuiStatus: () => webuiStatus,
+    getRuntimeManager: () => manager,
+    getAgentBridge: () => bridge,
+    getI18n: () => ({ getMainLocale, setMainLocale, tMain }),
+    getConfigIo: () => ({ desktopConfigPaths, readUiLocale, writeUiLocale }),
+    getShellSidebarCollapsed: () => shellSidebarCollapsed,
+    setShellSidebarCollapsed: (collapsed) => setShellSidebarCollapsed(collapsed),
+    broadcastState: () => broadcastState(),
+    publishWebuiStatus: (next) => publishWebuiStatus(next),
+    syncActiveWebuiView: () => syncActiveWebuiView(),
+    configureApplicationMenu: () => configureApplicationMenu2(),
+    broadcastLocaleToEmbeddedWebuis: (locale) => broadcastLocaleToEmbeddedWebuis(locale),
+    dispatchWebuiCommand: (command) => dispatchWebuiCommand(command),
+    reloadActiveWebuiView: () => reloadActiveWebuiView(),
+    openProject: (root) => openProject(root),
+    registerProject: (root) => registerProject(root),
+    unregisterProject: (root) => unregisterProject(root),
+    openProjectSession: (id) => openProjectSession(id),
+    activateRuntime: (id) => activateRuntime(id),
+    closeRuntime: (id) => closeRuntime(id),
+    openSettings: () => openSettings(),
+    sendMessage: (id, wsUrl, content) => bridge.sendMessage(id, wsUrl, content),
+    abortRuntime: (id, wsUrl) => bridge.abort(id, wsUrl),
+    openExternal: (url) => safeOpenExternal(url),
+    revealInExplorer: (root) => {
+      void shell.openPath(root);
+    },
+    findWebuiEntryBySenderId: (senderId) => findWebuiEntryBySenderId(senderId),
+    getPendingWebuiCommandAcks: () => pendingWebuiCommandAcks,
+    settlePendingWebuiCommandAck: (requestId, handled) => settlePendingWebuiCommandAck(requestId, handled),
+    setEntryWebuiStatus: (entry, next) => setEntryWebuiStatus(entry, next),
+    schedulePendingWebuiFlush: (entry) => schedulePendingWebuiFlush(entry)
+  };
 }
 async function boot() {
   const locale = await readUiLocale();
@@ -2719,18 +2947,27 @@ async function boot() {
     safeOpenExternal(url);
     return { action: "deny" };
   });
-  registerIpcHandlers();
+  registerIpcHandlers(buildIpcHandlerContext());
   await shellView.webContents.loadURL(shellUrl);
   const prevState = validatedWindowState(manager.getWindowState());
   const defaultWidth = 1180;
   const defaultHeight = 720;
+  let appIcon;
+  try {
+    const iconPath = new URL("../../assets/icon.svg", import.meta.url).pathname;
+    await fs3.stat(iconPath);
+    appIcon = nativeImage.createFromPath(iconPath);
+    if (appIcon.isEmpty()) appIcon = void 0;
+  } catch {
+  }
   const winOptions = {
     width: prevState?.width ?? defaultWidth,
     height: prevState?.height ?? defaultHeight,
     show: false,
     minWidth: MIN_WINDOW_WIDTH2,
     minHeight: MIN_WINDOW_HEIGHT2,
-    title: tMain("windowTitle")
+    title: tMain("windowTitle"),
+    ...appIcon ? { icon: appIcon } : {}
   };
   if (prevState) {
     if (prevState.x !== void 0) winOptions.x = prevState.x;