@wrongstack/desktop 0.286.0 → 0.289.0

package/dist/main/main.js

@@ -1,17 +1,64 @@
 // 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,
+  app as app2,
   BaseWindow,
   dialog,
-  ipcMain,
+  ipcMain as ipcMain2,
+  nativeImage,
   screen,
   shell,
   WebContentsView
 } from "electron";
 
+// src/main/macos-platform.ts
+import { app, Menu } from "electron";
+function initMacOS() {
+  if (process.platform !== "darwin") return;
+  app.setActivationPolicy("regular");
+  app.on("open-file", (_event, filePath) => {
+    if (app.isReady()) {
+      handleFileOpen(filePath);
+    }
+  });
+  app.dock?.setMenu(
+    Menu.buildFromTemplate([
+      {
+        label: "New Window",
+        click: () => {
+        }
+      }
+    ])
+  );
+  app.setAboutPanelOptions({
+    applicationName: "WrongStack Desktop",
+    applicationVersion: app.getVersion(),
+    version: process.versions.electron ? `Electron ${process.versions.electron}` : ""
+  });
+}
+function handleFileOpen(filePath) {
+  pendingOpenFilePath = filePath;
+}
+var pendingOpenFilePath = null;
+function drainPendingOpenFilePath() {
+  const path5 = pendingOpenFilePath;
+  pendingOpenFilePath = null;
+  return path5;
+}
+function firstOpenFileArg(argv) {
+  if (process.platform !== "darwin") return null;
+  for (let index = 1; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg == null) continue;
+    if (arg.startsWith("-")) continue;
+    if (arg === "." || arg === "--") continue;
+    return arg;
+  }
+  return null;
+}
+
 // src/main/agent-bridge.ts
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -397,7 +444,11 @@ var IPC = {
   // Embedded WebUI view side — the desktop shell pushes locale changes here
   // so the React WebUI inside Electron can swap i18n instantly, without waiting
   // for the config-file watcher → WS prefs.updated round-trip.
-  webuiLocaleChanged: "desktop:webui-locale-changed"
+  webuiLocaleChanged: "desktop:webui-locale-changed",
+  // macOS open-file event forwarded from main process to shell renderer.
+  // The shell uses this to decide whether to open a dragged/double-clicked
+  // path as a project directory.
+  openFile: "desktop:open-file"
 };
 
 // src/main/i18n-main.ts
