@wrongstack/desktop 0.280.0

package/dist/main/main.js

@@ -0,0 +1,2293 @@
+import {
+  DesktopAgentBridge
+} from "./chunk-F3LGFYUK.js";
+
+// src/main/main.ts
+import * as path3 from "path";
+import * as fs3 from "fs/promises";
+import { wstackGlobalRoot as wstackGlobalRoot3 } from "@wrongstack/core/utils";
+import {
+  app,
+  BaseWindow,
+  dialog,
+  ipcMain,
+  Menu,
+  screen,
+  shell,
+  WebContentsView
+} from "electron";
+
+// src/main/ipc.ts
+var IPC = {
+  getState: "desktop:get-state",
+  getConversation: "desktop:get-conversation",
+  getWebuiStatus: "desktop:get-webui-status",
+  openProject: "desktop:open-project",
+  registerProject: "desktop:register-project",
+  unregisterProject: "desktop:unregister-project",
+  openProjectSession: "desktop:open-project-session",
+  activateRuntime: "desktop:activate-runtime",
+  closeRuntime: "desktop:close-runtime",
+  navigateWebui: "desktop:navigate-webui",
+  reloadWebui: "desktop:reload-webui",
+  setShellSidebarCollapsed: "desktop:set-shell-sidebar-collapsed",
+  openSettings: "desktop:open-settings",
+  sendMessage: "desktop:send-message",
+  abortRuntime: "desktop:abort-runtime",
+  openRuntimeInBrowser: "desktop:open-runtime-in-browser",
+  revealRuntimeRoot: "desktop:reveal-runtime-root",
+  stateChanged: "desktop:state-changed",
+  conversationChanged: "desktop:conversation-changed",
+  webuiStatusChanged: "desktop:webui-status-changed",
+  webuiReadyChanged: "desktop:webui-ready-changed",
+  webuiPrefsChanged: "desktop:webui-prefs-changed",
+  webuiCommandAck: "desktop:webui-command-ack",
+  webuiCommand: "desktop:webui-command",
+  shellSidebarCollapsedChanged: "desktop:shell-sidebar-collapsed-changed",
+  setLocale: "desktop:set-locale",
+  localeChanged: "desktop:locale-changed",
+  // 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"
+};
+
+// src/main/i18n-main.ts
+var en = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "No open project sessions",
+  revealProjectFolder: "Reveal Project Folder",
+  quickView: "Quick View",
+  chat: "Chat",
+  terminal: "Terminal",
+  session: "Session",
+  newSession: "New Session",
+  file: "File",
+  view: "View",
+  workspace: "Workspace",
+  projects: "Projects",
+  openProject: "Open Project",
+  registerProject: "Register Project",
+  openProjectEllipsis: "Open Project\u2026",
+  registerProjectEllipsis: "Register Project\u2026",
+  removeActiveFromRegistry: "Remove Active Project from Registry",
+  newSessionForActive: "New Session for Active Project",
+  settings: "Settings",
+  closeActiveRuntime: "Close Active Runtime",
+  openChat: "Open Chat",
+  focusPrompt: "Focus Prompt",
+  toggleTerminal: "Toggle Terminal",
+  newTerminal: "New Terminal",
+  files: "Files",
+  changes: "Changes",
+  sessions: "Sessions",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Command Palette",
+  modelSwitcher: "Model Switcher",
+  quickModelSwitcher: "Quick Model Switcher",
+  openInBrowser: "Open in Browser",
+  reloadWebui: "Reload WebUI",
+  reloadActiveWebui: "Reload Active WebUI",
+  closeSession: "Close Session",
+  yoloMode: "YOLO Mode",
+  nextPrediction: "Next Prediction",
+  contextAutoCompact: "Context Auto Compact",
+  compactDesktopSidebar: "Compact Desktop Sidebar"
+};
+var tr = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "A\xE7\u0131k proje oturumu yok",
+  revealProjectFolder: "Proje klas\xF6r\xFCn\xFC g\xF6ster",
+  quickView: "H\u0131zl\u0131 g\xF6r\xFCn\xFCm",
+  chat: "Sohbet",
+  terminal: "Terminal",
+  session: "Oturum",
+  newSession: "Yeni Oturum",
+  file: "Dosya",
+  view: "G\xF6r\xFCn\xFCm",
+  workspace: "\xC7al\u0131\u015Fma alan\u0131",
+  projects: "Projeler",
+  openProject: "Proje A\xE7",
+  registerProject: "Proje Kaydet",
+  openProjectEllipsis: "Proje A\xE7\u2026",
+  registerProjectEllipsis: "Proje Kaydet\u2026",
+  removeActiveFromRegistry: "Aktif Projeyi Kay\u0131ttan Kald\u0131r",
+  newSessionForActive: "Aktif Proje i\xE7in Yeni Oturum",
+  settings: "Ayarlar",
+  closeActiveRuntime: "Aktif \xC7al\u0131\u015Fma Zaman\u0131n\u0131 Kapat",
+  openChat: "Sohbeti A\xE7",
+  focusPrompt: "\u0130steme Odaklan",
+  toggleTerminal: "Terminali A\xE7/Kapat",
+  newTerminal: "Yeni Terminal",
+  files: "Dosyalar",
+  changes: "De\u011Fi\u015Fiklikler",
+  sessions: "Oturumlar",
+  fleetHQ: "Filo HQ",
+  commandPalette: "Komut Paleti",
+  modelSwitcher: "Model De\u011Fi\u015Ftirici",
+  quickModelSwitcher: "H\u0131zl\u0131 Model De\u011Fi\u015Ftirici",
+  openInBrowser: "Taray\u0131c\u0131da A\xE7",
+  reloadWebui: "WebUI Yeniden Y\xFCkle",
+  reloadActiveWebui: "Aktif WebUI Yeniden Y\xFCkle",
+  closeSession: "Oturumu Kapat",
+  yoloMode: "YOLO Modu",
+  nextPrediction: "Sonraki Tahmin",
+  contextAutoCompact: "Ba\u011Flam\u0131 Otomatik S\u0131k\u0131\u015Ft\u0131r",
+  compactDesktopSidebar: "Masa\xFCst\xFC Kenar \xC7ubu\u011Funu Daralt"
+};
+var de = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "Keine offenen Projektsessions",
+  revealProjectFolder: "Projektordner anzeigen",
+  quickView: "Schnellansicht",
+  chat: "Chat",
+  terminal: "Terminal",
+  session: "Sitzung",
+  newSession: "Neue Sitzung",
+  file: "Datei",
+  view: "Ansicht",
+  workspace: "Workspace",
+  projects: "Projekte",
+  openProject: "Projekt \xF6ffnen",
+  registerProject: "Projekt registrieren",
+  openProjectEllipsis: "Projekt \xF6ffnen\u2026",
+  registerProjectEllipsis: "Projekt registrieren\u2026",
+  removeActiveFromRegistry: "Aktives Projekt aus Registry entfernen",
+  newSessionForActive: "Neue Sitzung f\xFCr aktives Projekt",
+  settings: "Einstellungen",
+  closeActiveRuntime: "Aktive Runtime schlie\xDFen",
+  openChat: "Chat \xF6ffnen",
+  focusPrompt: "Prompt fokussieren",
+  toggleTerminal: "Terminal umschalten",
+  newTerminal: "Neues Terminal",
+  files: "Dateien",
+  changes: "\xC4nderungen",
+  sessions: "Sitzungen",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Command Palette",
+  modelSwitcher: "Modell-Umschalter",
+  quickModelSwitcher: "Schneller Modell-Umschalter",
+  openInBrowser: "Im Browser \xF6ffnen",
+  reloadWebui: "WebUI neu laden",
+  reloadActiveWebui: "Aktive WebUI neu laden",
+  closeSession: "Sitzung schlie\xDFen",
+  yoloMode: "YOLO-Modus",
+  nextPrediction: "Next-Step-Vorhersage",
+  contextAutoCompact: "Kontext auto-kompaktieren",
+  compactDesktopSidebar: "Desktop-Seitenleiste einklappen"
+};
+var fr = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "Aucune session de projet ouverte",
+  revealProjectFolder: "R\xE9v\xE9ler le dossier du projet",
+  quickView: "Vue rapide",
+  chat: "Chat",
+  terminal: "Terminal",
+  session: "Session",
+  newSession: "Nouvelle session",
+  file: "Fichier",
+  view: "Affichage",
+  workspace: "Espace de travail",
+  projects: "Projets",
+  openProject: "Ouvrir un projet",
+  registerProject: "Enregistrer le projet",
+  openProjectEllipsis: "Ouvrir un projet\u2026",
+  registerProjectEllipsis: "Enregistrer le projet\u2026",
+  removeActiveFromRegistry: "Retirer le projet actif du registre",
+  newSessionForActive: "Nouvelle session pour le projet actif",
+  settings: "Param\xE8tres",
+  closeActiveRuntime: "Fermer l'ex\xE9cution active",
+  openChat: "Ouvrir le chat",
+  focusPrompt: "Focaliser le prompt",
+  toggleTerminal: "Basculer le terminal",
+  newTerminal: "Nouveau terminal",
+  files: "Fichiers",
+  changes: "Modifications",
+  sessions: "Sessions",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Palette de commandes",
+  modelSwitcher: "S\xE9lecteur de mod\xE8le",
+  quickModelSwitcher: "S\xE9lecteur de mod\xE8le rapide",
+  openInBrowser: "Ouvrir dans le navigateur",
+  reloadWebui: "Recharger WebUI",
+  reloadActiveWebui: "Recharger WebUI actif",
+  closeSession: "Fermer la session",
+  yoloMode: "Mode YOLO",
+  nextPrediction: "Pr\xE9diction du prochain pas",
+  contextAutoCompact: "Compacter le contexte auto",
+  compactDesktopSidebar: "R\xE9duire la barre lat\xE9rale"
+};
+var it = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "Nessuna sessione di progetto aperta",
+  revealProjectFolder: "Rivela cartella progetto",
+  quickView: "Vista rapida",
+  chat: "Chat",
+  terminal: "Terminale",
+  session: "Sessione",
+  newSession: "Nuova sessione",
+  file: "File",
+  view: "Visualizza",
+  workspace: "Workspace",
+  projects: "Progetti",
+  openProject: "Apri progetto",
+  registerProject: "Registra progetto",
+  openProjectEllipsis: "Apri progetto\u2026",
+  registerProjectEllipsis: "Registra progetto\u2026",
+  removeActiveFromRegistry: "Rimuovi progetto attivo dal registro",
+  newSessionForActive: "Nuova sessione per il progetto attivo",
+  settings: "Impostazioni",
+  closeActiveRuntime: "Chiudi runtime attivo",
+  openChat: "Apri chat",
+  focusPrompt: "Focalizza prompt",
+  toggleTerminal: "Attiva/disattiva terminale",
+  newTerminal: "Nuovo terminale",
+  files: "File",
+  changes: "Modifiche",
+  sessions: "Sessioni",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Palette comandi",
+  modelSwitcher: "Selettore modello",
+  quickModelSwitcher: "Selettore modello rapido",
+  openInBrowser: "Apri nel browser",
+  reloadWebui: "Ricarica WebUI",
+  reloadActiveWebui: "Ricarica WebUI attivo",
+  closeSession: "Chiudi sessione",
+  yoloMode: "Modalit\xE0 YOLO",
+  nextPrediction: "Predizione prossimo passo",
+  contextAutoCompact: "Compatta contesto auto",
+  compactDesktopSidebar: "Comprimi barra laterale desktop"
+};
+var es = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "Sin sesiones de proyecto abiertas",
+  revealProjectFolder: "Revelar carpeta del proyecto",
+  quickView: "Vista r\xE1pida",
+  chat: "Chat",
+  terminal: "Terminal",
+  session: "Sesi\xF3n",
+  newSession: "Nueva sesi\xF3n",
+  file: "Archivo",
+  view: "Ver",
+  workspace: "Espacio de trabajo",
+  projects: "Proyectos",
+  openProject: "Abrir proyecto",
+  registerProject: "Registrar proyecto",
+  openProjectEllipsis: "Abrir proyecto\u2026",
+  registerProjectEllipsis: "Registrar proyecto\u2026",
+  removeActiveFromRegistry: "Quitar proyecto activo del registro",
+  newSessionForActive: "Nueva sesi\xF3n para el proyecto activo",
+  settings: "Ajustes",
+  closeActiveRuntime: "Cerrar runtime activo",
+  openChat: "Abrir chat",
+  focusPrompt: "Focalizar indicaci\xF3n",
+  toggleTerminal: "Alternar terminal",
+  newTerminal: "Nuevo terminal",
+  files: "Archivos",
+  changes: "Cambios",
+  sessions: "Sesiones",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Paleta de comandos",
+  modelSwitcher: "Selector de modelo",
+  quickModelSwitcher: "Selector de modelo r\xE1pido",
+  openInBrowser: "Abrir en el navegador",
+  reloadWebui: "Recargar WebUI",
+  reloadActiveWebui: "Recargar WebUI activo",
+  closeSession: "Cerrar sesi\xF3n",
+  yoloMode: "Modo YOLO",
+  nextPrediction: "Predicci\xF3n del siguiente paso",
+  contextAutoCompact: "Auto-compactar contexto",
+  compactDesktopSidebar: "Contraer barra lateral de escritorio"
+};
+var ptBR = {
+  windowTitle: "WrongStack Desktop",
+  noOpenProjectSessions: "Sem sess\xF5es de projeto abertas",
+  revealProjectFolder: "Revelar pasta do projeto",
+  quickView: "Vista r\xE1pida",
+  chat: "Chat",
+  terminal: "Terminal",
+  session: "Sess\xE3o",
+  newSession: "Nova sess\xE3o",
+  file: "Arquivo",
+  view: "Ver",
+  workspace: "Workspace",
+  projects: "Projetos",
+  openProject: "Abrir projeto",
+  registerProject: "Registrar projeto",
+  openProjectEllipsis: "Abrir projeto\u2026",
+  registerProjectEllipsis: "Registrar projeto\u2026",
+  removeActiveFromRegistry: "Remover projeto ativo do registro",
+  newSessionForActive: "Nova sess\xE3o para o projeto ativo",
+  settings: "Configura\xE7\xF5es",
+  closeActiveRuntime: "Fechar runtime ativo",
+  openChat: "Abrir chat",
+  focusPrompt: "Focar prompt",
+  toggleTerminal: "Alternar terminal",
+  newTerminal: "Novo terminal",
+  files: "Arquivos",
+  changes: "Altera\xE7\xF5es",
+  sessions: "Sess\xF5es",
+  fleetHQ: "Fleet HQ",
+  commandPalette: "Paleta de comandos",
+  modelSwitcher: "Seletor de modelo",
+  quickModelSwitcher: "Seletor de modelo r\xE1pido",
+  openInBrowser: "Abrir no navegador",
+  reloadWebui: "Recarregar WebUI",
+  reloadActiveWebui: "Recarregar WebUI ativo",
+  closeSession: "Fechar sess\xE3o",
+  yoloMode: "Modo YOLO",
+  nextPrediction: "Previs\xE3o do pr\xF3ximo passo",
+  contextAutoCompact: "Auto-compactar contexto",
+  compactDesktopSidebar: "Recolher barra lateral do desktop"
+};
+var CATALOGS = { en, tr, de, fr, it, es, "pt-BR": ptBR };
+var mainLocale = "en";
+function setMainLocale(locale) {
+  if (locale in CATALOGS) mainLocale = locale;
+}
+function getMainLocale() {
+  return mainLocale;
+}
+function tMain(key) {
+  return CATALOGS[mainLocale]?.[key] ?? CATALOGS.en[key] ?? key;
+}
+
+// src/main/desktop-config-io.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { DefaultSecretVault } from "@wrongstack/core";
+import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
+import { atomicWrite, wstackGlobalRoot } from "@wrongstack/core/utils";
+var globalConfigPath = path.join(wstackGlobalRoot(), "config.json");
+var vault = new DefaultSecretVault({
+  keyFile: path.join(wstackGlobalRoot(), ".key")
+});
+async function readUiLocale() {
+  let raw;
+  try {
+    raw = await fs.readFile(globalConfigPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const decrypted = decryptConfigSecrets(
+      JSON.parse(raw),
+      vault
+    );
+    const value = decrypted.uiLocale;
+    return typeof value === "string" && value ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var desktopConfigPaths = { globalConfigPath, vault };
+async function writeUiLocale(code) {
+  let raw;
+  try {
+    raw = await fs.readFile(globalConfigPath, "utf8");
+  } catch {
+    raw = "{}";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const decrypted = decryptConfigSecrets(parsed, vault);
+  decrypted.uiLocale = code;
+  const encrypted = encryptConfigSecrets(decrypted, vault);
+  await atomicWrite(globalConfigPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+}
+
+// src/main/runtime-manager.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { EventEmitter } from "events";
+import * as fs2 from "fs/promises";
+import * as http from "http";
+import { createRequire } from "module";
+import * as net from "net";
+import * as os from "os";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+import { atomicWrite as atomicWrite2, projectSlug, toErrorMessage, wstackGlobalRoot as wstackGlobalRoot2 } from "@wrongstack/core/utils";
+var HTTP_PORT_START = 34560;
+var WS_PORT_START = 34660;
+var START_TIMEOUT_MS = 3e4;
+var MIN_WINDOW_WIDTH = 760;
+var MIN_WINDOW_HEIGHT = 520;
+var DesktopRuntimeManager = class extends EventEmitter {
+  runtimes = /* @__PURE__ */ new Map();
+  stateFile = path2.join(wstackGlobalRoot2(), "desktop.json");
+  recentProjects = [];
+  registeredProjects = [];
+  restoreProjectSessions = [];
+  restoreActiveRuntimeId = null;
+  restoreActiveProjectRoot = null;
+  lastActiveProjectRoot = null;
+  windowState = null;
+  activeRuntimeId = null;
+  restoring = false;
+  workspaceRestoreCompleted = false;
+  async init() {
+    const state = await this.loadDesktopState();
+    this.recentProjects = state.recentProjects;
+    this.registeredProjects = await readGlobalProjectManifest();
+    this.restoreProjectSessions = state.openProjectSessions;
+    this.restoreActiveRuntimeId = state.activeRuntimeId;
+    this.restoreActiveProjectRoot = state.activeProjectRoot;
+    this.lastActiveProjectRoot = state.activeProjectRoot;
+    this.windowState = state.window;
+  }
+  snapshot() {
+    return {
+      activeRuntimeId: this.activeRuntimeId,
+      runtimes: Array.from(this.runtimes.values()).map(publicRuntime),
+      recentProjects: [...this.recentProjects],
+      registeredProjects: [...this.registeredProjects],
+      restoring: this.restoring
+    };
+  }
+  getWindowState() {
+    return this.windowState ? { ...this.windowState } : null;
+  }
+  async saveWindowState(window) {
+    this.windowState = { ...window };
+    await this.saveDesktopState();
+  }
+  async restoreLastWorkspace() {
+    const sessions = this.restoreProjectSessions.filter(
+      (session) => typeof session.root === "string" && session.root.trim()
+    );
+    if (sessions.length === 0 || this.restoring || this.runtimes.size > 0) {
+      this.workspaceRestoreCompleted = true;
+      return;
+    }
+    this.restoring = true;
+    this.emitChanged();
+    try {
+      const seen = /* @__PURE__ */ new Map();
+      for (const session of sessions) {
+        const key = pathKey(session.root);
+        const seenCount = seen.get(key) ?? 0;
+        seen.set(key, seenCount + 1);
+        await this.openProject(session.root, {
+          forceNew: seenCount > 0,
+          name: session.name,
+          runtimeId: session.runtimeId
+        }).catch((err) => {
+          process.stderr.write(
+            `[desktop:restore] Failed to restore ${session.root}: ${toErrorMessage(err)}
+`
+          );
+        });
+      }
+      let restoredActive = false;
+      if (this.restoreActiveRuntimeId) {
+        const active = this.runtimes.get(this.restoreActiveRuntimeId);
+        if (active) {
+          await this.activateRuntime(active.id);
+          restoredActive = true;
+        }
+      }
+      if (!restoredActive && this.restoreActiveProjectRoot) {
+        const active = Array.from(this.runtimes.values()).find(
+          (runtime) => samePath(runtime.root, this.restoreActiveProjectRoot ?? "")
+        );
+        if (active) await this.activateRuntime(active.id);
+      }
+    } finally {
+      this.restoring = false;
+      this.workspaceRestoreCompleted = true;
+      this.emitChanged();
+      await this.saveDesktopState();
+    }
+  }
+  getRuntime(id) {
+    const runtime = this.runtimes.get(id);
+    return runtime ? publicRuntime(runtime) : void 0;
+  }
+  getRuntimeUrlWithToken(id) {
+    const runtime = this.runtimes.get(id);
+    if (!runtime) return void 0;
+    const url = new URL(runtime.url);
+    url.searchParams.set("token", runtime.token);
+    url.searchParams.set("shell", "desktop");
+    return url.toString();
+  }
+  getRuntimeWsUrlWithToken(id) {
+    const runtime = this.runtimes.get(id);
+    if (!runtime) return void 0;
+    const url = new URL(`ws://127.0.0.1:${runtime.wsPort}`);
+    url.searchParams.set("token", runtime.token);
+    return url.toString();
+  }
+  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 kind = options.kind ?? "project";
+    const touchRecent = options.touchRecent ?? kind === "project";
+    const forceNew = options.forceNew === true;
+    if (!forceNew) {
+      const existing = Array.from(this.runtimes.values()).find(
+        (runtime2) => samePath(runtime2.root, resolved) && runtime2.kind === kind && (runtime2.status === "starting" || runtime2.status === "running")
+      );
+      if (existing) {
+        this.activeRuntimeId = existing.id;
+        if (existing.kind === "project") this.lastActiveProjectRoot = existing.root;
+        if (touchRecent) {
+          await this.touchProject(existing.root);
+        } else {
+          await this.persistWorkspaceState();
+        }
+        this.emitChanged();
+        return publicRuntime(existing);
+      }
+      const staleSameRoot = Array.from(this.runtimes.values()).filter(
+        (runtime2) => samePath(runtime2.root, resolved) && runtime2.kind === kind
+      );
+      for (const stale of staleSameRoot) {
+        await this.closeRuntimeInternal(stale.id, { persistWorkspace: false });
+      }
+    }
+    const slug = projectSlug(resolved);
+    const requestedRuntimeId = normalizeRuntimeId(options.runtimeId);
+    const runtimeId = requestedRuntimeId && !this.runtimes.has(requestedRuntimeId) ? requestedRuntimeId : `${slug}-${randomBytes(3).toString("hex")}`;
+    const name = options.name ?? nextRuntimeName(this.runtimes, resolved, kind);
+    const httpPort = await findFreePort(HTTP_PORT_START, usedPorts(this.runtimes));
+    const wsPort = await findFreePort(
+      WS_PORT_START,
+      /* @__PURE__ */ new Set([...usedPorts(this.runtimes), httpPort])
+    );
+    const token = randomBytes(24).toString("hex");
+    const runtime = {
+      id: runtimeId,
+      name,
+      root: resolved,
+      slug,
+      kind,
+      status: "starting",
+      httpPort,
+      wsPort,
+      url: `http://127.0.0.1:${httpPort}`,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      token,
+      child: null,
+      logs: [],
+      logNotifyTimer: null
+    };
+    this.runtimes.set(runtimeId, runtime);
+    this.activeRuntimeId = runtimeId;
+    if (kind === "project") this.lastActiveProjectRoot = resolved;
+    if (touchRecent) {
+      await this.touchProject(resolved);
+    } else {
+      await this.persistWorkspaceState();
+    }
+    this.emitChanged();
+    try {
+      const entry = resolveWebUiEntry();
+      const child = spawn(
+        process.execPath,
+        [
+          entry,
+          "--host",
+          "127.0.0.1",
+          "--port",
+          String(httpPort),
+          "--ws-port",
+          String(wsPort),
+          "--token",
+          token,
+          "--require-token"
+        ],
+        {
+          cwd: resolved,
+          env: {
+            ...process.env,
+            ELECTRON_RUN_AS_NODE: "1",
+            WEBUI_STRICT_PORT: "1",
+            WRONGSTACK_DESKTOP: "1"
+          },
+          stdio: ["ignore", "pipe", "pipe"],
+          windowsHide: true
+        }
+      );
+      runtime.child = child;
+      runtime.pid = child.pid;
+      child.stdout?.on("data", (chunk) => {
+        const text = chunk.toString();
+        appendRuntimeLog(runtime, "stdout", text);
+        this.scheduleLogChanged(runtime);
+        process.stdout.write(`[desktop:${runtime.id}] ${text}`);
+      });
+      child.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        appendRuntimeLog(runtime, "stderr", text);
+        this.scheduleLogChanged(runtime);
+        process.stderr.write(`[desktop:${runtime.id}] ${text}`);
+      });
+      child.once("exit", (code, signal) => {
+        runtime.status = runtime.status === "error" ? "error" : "stopped";
+        runtime.error = runtime.status === "error" ? runtime.error : code === 0 ? void 0 : `Exited with ${signal ?? `code ${code ?? "unknown"}`}`;
+        runtime.child = null;
+        if (this.activeRuntimeId === runtime.id) {
+          this.activeRuntimeId = firstRunningRuntimeId(this.runtimes);
+        }
+        this.emitChanged();
+      });
+      await waitForHttpReady(runtime.url, token, START_TIMEOUT_MS);
+      runtime.status = "running";
+      await this.persistWorkspaceState();
+      this.emitChanged();
+      return publicRuntime(runtime);
+    } catch (err) {
+      runtime.status = "error";
+      runtime.error = toErrorMessage(err);
+      await terminateProcessTree(runtime.child);
+      runtime.child = null;
+      this.emitChanged();
+      throw err;
+    }
+  }
+  async activateRuntime(id) {
+    const runtime = this.runtimes.get(id);
+    if (!runtime) throw new Error(`Runtime not found: ${id}`);
+    this.activeRuntimeId = id;
+    if (runtime.kind === "project") this.lastActiveProjectRoot = runtime.root;
+    if (runtime.kind === "project") {
+      await this.touchProject(runtime.root);
+    } else {
+      await this.persistWorkspaceState();
+    }
+    this.emitChanged();
+  }
+  async closeRuntime(id) {
+    await this.closeRuntimeInternal(id, { persistWorkspace: true });
+  }
+  async closeAll(options = {}) {
+    const persistWorkspace = options.persistWorkspace ?? true;
+    await Promise.all(
+      Array.from(this.runtimes.keys()).map(
+        (id) => this.closeRuntimeInternal(id, { persistWorkspace })
+      )
+    );
+  }
+  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 now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      name: path2.basename(resolved) || resolved,
+      root: resolved,
+      slug: projectSlug(resolved),
+      lastSeen: now,
+      lastWorkingDir: resolved
+    };
+    this.registeredProjects = await touchGlobalProjectManifest(entry);
+    this.emitChanged();
+  }
+  async unregisterProject(projectRoot) {
+    const resolved = path2.resolve(projectRoot);
+    this.registeredProjects = await removeGlobalProjectManifest(resolved);
+    this.recentProjects = this.recentProjects.filter((project) => !samePath(project.root, resolved));
+    await this.saveDesktopState();
+    this.emitChanged();
+  }
+  async closeRuntimeInternal(id, options) {
+    const runtime = this.runtimes.get(id);
+    if (!runtime) return;
+    runtime.status = "stopped";
+    const child = runtime.child;
+    runtime.child = null;
+    await terminateProcessTree(child);
+    if (runtime.logNotifyTimer) {
+      clearTimeout(runtime.logNotifyTimer);
+      runtime.logNotifyTimer = null;
+    }
+    this.runtimes.delete(id);
+    if (this.activeRuntimeId === id) this.activeRuntimeId = firstRunningRuntimeId(this.runtimes);
+    if (this.lastActiveProjectRoot && samePath(this.lastActiveProjectRoot, runtime.root)) {
+      this.lastActiveProjectRoot = firstProjectRuntimeRoot(this.runtimes);
+    }
+    if (options.persistWorkspace) {
+      await this.persistWorkspaceState();
+    }
+    this.emitChanged();
+  }
+  async touchProject(projectRoot) {
+    const resolved = path2.resolve(projectRoot);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      name: path2.basename(resolved) || resolved,
+      root: resolved,
+      slug: projectSlug(resolved),
+      lastSeen: now,
+      lastWorkingDir: resolved
+    };
+    this.recentProjects = [
+      entry,
+      ...this.recentProjects.filter((p) => !samePath(p.root, resolved))
+    ].slice(0, 24);
+    const [, registeredProjects] = await Promise.all([
+      this.saveDesktopState(),
+      touchGlobalProjectManifest(entry)
+    ]);
+    this.registeredProjects = registeredProjects;
+  }
+  async persistWorkspaceState() {
+    await this.saveDesktopState();
+  }
+  async loadDesktopState() {
+    try {
+      const raw = await fs2.readFile(this.stateFile, "utf8");
+      const parsed = JSON.parse(raw);
+      const openProjects = normalizePathList(parsed.openProjects);
+      const openProjectSessions = normalizeSessionStateList(
+        parsed.openProjectSessions,
+        openProjects
+      );
+      return {
+        recentProjects: Array.isArray(parsed.recentProjects) ? parsed.recentProjects : [],
+        openProjects,
+        openProjectSessions,
+        activeRuntimeId: normalizeRuntimeId(parsed.activeRuntimeId) ?? null,
+        activeProjectRoot: typeof parsed.activeProjectRoot === "string" && parsed.activeProjectRoot.trim() ? path2.resolve(parsed.activeProjectRoot) : null,
+        window: normalizeWindowState(parsed.window)
+      };
+    } catch {
+      return {
+        recentProjects: [],
+        openProjects: [],
+        openProjectSessions: [],
+        activeRuntimeId: null,
+        activeProjectRoot: null,
+        window: null
+      };
+    }
+  }
+  async saveDesktopState() {
+    await fs2.mkdir(path2.dirname(this.stateFile), { recursive: true });
+    const liveProjectSessions = Array.from(this.runtimes.values()).filter((runtime) => runtime.status !== "stopped" && runtime.kind === "project").map((runtime) => runtimeToSessionState(runtime));
+    const openProjectSessions = liveProjectSessions.length === 0 && !this.workspaceRestoreCompleted ? [...this.restoreProjectSessions] : liveProjectSessions;
+    const openProjects = openProjectSessions.map((session) => session.root);
+    const activeRuntime = this.activeRuntimeId ? this.runtimes.get(this.activeRuntimeId) : null;
+    const lastActiveProjectRoot = this.lastActiveProjectRoot;
+    const fallbackSession = lastActiveProjectRoot ? openProjectSessions.find((session) => samePath(session.root, lastActiveProjectRoot)) : void 0;
+    const activeSession = activeRuntime?.kind === "project" ? runtimeToSessionState(activeRuntime) : fallbackSession ?? openProjectSessions[0];
+    const activeRoot = activeSession?.root;
+    const activeRuntimeId2 = activeSession?.runtimeId ?? null;
+    await atomicWrite2(
+      this.stateFile,
+      `${JSON.stringify(
+        {
+          recentProjects: this.recentProjects,
+          openProjects,
+          openProjectSessions,
+          activeRuntimeId: activeRuntimeId2,
+          activeProjectRoot: activeRoot ?? null,
+          window: this.windowState
+        },
+        null,
+        2
+      )}
+`,
+      { mode: 384 }
+    );
+  }
+  emitChanged() {
+    this.emit("changed");
+  }
+  scheduleLogChanged(runtime) {
+    if (runtime.logNotifyTimer) return;
+    runtime.logNotifyTimer = setTimeout(() => {
+      runtime.logNotifyTimer = null;
+      if (this.runtimes.get(runtime.id) === runtime) {
+        this.emitChanged();
+      }
+    }, 250);
+  }
+};
+async function terminateProcessTree(child) {
+  if (!child || child.killed || !child.pid) return;
+  if (process.platform !== "win32") {
+    child.kill("SIGTERM");
+    return;
+  }
+  await new Promise((resolve3) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve3();
+    };
+    const timer = setTimeout(finish, 3e3);
+    timer.unref?.();
+    const killer = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    killer.once("exit", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    killer.once("error", () => {
+      clearTimeout(timer);
+      child.kill();
+      finish();
+    });
+  });
+}
+function publicRuntime(runtime) {
+  const {
+    child: _child,
+    token: _token,
+    logs,
+    logNotifyTimer: _logNotifyTimer,
+    ...record
+  } = runtime;
+  void _child;
+  void _token;
+  void _logNotifyTimer;
+  return {
+    ...record,
+    recentLogs: logs.slice(-40)
+  };
+}
+function runtimeToSessionState(runtime) {
+  return {
+    runtimeId: runtime.id,
+    name: runtime.name,
+    root: runtime.root,
+    startedAt: runtime.startedAt
+  };
+}
+function appendRuntimeLog(runtime, stream, text) {
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    if (!line) continue;
+    runtime.logs.push(`[${stream}] ${line}`);
+  }
+  if (runtime.logs.length > 120) {
+    runtime.logs.splice(0, runtime.logs.length - 120);
+  }
+}
+function normalizePathList(value) {
+  if (!Array.isArray(value)) return [];
+  const roots = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !item.trim()) continue;
+    const resolved = path2.resolve(item);
+    roots.push(resolved);
+  }
+  return roots.slice(0, 12);
+}
+function normalizeSessionStateList(value, fallbackRoots) {
+  if (!Array.isArray(value)) {
+    return fallbackRoots.map((root) => ({ root })).slice(0, 12);
+  }
+  const sessions = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const candidate = item;
+    if (typeof candidate.root !== "string" || !candidate.root.trim()) continue;
+    const session = {
+      root: path2.resolve(candidate.root)
+    };
+    const runtimeId = normalizeRuntimeId(candidate.runtimeId);
+    if (runtimeId) session.runtimeId = runtimeId;
+    if (typeof candidate.name === "string" && candidate.name.trim()) {
+      session.name = candidate.name.trim().slice(0, 120);
+    }
+    if (typeof candidate.startedAt === "string" && candidate.startedAt.trim()) {
+      session.startedAt = candidate.startedAt.trim();
+    }
+    sessions.push(session);
+  }
+  return sessions.slice(0, 12);
+}
+function normalizeRuntimeId(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!/^[a-zA-Z0-9._:-]{3,120}$/.test(trimmed)) return void 0;
+  return trimmed;
+}
+function normalizeWindowState(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  const width = Number(candidate.width);
+  const height = Number(candidate.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  if (width < MIN_WINDOW_WIDTH || height < MIN_WINDOW_HEIGHT) return null;
+  const state = {
+    width: Math.round(width),
+    height: Math.round(height),
+    maximized: Boolean(candidate.maximized)
+  };
+  if (Number.isFinite(Number(candidate.x))) state.x = Math.round(Number(candidate.x));
+  if (Number.isFinite(Number(candidate.y))) state.y = Math.round(Number(candidate.y));
+  return state;
+}
+function firstRunningRuntimeId(runtimes) {
+  return Array.from(runtimes.values()).find((runtime) => runtime.status === "running")?.id ?? null;
+}
+function firstProjectRuntimeRoot(runtimes) {
+  return Array.from(runtimes.values()).find(
+    (runtime) => runtime.status === "running" && runtime.kind === "project"
+  )?.root ?? null;
+}
+function usedPorts(runtimes) {
+  const ports = /* @__PURE__ */ new Set();
+  for (const runtime of runtimes.values()) {
+    ports.add(runtime.httpPort);
+    ports.add(runtime.wsPort);
+  }
+  return ports;
+}
+function nextRuntimeName(runtimes, root, kind) {
+  const baseName = path2.basename(root) || root;
+  if (kind !== "project") return baseName;
+  const liveSameRoot = Array.from(runtimes.values()).filter(
+    (runtime) => runtime.kind === "project" && samePath(runtime.root, root) && runtime.status !== "stopped"
+  ).length;
+  return liveSameRoot === 0 ? baseName : `${baseName} #${liveSameRoot + 1}`;
+}
+function pathKey(value) {
+  const resolved = path2.resolve(value);
+  return os.platform() === "win32" ? resolved.toLowerCase() : resolved;
+}
+async function findFreePort(startPort, exclude) {
+  for (let port = startPort; port < startPort + 200; port++) {
+    if (exclude.has(port)) continue;
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(`No free local port found near ${startPort}`);
+}
+function isPortFree(port) {
+  return new Promise((resolve3) => {
+    const server = net.createServer();
+    server.once("error", () => resolve3(false));
+    server.once("listening", () => {
+      server.close(() => resolve3(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function waitForHttpReady(baseUrl, token, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const url = new URL(baseUrl);
+  url.searchParams.set("token", token);
+  url.searchParams.set("shell", "desktop");
+  return new Promise((resolve3, reject) => {
+    const probe = () => {
+      const req = http.get(url, (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 500) {
+          resolve3();
+          return;
+        }
+        retry();
+      });
+      req.once("error", retry);
+      req.setTimeout(1e3, () => {
+        req.destroy();
+        retry();
+      });
+    };
+    const retry = () => {
+      if (Date.now() >= deadline) {
+        reject(new Error(`WebUI did not become ready at ${baseUrl}`));
+        return;
+      }
+      setTimeout(probe, 250);
+    };
+    probe();
+  });
+}
+function resolveWebUiEntry() {
+  if (process.env["WRONGSTACK_WEBUI_ENTRY"]) {
+    return path2.resolve(process.env["WRONGSTACK_WEBUI_ENTRY"]);
+  }
+  const require2 = createRequire(import.meta.url);
+  const serverIndex = require2.resolve("@wrongstack/webui/server");
+  return path2.join(path2.dirname(serverIndex), "entry.js");
+}
+async function readGlobalProjectManifest() {
+  const manifestFile = path2.join(wstackGlobalRoot2(), "projects.json");
+  try {
+    const raw = await fs2.readFile(manifestFile, "utf8");
+    const parsed = JSON.parse(raw);
+    const projects = Array.isArray(parsed.projects) ? parsed.projects : [];
+    return projects.filter((project) => typeof project?.root === "string" && project.root.trim()).map((project) => ({
+      ...project,
+      name: project.name || path2.basename(project.root) || project.root,
+      root: path2.resolve(project.root),
+      slug: project.slug || projectSlug(path2.resolve(project.root))
+    })).sort((a, b) => (b.lastSeen ?? b.createdAt ?? "").localeCompare(a.lastSeen ?? a.createdAt ?? "")).slice(0, 80);
+  } catch {
+    return [];
+  }
+}
+async function touchGlobalProjectManifest(entry) {
+  const manifestFile = path2.join(wstackGlobalRoot2(), "projects.json");
+  const projects = await readGlobalProjectManifest();
+  const existing = projects.find((p) => samePath(p.root, entry.root));
+  if (existing) {
+    existing.name = entry.name;
+    existing.slug = entry.slug;
+    existing.lastSeen = entry.lastSeen;
+    existing.lastWorkingDir = entry.lastWorkingDir;
+  } else {
+    projects.push({ ...entry, createdAt: entry.lastSeen });
+  }
+  const sorted = projects.sort((a, b) => (b.lastSeen ?? b.createdAt ?? "").localeCompare(a.lastSeen ?? a.createdAt ?? "")).slice(0, 80);
+  await fs2.mkdir(path2.dirname(manifestFile), { recursive: true });
+  await atomicWrite2(manifestFile, `${JSON.stringify({ projects: sorted }, null, 2)}
+`, { mode: 384 });
+  return sorted;
+}
+async function removeGlobalProjectManifest(projectRoot) {
+  const manifestFile = path2.join(wstackGlobalRoot2(), "projects.json");
+  const resolved = path2.resolve(projectRoot);
+  const projects = (await readGlobalProjectManifest()).filter(
+    (project) => !samePath(project.root, resolved)
+  );
+  await fs2.mkdir(path2.dirname(manifestFile), { recursive: true });
+  await atomicWrite2(manifestFile, `${JSON.stringify({ projects }, null, 2)}
+`, { mode: 384 });
+  return projects;
+}
+function samePath(left, right) {
+  const a = path2.resolve(left);
+  const b = path2.resolve(right);
+  return os.platform() === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function rendererIndexPath() {
+  return fileURLToPath(new URL("../renderer/index.html", import.meta.url));
+}
+function preloadPath() {
+  return fileURLToPath(new URL("../preload/preload.cjs", import.meta.url));
+}
+function webuiPreloadPath() {
+  return fileURLToPath(new URL("../preload/webui-preload.cjs", import.meta.url));
+}
+
+// src/main/main.ts
+import { watchProviderConfig } from "@wrongstack/core/storage";
+
+// src/main/webui-command-bridge.ts
+var DESKTOP_WEBUI_ACTIONS = /* @__PURE__ */ new Set([
+  "new-session",
+  "clear-context",
+  "compact-context",
+  "repair-context",
+  "download-chat",
+  "focus-chat",
+  "open-command-palette",
+  "open-shortcuts",
+  "search-chat",
+  "open-model-switcher",
+  "open-prompt-library"
+]);
+var DESKTOP_WEBUI_VIEWS = /* @__PURE__ */ new Set([
+  "chat",
+  "settings",
+  "autophase",
+  "specs",
+  "sddboard",
+  "sddwizard",
+  "files",
+  "changes",
+  "sessions",
+  "setup",
+  "skill",
+  "officemap",
+  "mailbox",
+  "debug",
+  "design-gallery",
+  "refresh-debug",
+  "analytics"
+]);
+var DESKTOP_WEBUI_ACTIVITIES = /* @__PURE__ */ new Set([
+  "chat",
+  "agents",
+  "history",
+  "files",
+  "changes",
+  "mailbox",
+  "skills",
+  "design",
+  "worktrees",
+  "officemap"
+]);
+var DESKTOP_WEBUI_OVERLAYS = /* @__PURE__ */ new Set([
+  "fleet",
+  "agents-monitor",
+  "processes",
+  "queue"
+]);
+var DESKTOP_WEBUI_DOCKS = /* @__PURE__ */ new Set([
+  "autophase",
+  "goal",
+  "fleet",
+  "work",
+  "worktrees",
+  "collab"
+]);
+var DESKTOP_WEBUI_WORK_TABS = /* @__PURE__ */ new Set(["todos", "tasks", "plan"]);
+var DESKTOP_WEBUI_PREF_KEYS = /* @__PURE__ */ new Set([
+  "yolo",
+  "nextPrediction",
+  "contextAutoCompact"
+]);
+function normalizeDesktopWebuiCommand(value) {
+  if (!isRecord(value)) return null;
+  const command = {};
+  let hasCommand = false;
+  const action = value["action"];
+  if (action !== void 0) {
+    if (typeof action !== "string" || !DESKTOP_WEBUI_ACTIONS.has(action)) {
+      return null;
+    }
+    command.action = action;
+    hasCommand = true;
+  }
+  const view = value["view"];
+  if (view !== void 0) {
+    if (typeof view !== "string" || !DESKTOP_WEBUI_VIEWS.has(view)) {
+      return null;
+    }
+    command.view = view;
+    hasCommand = true;
+  }
+  const activity = value["activity"];
+  if (activity !== void 0) {
+    if (typeof activity !== "string" || !DESKTOP_WEBUI_ACTIVITIES.has(activity)) {
+      return null;
+    }
+    command.activity = activity;
+    hasCommand = true;
+  }
+  const overlay = value["overlay"];
+  if (overlay !== void 0) {
+    if (typeof overlay !== "string" || !DESKTOP_WEBUI_OVERLAYS.has(overlay)) {
+      return null;
+    }
+    command.overlay = overlay;
+    hasCommand = true;
+  }
+  const dockSection = value["dockSection"];
+  if (dockSection !== void 0) {
+    if (typeof dockSection !== "string" || !DESKTOP_WEBUI_DOCKS.has(dockSection)) {
+      return null;
+    }
+    command.dockSection = dockSection;
+    hasCommand = true;
+  }
+  const workTab = value["workTab"];
+  if (workTab !== void 0) {
+    if (typeof workTab !== "string" || !DESKTOP_WEBUI_WORK_TABS.has(workTab)) {
+      return null;
+    }
+    command.workTab = workTab;
+    hasCommand = true;
+  }
+  const terminal = value["terminal"];
+  if (terminal !== void 0) {
+    if (terminal !== true && terminal !== false && terminal !== "toggle" && terminal !== "new") {
+      return null;
+    }
+    command.terminal = terminal;
+    hasCommand = true;
+  }
+  const pref = value["pref"];
+  if (pref !== void 0) {
+    if (!isRecord(pref)) return null;
+    const key = pref["key"];
+    if (typeof key !== "string" || !DESKTOP_WEBUI_PREF_KEYS.has(key)) {
+      return null;
+    }
+    const toggle = pref["toggle"];
+    const prefValue = pref["value"];
+    if (toggle !== void 0 && typeof toggle !== "boolean") return null;
+    if (prefValue !== void 0 && typeof prefValue !== "boolean") return null;
+    if (toggle === void 0 && prefValue === void 0) return null;
+    command.pref = {
+      key,
+      ...typeof prefValue === "boolean" ? { value: prefValue } : {},
+      ...typeof toggle === "boolean" ? { toggle } : {}
+    };
+    hasCommand = true;
+  }
+  return hasCommand ? command : null;
+}
+function buildWebuiCommandFallbackScript(command) {
+  const payload = JSON.stringify(command).replace(/</g, "\\u003c");
+  return `window.dispatchEvent(new CustomEvent('wrongstack:desktop-command', { detail: ${payload} })); true;`;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/main/main.ts
+var manager = new DesktopRuntimeManager();
+var bridge = new DesktopAgentBridge();
+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;
+app.setAppUserModelId("com.wrongstack.desktop");
+app.setPath("userData", path3.join(wstackGlobalRoot3(), "desktop", "electron-profile"));
+function safeOpenExternal(target) {
+  let protocol;
+  try {
+    protocol = new URL(target).protocol;
+  } catch {
+    return;
+  }
+  if (OPEN_EXTERNAL_ALLOWED_PROTOCOLS.has(protocol)) {
+    void shell.openExternal(target);
+  }
+}
+var mainWindow = null;
+var shellView = null;
+var webuiViews = /* @__PURE__ */ new Map();
+var activeWebuiRuntimeId = null;
+var webuiStatus = { runtimeId: null, status: "idle" };
+var webuiCommandSequence = 0;
+var shellSidebarCollapsed = false;
+var pendingWebuiCommandAcks = /* @__PURE__ */ new Map();
+var saveWindowStateTimer = null;
+var quittingAfterCleanup = false;
+async function createWindow() {
+  await manager.init();
+  const bootLocale = await readUiLocale();
+  if (bootLocale) setMainLocale(bootLocale);
+  configureApplicationMenu();
+  const windowState = validatedWindowState(manager.getWindowState());
+  const windowOptions = {
+    width: windowState?.width ?? 1320,
+    height: windowState?.height ?? 860,
+    minWidth: MIN_WINDOW_WIDTH2,
+    minHeight: MIN_WINDOW_HEIGHT2,
+    title: tMain("windowTitle"),
+    backgroundColor: "#111217"
+  };
+  if (windowState?.x !== void 0) windowOptions.x = windowState.x;
+  if (windowState?.y !== void 0) windowOptions.y = windowState.y;
+  mainWindow = new BaseWindow(windowOptions);
+  if (windowState?.maximized) {
+    mainWindow.maximize();
+  }
+  shellView = new WebContentsView({
+    webPreferences: {
+      preload: preloadPath(),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+  mainWindow.contentView.addChildView(shellView);
+  shellView.webContents.once("did-finish-load", () => {
+    shellView?.webContents.send(IPC.localeChanged, getMainLocale());
+  });
+  shellView.webContents.setWindowOpenHandler(({ url }) => {
+    safeOpenExternal(url);
+    return { action: "deny" };
+  });
+  await shellView.webContents.loadFile(rendererIndexPath());
+  mainWindow.on("resize", layoutViews);
+  mainWindow.on("resize", scheduleWindowStateSave);
+  mainWindow.on("move", scheduleWindowStateSave);
+  mainWindow.on("maximize", scheduleWindowStateSave);
+  mainWindow.on("unmaximize", scheduleWindowStateSave);
+  mainWindow.on("close", () => {
+    if (saveWindowStateTimer) {
+      clearTimeout(saveWindowStateTimer);
+      saveWindowStateTimer = null;
+    }
+    void saveWindowState();
+  });
+  mainWindow.on("closed", () => {
+    if (saveWindowStateTimer) {
+      clearTimeout(saveWindowStateTimer);
+      saveWindowStateTimer = null;
+    }
+    mainWindow = null;
+    disposeAllWebuiEntries();
+    shellView = null;
+    activeWebuiRuntimeId = null;
+    webuiStatus = { runtimeId: null, status: "idle" };
+  });
+  layoutViews();
+  syncActiveWebuiView();
+  void restoreLastWorkspace();
+}
+function layoutViews() {
+  if (!mainWindow || !shellView) return;
+  const size = mainWindow.getContentSize();
+  const width = size[0] ?? 0;
+  const height = size[1] ?? 0;
+  shellView.setBounds({ x: 0, y: 0, width, height });
+  layoutWebuiViews(width, height);
+}
+function scheduleWindowStateSave() {
+  if (saveWindowStateTimer) clearTimeout(saveWindowStateTimer);
+  saveWindowStateTimer = setTimeout(() => {
+    saveWindowStateTimer = null;
+    void saveWindowState();
+  }, 350);
+}
+async function saveWindowState() {
+  if (!mainWindow) return;
+  const bounds = mainWindow.getNormalBounds();
+  await manager.saveWindowState({
+    x: bounds.x,
+    y: bounds.y,
+    width: bounds.width,
+    height: bounds.height,
+    maximized: mainWindow.isMaximized()
+  });
+}
+function layoutWebuiViews(windowWidth, windowHeight) {
+  if (!mainWindow) return;
+  const size = mainWindow.getContentSize();
+  const width = windowWidth ?? size[0] ?? 0;
+  const height = windowHeight ?? size[1] ?? 0;
+  const snapshot = manager.snapshot();
+  const active = snapshot.runtimes.find((runtime) => runtime.id === snapshot.activeRuntimeId);
+  const sidebarWidth = desktopSidebarWidth(width);
+  const contentWidth = Math.max(0, width - sidebarWidth);
+  for (const entry of webuiViews.values()) {
+    if (active?.id === entry.runtimeId && active.status === "running") {
+      entry.view.setBounds({ x: sidebarWidth, y: 0, width: contentWidth, height });
+    } else {
+      entry.view.setBounds({ x: sidebarWidth, y: 0, width: 0, height });
+    }
+  }
+}
+function desktopSidebarWidth(windowWidth) {
+  if (shellSidebarCollapsed) return SIDEBAR_WIDTH_COLLAPSED;
+  if (windowWidth < 900) return SIDEBAR_WIDTH_NARROW;
+  if (windowWidth < 1180) return SIDEBAR_WIDTH_MEDIUM;
+  return SIDEBAR_WIDTH_WIDE;
+}
+function setShellSidebarCollapsed(collapsed) {
+  shellSidebarCollapsed = collapsed;
+  layoutWebuiViews();
+  configureApplicationMenu();
+  if (!shellView || shellView.webContents.isDestroyed()) return;
+  shellView.webContents.send(IPC.shellSidebarCollapsedChanged, shellSidebarCollapsed);
+}
+function ensureWebuiEntry(runtimeId) {
+  if (!mainWindow) return null;
+  const existing = webuiViews.get(runtimeId);
+  if (existing) return existing;
+  const view = new WebContentsView({
+    webPreferences: {
+      preload: webuiPreloadPath(),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+  const entry = {
+    runtimeId,
+    view,
+    url: null,
+    status: { runtimeId, status: "idle" },
+    bridgeReady: false,
+    attached: false,
+    pendingCommands: [],
+    pendingFlushTimer: null,
+    pendingFlushAttempts: 0
+  };
+  view.webContents.setWindowOpenHandler(({ url }) => {
+    safeOpenExternal(url);
+    return { action: "deny" };
+  });
+  view.webContents.on("will-navigate", (event, url) => {
+    if (sameOrigin(url, entry.url)) return;
+    event.preventDefault();
+    safeOpenExternal(url);
+  });
+  view.webContents.on("did-start-loading", () => {
+    if (webuiViews.get(runtimeId) !== entry) return;
+    entry.bridgeReady = false;
+    setEntryWebuiStatus(entry, { runtimeId, status: "loading" });
+  });
+  view.webContents.on("did-finish-load", () => {
+    if (webuiViews.get(runtimeId) !== entry) return;
+    schedulePendingWebuiFlush(entry);
+    try {
+      entry.view.webContents.send(IPC.webuiLocaleChanged, getMainLocale());
+    } catch {
+    }
+  });
+  view.webContents.on("did-fail-load", (_event, errorCode, errorDescription) => {
+    if (webuiViews.get(runtimeId) !== entry || errorCode === -3) return;
+    setEntryWebuiStatus(entry, {
+      runtimeId,
+      status: "error",
+      error: errorDescription
+    });
+  });
+  view.webContents.on("render-process-gone", (_event, details) => {
+    if (webuiViews.get(runtimeId) !== entry) return;
+    setEntryWebuiStatus(entry, {
+      runtimeId,
+      status: "error",
+      error: `WebUI renderer exited: ${details.reason}`
+    });
+  });
+  webuiViews.set(runtimeId, entry);
+  return entry;
+}
+function syncActiveWebuiView() {
+  if (!mainWindow) return;
+  const snapshot = manager.snapshot();
+  pruneWebuiEntries(
+    snapshot.runtimes.filter((runtime) => runtime.status === "running").map((runtime) => runtime.id)
+  );
+  const active = snapshot.runtimes.find((runtime) => runtime.id === snapshot.activeRuntimeId);
+  if (active?.status !== "running") {
+    activeWebuiRuntimeId = active?.id ?? null;
+    publishWebuiStatus({ runtimeId: active?.id ?? null, status: "idle" });
+    layoutWebuiViews();
+    return;
+  }
+  const url = manager.getRuntimeUrlWithToken(active.id);
+  if (!url) {
+    activeWebuiRuntimeId = active.id;
+    publishWebuiStatus({ runtimeId: active.id, status: "idle" });
+    layoutWebuiViews();
+    return;
+  }
+  const entry = ensureWebuiEntry(active.id);
+  if (!entry) return;
+  activeWebuiRuntimeId = active.id;
+  attachWebuiEntry(entry);
+  layoutWebuiViews();
+  publishWebuiStatus(entry.status);
+  if (entry.url !== url) {
+    entry.url = url;
+    entry.bridgeReady = false;
+    setEntryWebuiStatus(entry, { runtimeId: active.id, status: "loading" });
+    void entry.view.webContents.loadURL(url).catch((err) => {
+      setEntryWebuiStatus(entry, {
+        runtimeId: active.id,
+        status: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+      console.error("Failed to load desktop WebUI view:", err);
+    });
+  }
+}
+function broadcastState() {
+  if (!shellView || shellView.webContents.isDestroyed()) return;
+  shellView.webContents.send(IPC.stateChanged, manager.snapshot());
+}
+function publishWebuiStatus(next) {
+  webuiStatus = next;
+  if (!shellView || shellView.webContents.isDestroyed()) return;
+  shellView.webContents.send(IPC.webuiStatusChanged, webuiStatus);
+}
+function setEntryWebuiStatus(entry, next) {
+  const previousPrefs = entry.status.prefs;
+  entry.status = {
+    ...next,
+    prefs: next.prefs ?? entry.status.prefs,
+    pendingCommands: entry.pendingCommands.length || void 0
+  };
+  if (activeWebuiRuntimeId === entry.runtimeId) {
+    publishWebuiStatus(entry.status);
+    if (menuRelevantPrefsChanged(previousPrefs, entry.status.prefs)) {
+      configureApplicationMenu();
+    }
+  }
+}
+function menuRelevantPrefsChanged(previous, next) {
+  return previous?.yolo !== next?.yolo || previous?.nextPrediction !== next?.nextPrediction || previous?.contextAutoCompact !== next?.contextAutoCompact;
+}
+function runtimeWsUrlOrThrow(runtimeId) {
+  const wsUrl = manager.getRuntimeWsUrlWithToken(runtimeId);
+  if (!wsUrl) throw new Error(`Runtime not found: ${runtimeId}`);
+  return wsUrl;
+}
+function broadcastLocaleToEmbeddedWebuis(locale) {
+  for (const entry of webuiViews.values()) {
+    if (entry.view.webContents.isDestroyed()) continue;
+    try {
+      entry.view.webContents.send(IPC.webuiLocaleChanged, locale);
+    } catch {
+    }
+  }
+}
+function registerIpc() {
+  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) => {
+    return openProjectSession(runtimeId);
+  });
+  ipcMain.handle(IPC.openProject, async (_event, requestedRoot) => {
+    return openProject(requestedRoot);
+  });
+  ipcMain.handle(IPC.registerProject, async (_event, requestedRoot) => {
+    return registerProject(requestedRoot);
+  });
+  ipcMain.handle(IPC.unregisterProject, async (_event, root) => {
+    return unregisterProject(root);
+  });
+  ipcMain.handle(IPC.activateRuntime, async (_event, id) => {
+    return activateRuntime(id);
+  });
+  ipcMain.handle(IPC.closeRuntime, async (_event, id) => {
+    return 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) await 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 sanitized = sanitizeWebuiPrefs(prefs);
+    if (Object.keys(sanitized).length === 0) return;
+    setEntryWebuiStatus(entry, {
+      ...entry.status,
+      prefs: { ...entry.status.prefs ?? {}, ...sanitized }
+    });
+  });
+  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);
+    }
+  );
+}
+function findWebuiEntryBySenderId(senderId) {
+  return Array.from(webuiViews.values()).find(
+    (candidate) => candidate.view.webContents.id === senderId
+  );
+}
+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);
+}
+async function dispatchWebuiCommand(commandInput) {
+  const command = normalizeDesktopWebuiCommand(commandInput);
+  if (!command) return false;
+  const entry = getActiveWebuiEntry();
+  if (!entry?.url) return false;
+  if (entry.status.status !== "ready") {
+    if (!entry.view.webContents.isLoading() && entry.status.status !== "error") {
+      return dispatchWebuiCommandNow(entry, command);
+    }
+    queueWebuiCommand(entry, command);
+    schedulePendingWebuiFlush(entry);
+    return true;
+  }
+  if (!await isWebuiCommandBridgeReady(entry)) {
+    if (!entry.view.webContents.isLoading()) {
+      return dispatchWebuiCommandNow(entry, command);
+    }
+    queueWebuiCommand(entry, command);
+    schedulePendingWebuiFlush(entry);
+    return true;
+  }
+  return dispatchWebuiCommandNow(entry, command);
+}
+async function reloadActiveWebuiView() {
+  const entry = getActiveWebuiEntry();
+  if (!entry?.url) return false;
+  entry.bridgeReady = false;
+  setEntryWebuiStatus(entry, { runtimeId: entry.runtimeId, status: "loading" });
+  return entry.view.webContents.loadURL(entry.url).then(() => true).catch((err) => {
+    setEntryWebuiStatus(entry, {
+      runtimeId: entry.runtimeId,
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    console.error("Failed to reload desktop WebUI view:", err);
+    return false;
+  });
+}
+async function dispatchWebuiCommandNow(entry, command) {
+  if (webuiViews.get(entry.runtimeId) !== entry || !entry.url) return false;
+  const requestId = nextWebuiCommandRequestId(entry.runtimeId);
+  const commandWithRequestId = { ...command, requestId };
+  return new Promise((resolve3) => {
+    const fallbackTimer = setTimeout(() => {
+      const pending = pendingWebuiCommandAcks.get(requestId);
+      if (!pending) return;
+      sendWebuiCommandDomFallback(entry, commandWithRequestId);
+    }, WEBUI_COMMAND_FALLBACK_MS);
+    const timer = setTimeout(() => {
+      settlePendingWebuiCommandAck(requestId, false);
+    }, WEBUI_COMMAND_ACK_TIMEOUT_MS);
+    pendingWebuiCommandAcks.set(requestId, {
+      runtimeId: entry.runtimeId,
+      timer,
+      fallbackTimer,
+      resolve: resolve3
+    });
+    try {
+      entry.view.webContents.send(IPC.webuiCommand, commandWithRequestId);
+      if (activeWebuiRuntimeId === entry.runtimeId) {
+        entry.view.webContents.focus();
+      }
+    } catch {
+      settlePendingWebuiCommandAck(requestId, false);
+    }
+  });
+}
+function sendWebuiCommandDomFallback(entry, command) {
+  if (webuiViews.get(entry.runtimeId) !== entry || entry.view.webContents.isDestroyed()) return;
+  void entry.view.webContents.executeJavaScript(buildWebuiCommandFallbackScript(command), true).catch(() => void 0);
+}
+function nextWebuiCommandRequestId(runtimeId) {
+  webuiCommandSequence += 1;
+  return `${runtimeId}:${Date.now()}:${webuiCommandSequence}`;
+}
+function settlePendingWebuiCommandAck(requestId, handled) {
+  const pending = pendingWebuiCommandAcks.get(requestId);
+  if (!pending) return;
+  pendingWebuiCommandAcks.delete(requestId);
+  clearTimeout(pending.timer);
+  if (pending.fallbackTimer) clearTimeout(pending.fallbackTimer);
+  if (handled) {
+    const entry = webuiViews.get(pending.runtimeId);
+    if (entry) {
+      entry.bridgeReady = true;
+      setEntryWebuiStatus(entry, { ...entry.status, status: "ready" });
+    }
+  }
+  pending.resolve(handled);
+}
+function settlePendingWebuiCommandAcksForRuntime(runtimeId, handled) {
+  for (const [requestId, pending] of [...pendingWebuiCommandAcks]) {
+    if (pending.runtimeId === runtimeId) {
+      settlePendingWebuiCommandAck(requestId, handled);
+    }
+  }
+}
+async function flushPendingWebuiCommands(entry) {
+  if (webuiViews.get(entry.runtimeId) !== entry) return;
+  if (entry.pendingCommands.length === 0) return;
+  if (!await isWebuiCommandBridgeReady(entry)) {
+    entry.pendingFlushAttempts += 1;
+    const canFallback = !entry.view.webContents.isLoading() && entry.pendingFlushAttempts >= 4;
+    if (!canFallback && entry.pendingFlushAttempts <= MAX_PENDING_FLUSH_ATTEMPTS) {
+      schedulePendingWebuiFlush(entry);
+      setEntryWebuiStatus(entry, entry.status);
+      return;
+    }
+    if (!canFallback) {
+      entry.pendingCommands.length = 0;
+      setEntryWebuiStatus(entry, {
+        runtimeId: entry.runtimeId,
+        status: "error",
+        error: "WebUI command bridge did not become ready."
+      });
+      return;
+    }
+  }
+  entry.pendingFlushAttempts = 0;
+  const commands = entry.pendingCommands.splice(0, entry.pendingCommands.length);
+  setEntryWebuiStatus(entry, entry.status);
+  for (const command of commands) {
+    await dispatchWebuiCommandNow(entry, command).catch(() => void 0);
+  }
+}
+function schedulePendingWebuiFlush(entry) {
+  if (entry.pendingFlushTimer) return;
+  entry.pendingFlushTimer = setTimeout(() => {
+    entry.pendingFlushTimer = null;
+    void flushPendingWebuiCommands(entry);
+  }, 250);
+}
+async function isWebuiCommandBridgeReady(entry) {
+  if (webuiViews.get(entry.runtimeId) !== entry || !entry.url) return false;
+  return entry.bridgeReady;
+}
+function queueWebuiCommand(entry, command) {
+  entry.pendingCommands.push(command);
+  if (entry.pendingCommands.length > MAX_PENDING_WEBUI_COMMANDS) {
+    entry.pendingCommands.splice(0, entry.pendingCommands.length - MAX_PENDING_WEBUI_COMMANDS);
+  }
+  entry.pendingFlushAttempts = 0;
+  setEntryWebuiStatus(entry, entry.status);
+}
+function getActiveWebuiEntry() {
+  const activeId = manager.snapshot().activeRuntimeId;
+  return activeId ? webuiViews.get(activeId) : void 0;
+}
+function attachWebuiEntry(entry) {
+  if (!mainWindow) return;
+  if (entry.attached) return;
+  mainWindow.contentView.addChildView(entry.view);
+  entry.attached = true;
+}
+function pruneWebuiEntries(runtimeIds) {
+  const live = new Set(runtimeIds);
+  for (const [id, entry] of webuiViews) {
+    if (!live.has(id)) {
+      disposeWebuiEntry(entry);
+    }
+  }
+}
+function disposeWebuiEntry(entry) {
+  webuiViews.delete(entry.runtimeId);
+  entry.pendingCommands.length = 0;
+  settlePendingWebuiCommandAcksForRuntime(entry.runtimeId, false);
+  if (entry.pendingFlushTimer) {
+    clearTimeout(entry.pendingFlushTimer);
+    entry.pendingFlushTimer = null;
+  }
+  if (mainWindow && entry.attached) {
+    mainWindow.contentView.removeChildView(entry.view);
+  }
+  entry.attached = false;
+  if (!entry.view.webContents.isDestroyed()) {
+    entry.view.webContents.close();
+  }
+  if (activeWebuiRuntimeId === entry.runtimeId) activeWebuiRuntimeId = null;
+}
+function disposeAllWebuiEntries() {
+  for (const entry of Array.from(webuiViews.values())) {
+    disposeWebuiEntry(entry);
+  }
+  webuiViews.clear();
+}
+async function openProject(requestedRoot) {
+  let projectRoot = requestedRoot;
+  if (!projectRoot) {
+    const result = await dialog.showOpenDialog({
+      title: tMain("openProject"),
+      properties: ["openDirectory"]
+    });
+    projectRoot = result.filePaths[0];
+  }
+  if (!projectRoot) return manager.snapshot();
+  await manager.openProject(projectRoot);
+  syncActiveWebuiView();
+  broadcastState();
+  return manager.snapshot();
+}
+async function registerProject(requestedRoot) {
+  let projectRoot = requestedRoot;
+  if (!projectRoot) {
+    const result = await dialog.showOpenDialog({
+      title: tMain("registerProject"),
+      properties: ["openDirectory"]
+    });
+    projectRoot = result.filePaths[0];
+  }
+  if (!projectRoot) return manager.snapshot();
+  await manager.registerProject(projectRoot);
+  broadcastState();
+  return manager.snapshot();
+}
+async function unregisterProject(root) {
+  if (!root || typeof root !== "string") return manager.snapshot();
+  await manager.unregisterProject(root);
+  broadcastState();
+  return manager.snapshot();
+}
+async function openProjectSession(runtimeId) {
+  const snapshot = manager.snapshot();
+  const runtime = (runtimeId ? snapshot.runtimes.find((candidate) => candidate.id === runtimeId) : void 0) ?? snapshot.runtimes.find((candidate) => candidate.id === snapshot.activeRuntimeId);
+  if (runtime?.kind !== "project") {
+    return openProject();
+  }
+  await manager.openProject(runtime.root, { forceNew: true });
+  syncActiveWebuiView();
+  broadcastState();
+  return manager.snapshot();
+}
+async function openSettings() {
+  const snapshot = manager.snapshot();
+  const active = snapshot.runtimes.find((runtime) => runtime.id === snapshot.activeRuntimeId);
+  if (!active || active.kind === "global-settings" || active.status !== "running") {
+    const root = desktopSettingsWorkspaceRoot();
+    await fs3.mkdir(root, { recursive: true });
+    await manager.openProject(root, {
+      name: "Global Settings",
+      kind: "global-settings",
+      touchRecent: false
+    });
+    syncActiveWebuiView();
+    broadcastState();
+  }
+  await dispatchWebuiCommand({ view: "settings" });
+  return manager.snapshot();
+}
+async function activateRuntime(id) {
+  await manager.activateRuntime(id);
+  syncActiveWebuiView();
+  broadcastState();
+  return manager.snapshot();
+}
+async function closeRuntime(id) {
+  bridge.close(id);
+  await manager.closeRuntime(id);
+  const entry = webuiViews.get(id);
+  if (entry) disposeWebuiEntry(entry);
+  syncActiveWebuiView();
+  broadcastState();
+  return manager.snapshot();
+}
+async function restoreLastWorkspace() {
+  await manager.restoreLastWorkspace();
+  syncActiveWebuiView();
+  broadcastState();
+}
+function activeRuntimeId() {
+  return manager.snapshot().activeRuntimeId;
+}
+function buildProjectsMenu(runtimes, actions) {
+  const projectGroups = groupProjectRuntimesForMenu(runtimes);
+  const menu = [
+    {
+      label: tMain("openProjectEllipsis"),
+      accelerator: "CmdOrCtrl+O",
+      click: () => void openProject()
+    },
+    { label: tMain("registerProjectEllipsis"), click: () => void registerProject() },
+    { type: "separator" }
+  ];
+  if (projectGroups.length === 0) {
+    menu.push({ label: tMain("noOpenProjectSessions"), enabled: false });
+    return menu;
+  }
+  for (const group of projectGroups) {
+    menu.push({
+      label: group.name,
+      submenu: [
+        {
+          label: tMain("newSession"),
+          click: () => actions.newSession(group.sessions[0]?.id ?? ""),
+          enabled: Boolean(group.sessions[0])
+        },
+        {
+          label: tMain("revealProjectFolder"),
+          click: () => actions.reveal(group.sessions[0]?.id ?? ""),
+          enabled: Boolean(group.sessions[0])
+        },
+        { type: "separator" },
+        ...group.sessions.map((runtime, index) => buildSessionMenu(runtime, index + 1, actions))
+      ]
+    });
+  }
+  return menu;
+}
+function buildSessionMenu(runtime, index, actions) {
+  const running = runtime.status === "running";
+  const label = `${tMain("session")} ${index} \xB7 ${runtime.status}`;
+  return {
+    label,
+    submenu: [
+      {
+        label: tMain("quickView"),
+        click: () => actions.activate(runtime.id)
+      },
+      {
+        label: "WebUI",
+        enabled: running,
+        submenu: [
+          {
+            label: tMain("chat"),
+            click: () => actions.activateAndNavigate(runtime.id, { activity: "chat", view: "chat" })
+          },
+          {
+            label: tMain("focusPrompt"),
+            click: () => actions.activateAndNavigate(runtime.id, { action: "focus-chat" })
+          },
+          {
+            label: tMain("terminal"),
+            click: () => actions.activateAndNavigate(runtime.id, { terminal: "toggle" })
+          },
+          {
+            label: tMain("newTerminal"),
+            click: () => actions.activateAndNavigate(runtime.id, { terminal: "new" })
+          },
+          { type: "separator" },
+          {
+            label: tMain("files"),
+            click: () => actions.activateAndNavigate(runtime.id, { activity: "files", view: "files" })
+          },
+          {
+            label: tMain("changes"),
+            click: () => actions.activateAndNavigate(runtime.id, { activity: "changes", view: "changes" })
+          },
+          {
+            label: tMain("sessions"),
+            click: () => actions.activateAndNavigate(runtime.id, { view: "sessions" })
+          },
+          {
+            label: tMain("fleetHQ"),
+            click: () => actions.activateAndNavigate(runtime.id, { activity: "officemap", view: "officemap" })
+          },
+          {
+            label: tMain("settings"),
+            click: () => actions.activateAndNavigate(runtime.id, { view: "settings" })
+          },
+          { type: "separator" },
+          {
+            label: tMain("commandPalette"),
+            click: () => actions.activateAndNavigate(runtime.id, { action: "open-command-palette" })
+          },
+          {
+            label: tMain("modelSwitcher"),
+            click: () => actions.activateAndNavigate(runtime.id, { action: "open-model-switcher" })
+          }
+        ]
+      },
+      { type: "separator" },
+      {
+        label: tMain("openInBrowser"),
+        enabled: running,
+        click: () => actions.openBrowser(runtime.id)
+      },
+      {
+        label: tMain("reloadWebui"),
+        enabled: running,
+        click: () => actions.reload(runtime.id)
+      },
+      {
+        label: tMain("closeSession"),
+        click: () => actions.close(runtime.id)
+      }
+    ]
+  };
+}
+function groupProjectRuntimesForMenu(runtimes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const runtime of runtimes) {
+    if (runtime.kind !== "project") continue;
+    const key = normalizeMenuRoot(runtime.root);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.sessions.push(runtime);
+      continue;
+    }
+    groups.set(key, {
+      key,
+      name: path3.basename(runtime.root) || runtime.name,
+      root: runtime.root,
+      sessions: [runtime]
+    });
+  }
+  return [...groups.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function normalizeMenuRoot(root) {
+  return path3.resolve(root).replace(/\\/g, "/").replace(/\/+$/g, "").toLowerCase();
+}
+function configureApplicationMenu() {
+  const navigate = (command) => {
+    void dispatchWebuiCommand(command);
+  };
+  const activateAndNavigate = (runtimeId, command) => {
+    void activateRuntime(runtimeId).then(() => dispatchWebuiCommand(command));
+  };
+  const reloadRuntimeWebui = (runtimeId) => {
+    void activateRuntime(runtimeId).then(() => reloadActiveWebuiView());
+  };
+  const snapshot = manager.snapshot();
+  const active = snapshot.runtimes.find((runtime) => runtime.id === snapshot.activeRuntimeId);
+  const hasActiveRuntime = Boolean(active);
+  const hasActiveWebui = active?.status === "running";
+  const hasActiveProjectWebui = hasActiveWebui && active?.kind === "project";
+  const activeWebuiPrefs = active ? webuiViews.get(active.id)?.status.prefs : void 0;
+  const yoloChecked = activeWebuiPrefs?.yolo === true;
+  const nextPredictionChecked = activeWebuiPrefs?.nextPrediction === true;
+  const contextAutoCompactChecked = activeWebuiPrefs?.contextAutoCompact === true;
+  const webuiItem = (item) => ({
+    ...item,
+    enabled: item.enabled ?? hasActiveWebui
+  });
+  const template = [
+    {
+      label: tMain("file"),
+      submenu: [
+        {
+          label: tMain("openProjectEllipsis"),
+          accelerator: "CmdOrCtrl+O",
+          click: () => void openProject()
+        },
+        { label: tMain("registerProjectEllipsis"), click: () => void registerProject() },
+        {
+          label: tMain("removeActiveFromRegistry"),
+          enabled: hasActiveProjectWebui,
+          click: () => {
+            if (active?.kind === "project") void unregisterProject(active.root);
+          }
+        },
+        { type: "separator" },
+        {
+          label: tMain("newSessionForActive"),
+          accelerator: "CmdOrCtrl+N",
+          enabled: hasActiveProjectWebui,
+          click: () => void openProjectSession(active?.id)
+        },
+        {
+          label: tMain("settings"),
+          accelerator: "CmdOrCtrl+,",
+          click: () => {
+            if (hasActiveWebui) navigate({ view: "settings" });
+            else void openSettings();
+          }
+        },
+        { type: "separator" },
+        {
+          label: tMain("closeActiveRuntime"),
+          accelerator: "CmdOrCtrl+W",
+          enabled: hasActiveRuntime,
+          click: () => {
+            const id = activeRuntimeId();
+            if (id) void closeRuntime(id);
+          }
+        },
+        { type: "separator" },
+        { role: process.platform === "darwin" ? "close" : "quit" }
+      ]
+    },
+    {
+      label: tMain("projects"),
+      submenu: buildProjectsMenu(snapshot.runtimes, {
+        activate: (runtimeId) => void activateRuntime(runtimeId),
+        activateAndNavigate,
+        newSession: (runtimeId) => void openProjectSession(runtimeId),
+        openBrowser: (runtimeId) => {
+          const url = manager.getRuntimeUrlWithToken(runtimeId);
+          if (url) safeOpenExternal(url);
+        },
+        reload: reloadRuntimeWebui,
+        close: (runtimeId) => void closeRuntime(runtimeId),
+        reveal: (runtimeId) => {
+          const runtime = manager.getRuntime(runtimeId);
+          if (runtime) void shell.openPath(runtime.root);
+        }
+      })
+    },
+    {
+      label: tMain("workspace"),
+      submenu: [
+        webuiItem({
+          label: tMain("openChat"),
+          accelerator: "CmdOrCtrl+1",
+          click: () => navigate({ activity: "chat", view: "chat" })
+        }),
+        webuiItem({
+          label: tMain("focusPrompt"),
+          accelerator: "CmdOrCtrl+/",
+          click: () => navigate({ action: "focus-chat" })
+        }),
+        webuiItem({
+          label: tMain("toggleTerminal"),
+          accelerator: "CmdOrCtrl+`",
+          click: () => navigate({ terminal: "toggle" })
+        }),
+        webuiItem({ label: tMain("newTerminal"), click: () => navigate({ terminal: "new" }) }),
+        { type: "separator" },
+        webuiItem({
+          label: tMain("commandPalette"),
+          accelerator: "CmdOrCtrl+K",
+          click: () => navigate({ action: "open-command-palette" })
+        }),
+        webuiItem({
+          label: tMain("quickModelSwitcher"),
+          accelerator: "CmdOrCtrl+M",
+          click: () => navigate({ action: "open-model-switcher" })
+        }),
+        webuiItem({
+          type: "checkbox",
+          label: tMain("yoloMode"),
+          checked: yoloChecked,
+          accelerator: "CmdOrCtrl+Shift+Y",
+          click: () => navigate({ pref: { key: "yolo", toggle: true } })
+        }),
+        webuiItem({
+          type: "checkbox",
+          label: tMain("nextPrediction"),
+          checked: nextPredictionChecked,
+          click: () => navigate({ pref: { key: "nextPrediction", toggle: true } })
+        }),
+        webuiItem({
+          type: "checkbox",
+          label: tMain("contextAutoCompact"),
+          checked: contextAutoCompactChecked,
+          click: () => navigate({ pref: { key: "contextAutoCompact", toggle: true } })
+        }),
+        { type: "separator" },
+        webuiItem({
+          label: tMain("reloadActiveWebui"),
+          accelerator: "CmdOrCtrl+Shift+R",
+          click: () => void reloadActiveWebuiView()
+        })
+      ]
+    },
+    {
+      label: tMain("view"),
+      submenu: [
+        {
+          type: "checkbox",
+          label: tMain("compactDesktopSidebar"),
+          accelerator: "CmdOrCtrl+B",
+          checked: shellSidebarCollapsed,
+          click: () => setShellSidebarCollapsed(!shellSidebarCollapsed)
+        },
+        { type: "separator" },
+        { role: "reload" },
+        { role: "toggleDevTools" },
+        { type: "separator" },
+        { role: "resetZoom" },
+        { role: "zoomIn" },
+        { role: "zoomOut" },
+        { type: "separator" },
+        { role: "togglefullscreen" }
+      ]
+    }
+  ];
+  Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+manager.on("changed", () => {
+  configureApplicationMenu();
+  syncActiveWebuiView();
+  broadcastState();
+});
+ipcMain.on(IPC.setLocale, (_event, locale) => {
+  setMainLocale(locale);
+  configureApplicationMenu();
+  broadcastLocaleToEmbeddedWebuis(locale);
+  void writeUiLocale(locale);
+});
+watchProviderConfig(
+  desktopConfigPaths.globalConfigPath,
+  desktopConfigPaths.vault,
+  (snapshot) => {
+    if (snapshot.uiLocale === void 0) return;
+    setMainLocale(snapshot.uiLocale);
+    configureApplicationMenu();
+    shellView?.webContents.send(IPC.localeChanged, snapshot.uiLocale);
+    broadcastLocaleToEmbeddedWebuis(snapshot.uiLocale);
+  },
+  { warn: (m) => console.warn(`Config watcher: ${m}`) }
+);
+bridge.on("changed", (conversation) => {
+  shellView?.webContents.send(IPC.conversationChanged, conversation);
+});
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") app.quit();
+});
+app.on("before-quit", (event) => {
+  if (quittingAfterCleanup) return;
+  event.preventDefault();
+  quittingAfterCleanup = true;
+  if (saveWindowStateTimer) {
+    clearTimeout(saveWindowStateTimer);
+    saveWindowStateTimer = null;
+  }
+  bridge.closeAll();
+  void saveWindowState().catch(() => void 0).finally(() => manager.closeAll({ persistWorkspace: false }).finally(() => app.quit()));
+});
+app.whenReady().then(async () => {
+  registerIpc();
+  await createWindow();
+  app.on("activate", () => {
+    if (mainWindow === null) void createWindow();
+  });
+}).catch((err) => {
+  console.error(err);
+  app.exit(1);
+});
+function sameOrigin(candidate, base) {
+  if (!base) return false;
+  try {
+    const candidateUrl = new URL(candidate);
+    const baseUrl = new URL(base);
+    return candidateUrl.origin === baseUrl.origin;
+  } catch {
+    return false;
+  }
+}
+function desktopSettingsWorkspaceRoot() {
+  return path3.join(wstackGlobalRoot3(), "desktop", "global-settings-workspace");
+}
+function validatedWindowState(state) {
+  if (!state) return null;
+  if (state.width < MIN_WINDOW_WIDTH2 || state.height < MIN_WINDOW_HEIGHT2) return null;
+  if (state.x === void 0 || state.y === void 0) return state;
+  const candidate = {
+    x: state.x,
+    y: state.y,
+    width: state.width,
+    height: state.height
+  };
+  const visibleOnSomeDisplay = screen.getAllDisplays().some((display) => {
+    const area = display.workArea;
+    return rectanglesIntersect(candidate, area);
+  });
+  return visibleOnSomeDisplay ? state : null;
+}
+function rectanglesIntersect(left, right) {
+  return left.x < right.x + right.width && left.x + left.width > right.x && left.y < right.y + right.height && left.y + left.height > right.y;
+}
+//# sourceMappingURL=main.js.map