@@ -874,8 +925,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 +1100,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,
@@ -1186,6 +1237,26 @@ async function terminateProcessTree(child) {
   if (!child || child.killed || !child.pid) return;
   if (process.platform !== "win32") {
     child.kill("SIGTERM");
+    const deadline = Date.now() + 5e3;
+    await new Promise((resolve2) => {
+      const check = () => {
+        if (child.killed || !child.pid) {
+          resolve2();
+          return;
+        }
+        if (Date.now() >= deadline) {
+          try {
+            process.kill(-child.pid, "SIGKILL");
+          } catch {
+            child.kill("SIGKILL");
+          }
+          resolve2();
+          return;
+        }
+        setTimeout(check, 100);
+      };
+      check();
+    });
     return;
   }
   await new Promise((resolve2) => {
@@ -1389,16 +1460,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.`
@@ -1525,7 +1596,7 @@ var DESKTOP_WEBUI_ACTIONS = /* @__PURE__ */ new Set([
 var DESKTOP_WEBUI_VIEWS = /* @__PURE__ */ new Set([
   "chat",
   "settings",
-  "autophase",
+  "goal",
   "specs",
   "sddboard",
   "sddwizard",
@@ -1560,7 +1631,6 @@ var DESKTOP_WEBUI_OVERLAYS = /* @__PURE__ */ new Set([
   "queue"
 ]);
 var DESKTOP_WEBUI_DOCKS = /* @__PURE__ */ new Set([
-  "autophase",
   "goal",
   "fleet",
   "work",
@@ -1663,10 +1733,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) {
@@ -1677,10 +1754,10 @@ function getSidebarWidth(windowWidth, collapsed) {
 }
 
 // src/main/menu/index.ts
-import { Menu } from "electron";
+import { Menu as Menu2 } 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 +1765,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 +1891,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 +2062,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();
@@ -2007,19 +2087,301 @@ function configureApplicationMenu(ctx) {
     buildWorkspaceMenu(ctx, actions, hasActiveWebui, activeWebuiPrefs, navigate),
     buildViewMenu(ctx)
   ];
-  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+  Menu2.setApplicationMenu(Menu2.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"));
+initMacOS();
+if (process.platform === "win32") {
+  app2.setAppUserModelId("com.wrongstack.desktop");
+}
+app2.setPath("userData", path4.join(wstackGlobalRoot3(), "desktop", "electron-profile"));
 var manager = new DesktopRuntimeManager();
 var bridge = new DesktopAgentBridge();
 var mainWindow = null;
@@ -2051,13 +2413,21 @@ 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 revealInExplorer(root) {
+  shell.openPath(root).catch((err) => {
+    if (process.platform === "darwin") {
+      void shell.openPath(path4.dirname(root)).catch(() => void 0);
+    }
+    console.error(
+      JSON.stringify({
+        level: "warn",
+        event: "desktop.reveal_in_explorer_failed",
+        root,
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
 }
 function setShellSidebarCollapsed(collapsed) {
   shellSidebarCollapsed = collapsed;
@@ -2603,105 +2973,51 @@ function createMenuContext() {
       shell.openExternal(url);
     },
     revealInExplorer: (root) => {
-      void shell.openPath(root);
+      revealInExplorer(root);
     }
   };
 }
 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) => {
+      revealInExplorer(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 +3035,44 @@ 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;
+  if (process.platform !== "darwin") {
+    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 {
+    }
+  } else {
+    try {
+      const pngPath = new URL("../../assets/icon.png", import.meta.url).pathname;
+      await fs3.stat(pngPath);
+      appIcon = nativeImage.createFromPath(pngPath);
+      if (appIcon.isEmpty()) appIcon = void 0;
+    } catch {
+      try {
+        const icnsPath = new URL("../../assets/icon.icns", import.meta.url).pathname;
+        await fs3.stat(icnsPath);
+        appIcon = nativeImage.createFromPath(icnsPath);
+        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;
@@ -2757,6 +3099,11 @@ async function boot() {
     configureApplicationMenu2();
     broadcastState();
   });
+  app2.on("open-file", (_event, filePath) => {
+    if (shellView && !shellView.webContents.isDestroyed()) {
+      shellView.webContents.send(IPC.openFile, filePath);
+    }
+  });
   let lastWatchedLocale;
   watchProviderConfig(
     desktopConfigPaths.globalConfigPath,
@@ -2780,17 +3127,25 @@ async function boot() {
     disposeAllWebuiEntries();
     void saveWindowState();
     quittingAfterCleanup = true;
-    app.exit(0);
+    app2.exit(0);
   });
   await restoreLastWorkspace();
+  const argvOpenPath = firstOpenFileArg(process.argv);
+  const queuedOpenPath = drainPendingOpenFilePath();
+  const openPath = argvOpenPath ?? queuedOpenPath;
+  if (openPath && shellView && !shellView.webContents.isDestroyed()) {
+    shellView.webContents.send(IPC.openFile, openPath);
+  }
   mainWindow.show();
   shellView.webContents.focus();
 }
-app.whenReady().then(boot);
-app.on("window-all-closed", () => {
-  app.quit();
+app2.whenReady().then(boot);
+app2.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app2.quit();
+  }
 });
-app.on("before-quit", () => {
+app2.on("before-quit", () => {
   if (mainWindow) {
     mainWindow.removeAllListeners("close");
     void saveWindowState();
@@ -2798,7 +3153,7 @@ app.on("before-quit", () => {
   bridge.closeAll();
   disposeAllWebuiEntries();
 });
-app.on("activate", () => {
+app2.on("activate", () => {
   if (!mainWindow) return;
   mainWindow.show();
   shellView?.webContents.focus();