@runfusion/fusion 0.52.0 → 0.53.1

package/dist/desktop/main.js

@@ -0,0 +1,1661 @@
+// src/main.ts
+import { app as app6, BrowserWindow as BrowserWindow4, nativeImage as nativeImage2, screen, Tray as Tray2 } from "electron";
+import { join as join4, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/deep-link.ts
+import { app } from "electron";
+var DEEP_LINK_EVENT = "deep-link";
+var FUSION_SCHEME = "fusion:";
+function registerDeepLinkProtocol() {
+  try {
+    const isRegistered = app.setAsDefaultProtocolClient("fusion");
+    if (!isRegistered) {
+      console.warn("[desktop/deep-link] Failed to register fusion:// protocol");
+      return;
+    }
+    console.log("[desktop/deep-link] Registered fusion:// protocol handler");
+  } catch (error) {
+    console.error("[desktop/deep-link] Error while registering fusion:// protocol", error);
+  }
+}
+function parseDeepLink(rawUrl) {
+  if (!rawUrl) {
+    return null;
+  }
+  try {
+    const parsedUrl = new URL(rawUrl);
+    if (parsedUrl.protocol !== FUSION_SCHEME) {
+      return null;
+    }
+    const type = parsedUrl.hostname;
+    if (type !== "task" && type !== "project") {
+      return null;
+    }
+    const pathSegments = parsedUrl.pathname.split("/").filter((segment) => segment.length > 0);
+    const decodedId = pathSegments.length > 0 ? decodeURIComponent(pathSegments[0]) : "";
+    return {
+      type,
+      id: decodedId,
+      raw: rawUrl
+    };
+  } catch {
+    return null;
+  }
+}
+function handleDeepLink(mainWindow2, url) {
+  const parsed = parseDeepLink(url);
+  if (!parsed || parsed.type === "unknown") {
+    console.warn(`[desktop/deep-link] Ignoring unsupported deep link: ${url}`);
+    return;
+  }
+  if (!mainWindow2.isVisible()) {
+    mainWindow2.show();
+  }
+  if (mainWindow2.isMinimized()) {
+    mainWindow2.restore();
+  }
+  mainWindow2.focus();
+  mainWindow2.webContents.send(DEEP_LINK_EVENT, parsed);
+}
+function setupDeepLinkHandler(mainWindow2) {
+  const hasLock = app.requestSingleInstanceLock();
+  if (!hasLock) {
+    app.quit();
+    return;
+  }
+  app.on("open-url", (event, url) => {
+    event.preventDefault();
+    handleDeepLink(mainWindow2, url);
+  });
+  app.on("second-instance", (_event, argv) => {
+    const deepLink = argv.find((arg) => arg.startsWith("fusion://"));
+    if (!deepLink) {
+      return;
+    }
+    handleDeepLink(mainWindow2, deepLink);
+  });
+}
+
+// src/ipc.ts
+import { app as app5, ipcMain } from "electron";
+
+// src/native.ts
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  app as app2,
+  dialog,
+  Notification
+} from "electron";
+var MIN_VISIBLE_OVERLAP_PX = 64;
+function clampWindowStateToVisibleDisplay(state, displays) {
+  if (state.x === void 0 || state.y === void 0) {
+    return state;
+  }
+  const windowLeft = state.x;
+  const windowTop = state.y;
+  const windowRight = state.x + state.width;
+  const windowBottom = state.y + state.height;
+  const hasSufficientOverlap = displays.some(({ workArea }) => {
+    const displayLeft = workArea.x;
+    const displayTop = workArea.y;
+    const displayRight = workArea.x + workArea.width;
+    const displayBottom = workArea.y + workArea.height;
+    const overlapWidth = Math.max(0, Math.min(windowRight, displayRight) - Math.max(windowLeft, displayLeft));
+    const overlapHeight = Math.max(0, Math.min(windowBottom, displayBottom) - Math.max(windowTop, displayTop));
+    return overlapWidth >= MIN_VISIBLE_OVERLAP_PX && overlapHeight >= MIN_VISIBLE_OVERLAP_PX;
+  });
+  if (hasSufficientOverlap) {
+    return state;
+  }
+  return {
+    width: state.width,
+    height: state.height,
+    isMaximized: state.isMaximized
+  };
+}
+var SHELL_HANDOFF_QUERY = {
+  shellKind: "shellKind",
+  shellMode: "shellMode",
+  profileId: "profileId",
+  serverBaseUrl: "serverBaseUrl",
+  serverLabel: "serverLabel",
+  token: "token",
+  canOpenConnectionManager: "shellCanOpenConnectionManager"
+};
+var DEFAULT_WINDOW_STATE = {
+  width: 1280,
+  height: 900,
+  isMaximized: false
+};
+function generateSettingsExportFilename(date = /* @__PURE__ */ new Date()) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  return `fusion-settings-${year}-${month}-${day}-${hours}${minutes}${seconds}.json`;
+}
+function getWindowStatePath() {
+  return join(app2.getPath("userData"), "window-state.json");
+}
+function getDesktopLaunchModePath() {
+  return join(app2.getPath("userData"), "desktop-launch-mode.json");
+}
+function isValidWindowState(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  const hasValidPosition = (candidate.x === void 0 || typeof candidate.x === "number") && (candidate.y === void 0 || typeof candidate.y === "number");
+  return hasValidPosition && typeof candidate.width === "number" && Number.isFinite(candidate.width) && typeof candidate.height === "number" && Number.isFinite(candidate.height) && typeof candidate.isMaximized === "boolean";
+}
+async function showExportSettingsDialog(parentWindow) {
+  const filename = generateSettingsExportFilename();
+  const defaultPath = join(app2.getPath("documents"), filename);
+  const dialogOptions = {
+    title: "Export Fusion Settings",
+    defaultPath,
+    filters: [{ name: "JSON Files", extensions: ["json"] }]
+  };
+  const result = parentWindow ? await dialog.showSaveDialog(parentWindow, dialogOptions) : await dialog.showSaveDialog(dialogOptions);
+  if (result.canceled || !result.filePath) {
+    return null;
+  }
+  return result.filePath;
+}
+async function showImportSettingsDialog(parentWindow) {
+  const dialogOptions = {
+    title: "Import Fusion Settings",
+    properties: ["openFile"],
+    filters: [{ name: "JSON Files", extensions: ["json"] }]
+  };
+  const result = parentWindow ? await dialog.showOpenDialog(parentWindow, dialogOptions) : await dialog.showOpenDialog(dialogOptions);
+  if (result.canceled || result.filePaths.length === 0) {
+    return null;
+  }
+  return result.filePaths[0] ?? null;
+}
+function showDesktopNotification(title, body, options = {}) {
+  if (!Notification.isSupported()) {
+    console.warn("[desktop/native] Notifications are not supported in this environment");
+    return;
+  }
+  try {
+    const notification = new Notification({
+      title,
+      body,
+      silent: options.silent
+    });
+    if (options.onClick) {
+      notification.on("click", options.onClick);
+    }
+    notification.show();
+  } catch (error) {
+    console.error("[desktop/native] Failed to display desktop notification", error);
+  }
+}
+var cachedAutoUpdater = null;
+var autoUpdaterLoadPromise = null;
+var listenersBound = false;
+var hasRunInitialUpdateCheck = false;
+var autoUpdaterWindow;
+var updateIntervalTimer = null;
+var updateIntervalDisposer = null;
+var updateIntervalWindow = null;
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+async function resolveAutoUpdater() {
+  if (cachedAutoUpdater) {
+    return cachedAutoUpdater;
+  }
+  if (!autoUpdaterLoadPromise) {
+    autoUpdaterLoadPromise = (async () => {
+      try {
+        const mod = await import("electron-updater");
+        const namedAutoUpdater = "autoUpdater" in mod ? mod.autoUpdater : void 0;
+        const autoUpdater = mod.default?.autoUpdater ?? namedAutoUpdater;
+        if (!autoUpdater) {
+          console.warn("[desktop/native] Auto-updater module loaded without autoUpdater export");
+          return null;
+        }
+        cachedAutoUpdater = autoUpdater;
+        return autoUpdater;
+      } catch (error) {
+        console.warn("[desktop/native] Auto-updater unavailable", error);
+        return null;
+      }
+    })();
+  }
+  return autoUpdaterLoadPromise;
+}
+function bindAutoUpdaterListeners(autoUpdater) {
+  if (listenersBound) {
+    return;
+  }
+  listenersBound = true;
+  autoUpdater.autoDownload = true;
+  autoUpdater.autoInstallOnAppQuit = true;
+  autoUpdater.on("update-available", (info) => {
+    showDesktopNotification("Fusion Update Available", "Update available \u2014 downloading in background", {
+      silent: true
+    });
+    autoUpdaterWindow?.webContents.send("update-available", info);
+  });
+  autoUpdater.on("update-downloaded", (info) => {
+    showDesktopNotification("Fusion Update Ready", "Update ready \u2014 will install on quit", {
+      silent: true
+    });
+    autoUpdaterWindow?.webContents.send("update-downloaded", info);
+  });
+  autoUpdater.on("update-not-available", (info) => {
+    showDesktopNotification("Fusion is up to date", "You're on the latest version", {
+      silent: true
+    });
+    autoUpdaterWindow?.webContents.send("update-not-available", info);
+  });
+  autoUpdater.on("error", (error) => {
+    const message = getErrorMessage(error);
+    console.error("[desktop/native] Auto-updater error", error);
+    autoUpdaterWindow?.webContents.send("update-error", { message });
+  });
+}
+function setupAutoUpdater(mainWindow2) {
+  if (mainWindow2) {
+    autoUpdaterWindow = mainWindow2;
+  }
+  void (async () => {
+    try {
+      const autoUpdater = await resolveAutoUpdater();
+      if (!autoUpdater) {
+        return;
+      }
+      bindAutoUpdaterListeners(autoUpdater);
+      if (hasRunInitialUpdateCheck) {
+        return;
+      }
+      hasRunInitialUpdateCheck = true;
+      await autoUpdater.checkForUpdates().catch((error) => {
+        console.error("[desktop/native] Auto-updater check failed", error);
+      });
+    } catch (error) {
+      console.warn("[desktop/native] Auto-updater setup failed", error);
+    }
+  })();
+}
+async function triggerUpdateCheck(mainWindow2) {
+  setupAutoUpdater(mainWindow2);
+  const autoUpdater = await resolveAutoUpdater();
+  if (!autoUpdater) {
+    return { status: "unavailable", reason: "updater_unavailable" };
+  }
+  try {
+    await autoUpdater.checkForUpdates();
+    return { status: "checking" };
+  } catch (error) {
+    return { status: "error", error: getErrorMessage(error) };
+  }
+}
+function startUpdateCheckInterval(mainWindow2, intervalMs = 4 * 60 * 60 * 1e3) {
+  autoUpdaterWindow = mainWindow2;
+  if (updateIntervalDisposer && updateIntervalWindow === mainWindow2) {
+    return updateIntervalDisposer;
+  }
+  if (updateIntervalTimer) {
+    clearInterval(updateIntervalTimer);
+    updateIntervalTimer = null;
+  }
+  updateIntervalWindow = mainWindow2;
+  updateIntervalTimer = setInterval(() => {
+    void triggerUpdateCheck(mainWindow2);
+  }, intervalMs);
+  updateIntervalDisposer = () => {
+    if (updateIntervalTimer) {
+      clearInterval(updateIntervalTimer);
+      updateIntervalTimer = null;
+    }
+    updateIntervalDisposer = null;
+    updateIntervalWindow = null;
+  };
+  return updateIntervalDisposer;
+}
+function normalizeServerBaseUrl(serverUrl) {
+  try {
+    const parsed = new URL(serverUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    return null;
+  }
+}
+function normalizeDesktopRemoteLaunch(settings) {
+  if (settings.desktopMode !== "remote" || !settings.activeProfileId) {
+    return null;
+  }
+  const activeProfile = settings.profiles.find((profile) => profile.id === settings.activeProfileId);
+  if (!activeProfile) {
+    return null;
+  }
+  const serverBaseUrl = normalizeServerBaseUrl(activeProfile.serverUrl);
+  if (!serverBaseUrl) {
+    return null;
+  }
+  return {
+    mode: "remote",
+    profileId: activeProfile.id,
+    serverBaseUrl,
+    ...activeProfile.name ? { serverLabel: activeProfile.name } : {},
+    ...activeProfile.authToken ? { authToken: activeProfile.authToken } : {}
+  };
+}
+function buildRemoteShellHandoffUrl(launch) {
+  const url = new URL(launch.serverBaseUrl);
+  url.searchParams.set(SHELL_HANDOFF_QUERY.shellKind, "desktop");
+  url.searchParams.set(SHELL_HANDOFF_QUERY.shellMode, "remote");
+  url.searchParams.set(SHELL_HANDOFF_QUERY.profileId, launch.profileId);
+  url.searchParams.set(SHELL_HANDOFF_QUERY.serverBaseUrl, launch.serverBaseUrl);
+  if (launch.serverLabel) {
+    url.searchParams.set(SHELL_HANDOFF_QUERY.serverLabel, launch.serverLabel);
+  }
+  if (launch.authToken) {
+    url.searchParams.set(SHELL_HANDOFF_QUERY.token, launch.authToken);
+  }
+  url.searchParams.set(SHELL_HANDOFF_QUERY.canOpenConnectionManager, "1");
+  return url.toString();
+}
+function isValidDesktopLaunchMode(value) {
+  return value === "choose" || value === "local" || value === "remote";
+}
+async function loadDesktopLaunchMode() {
+  const launchModePath = getDesktopLaunchModePath();
+  try {
+    const raw = await readFile(launchModePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && "mode" in parsed) {
+      const mode = parsed.mode;
+      if (isValidDesktopLaunchMode(mode)) {
+        return mode;
+      }
+    }
+    return "choose";
+  } catch {
+    return "choose";
+  }
+}
+async function saveDesktopLaunchMode(mode) {
+  const launchModePath = getDesktopLaunchModePath();
+  const tempPath = `${launchModePath}.tmp`;
+  await writeFile(tempPath, JSON.stringify({ mode }, null, 2), "utf-8");
+  await rename(tempPath, launchModePath);
+}
+async function loadWindowState() {
+  const statePath = getWindowStatePath();
+  try {
+    const raw = await readFile(statePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!isValidWindowState(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+}
+function saveWindowState(mainWindow2) {
+  if (mainWindow2.isDestroyed()) {
+    return;
+  }
+  const bounds = mainWindow2.getBounds();
+  const state = {
+    x: bounds.x,
+    y: bounds.y,
+    width: bounds.width,
+    height: bounds.height,
+    isMaximized: mainWindow2.isMaximized()
+  };
+  const statePath = getWindowStatePath();
+  const tempPath = `${statePath}.tmp`;
+  void writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8").then(() => rename(tempPath, statePath)).catch((error) => {
+    console.error("[desktop/native] Failed to save window state", error);
+  });
+}
+
+// src/tray.ts
+import path from "node:path";
+import {
+  app as app3,
+  Menu,
+  nativeImage
+} from "electron";
+var trayState = /* @__PURE__ */ new WeakMap();
+function toggleMainWindow(mainWindow2) {
+  if (mainWindow2.isVisible()) {
+    mainWindow2.hide();
+    return;
+  }
+  mainWindow2.show();
+  mainWindow2.focus();
+}
+function resolveEngineMenuLabel(engineStatus) {
+  return engineStatus === "running" ? "Pause Engine" : "Resume Engine";
+}
+function applyTrayMenu(tray2, state) {
+  const baseTemplate = buildTrayContextMenu({
+    isWindowVisible: state.mainWindow.isVisible(),
+    engineStatus: state.engineStatus
+  });
+  const contextTemplate = baseTemplate.map((item) => {
+    if (item.type === "separator") {
+      return item;
+    }
+    if (item.label === "Show Window" || item.label === "Hide Window") {
+      return {
+        ...item,
+        click: () => toggleMainWindow(state.mainWindow)
+      };
+    }
+    if (item.label === "Pause Engine" || item.label === "Resume Engine") {
+      return {
+        ...item,
+        click: () => {
+          if (state.engineStatus === "stopped") {
+            return;
+          }
+          state.engineStatus = state.engineStatus === "running" ? "paused" : "running";
+          applyTrayMenu(tray2, state);
+        }
+      };
+    }
+    return {
+      ...item,
+      click: () => {
+        state.isQuitting = true;
+        app3.quit();
+      }
+    };
+  });
+  tray2.setToolTip(getTrayTooltip(state.engineStatus));
+  tray2.setContextMenu(Menu.buildFromTemplate(contextTemplate));
+}
+function createTrayIcon() {
+  if (process.platform === "darwin") {
+    const iconPath2 = path.join(import.meta.dirname, "icons", "tray-32.png");
+    const retinaIcon = nativeImage.createFromPath(iconPath2);
+    return retinaIcon.resize({ width: 16, height: 16 });
+  }
+  const iconPath = path.join(import.meta.dirname, "icons", "tray-48.png");
+  return nativeImage.createFromPath(iconPath);
+}
+function buildTrayContextMenu(options) {
+  return [
+    {
+      label: options.isWindowVisible ? "Hide Window" : "Show Window"
+    },
+    {
+      type: "separator"
+    },
+    {
+      label: resolveEngineMenuLabel(options.engineStatus),
+      enabled: options.engineStatus !== "stopped"
+    },
+    {
+      type: "separator"
+    },
+    {
+      label: "Quit Fusion"
+    }
+  ];
+}
+function getTrayTooltip(status) {
+  switch (status) {
+    case "paused":
+      return "Fusion \u2014 Paused";
+    case "stopped":
+      return "Fusion \u2014 Stopped";
+    case "running":
+    default:
+      return "Fusion \u2014 Running";
+  }
+}
+function setupTray(mainWindow2, tray2) {
+  const state = {
+    mainWindow: mainWindow2,
+    engineStatus: "running",
+    isQuitting: false
+  };
+  trayState.set(tray2, state);
+  tray2.setImage(createTrayIcon());
+  applyTrayMenu(tray2, state);
+  tray2.on("click", () => {
+    toggleMainWindow(mainWindow2);
+  });
+  mainWindow2.on("show", () => {
+    applyTrayMenu(tray2, state);
+  });
+  mainWindow2.on("hide", () => {
+    applyTrayMenu(tray2, state);
+  });
+  mainWindow2.on("close", (event) => {
+    if (state.isQuitting) {
+      return;
+    }
+    event.preventDefault();
+    mainWindow2.hide();
+  });
+  app3.on("before-quit", () => {
+    state.isQuitting = true;
+  });
+  return tray2;
+}
+function updateTrayStatus(tray2, status) {
+  const state = trayState.get(tray2);
+  if (!state) {
+    tray2.setToolTip(getTrayTooltip(status));
+    const menu = Menu.buildFromTemplate(
+      buildTrayContextMenu({
+        isWindowVisible: false,
+        engineStatus: status
+      })
+    );
+    tray2.setContextMenu(menu);
+    return;
+  }
+  state.engineStatus = status;
+  applyTrayMenu(tray2, state);
+}
+
+// src/shell-settings.ts
+import { readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { join as join2 } from "node:path";
+import { app as app4 } from "electron";
+var DEFAULT_SETTINGS = {
+  desktopMode: null,
+  hasCompletedModeSelection: false,
+  activeProfileId: null,
+  profiles: []
+};
+function getSettingsPath() {
+  return join2(app4.getPath("userData"), "shell-connections.json");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeDesktopMode(value) {
+  return value === "local" || value === "remote" ? value : null;
+}
+function normalizeServerUrl(serverUrl) {
+  const normalized = serverUrl.trim().replace(/\/$/, "");
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error("Server URL must be a valid absolute URL");
+  }
+  if (!/^https?:$/.test(parsed.protocol)) {
+    throw new Error("Server URL must use http or https");
+  }
+  return normalized;
+}
+function normalizeProfileName(name) {
+  const normalized = name.trim().replace(/\s+/g, " ");
+  return normalized.length > 0 ? normalized : "Remote Server";
+}
+function profileBaseId(name, serverUrl) {
+  const hash = createHash("sha1").update(`${name}|${serverUrl}`).digest("hex").slice(0, 10);
+  return `profile_${hash}`;
+}
+function ensureUniqueProfileName(name, profiles, skipId) {
+  const used = new Set(
+    profiles.filter((profile) => profile.id !== skipId).map((profile) => profile.name.toLocaleLowerCase())
+  );
+  if (!used.has(name.toLocaleLowerCase())) {
+    return name;
+  }
+  let suffix = 2;
+  let candidate = `${name} (${suffix})`;
+  while (used.has(candidate.toLocaleLowerCase())) {
+    suffix += 1;
+    candidate = `${name} (${suffix})`;
+  }
+  return candidate;
+}
+function createDeterministicProfileId(name, serverUrl, profiles, skipId) {
+  const used = new Set(profiles.filter((profile) => profile.id !== skipId).map((profile) => profile.id));
+  const base = profileBaseId(name, serverUrl);
+  if (!used.has(base)) {
+    return base;
+  }
+  let suffix = 2;
+  let candidate = `${base}_${suffix}`;
+  while (used.has(candidate)) {
+    suffix += 1;
+    candidate = `${base}_${suffix}`;
+  }
+  return candidate;
+}
+function normalizeProfileRecord(input, fallbackIndex) {
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+  const candidate = input;
+  if (typeof candidate.serverUrl !== "string") {
+    return null;
+  }
+  let serverUrl;
+  try {
+    serverUrl = normalizeServerUrl(candidate.serverUrl);
+  } catch {
+    return null;
+  }
+  const name = normalizeProfileName(typeof candidate.name === "string" ? candidate.name : "");
+  const createdAt = typeof candidate.createdAt === "string" && candidate.createdAt.length > 0 ? candidate.createdAt : nowIso();
+  const updatedAt = typeof candidate.updatedAt === "string" && candidate.updatedAt.length > 0 ? candidate.updatedAt : createdAt;
+  return {
+    id: typeof candidate.id === "string" && candidate.id.length > 0 ? candidate.id : `profile_imported_${fallbackIndex}`,
+    name,
+    serverUrl,
+    authToken: typeof candidate.authToken === "string" ? candidate.authToken : null,
+    createdAt,
+    updatedAt,
+    lastUsedAt: typeof candidate.lastUsedAt === "string" ? candidate.lastUsedAt : null
+  };
+}
+function normalize(input) {
+  if (!input || typeof input !== "object") {
+    return { ...DEFAULT_SETTINGS };
+  }
+  const candidate = input;
+  const desktopMode = normalizeDesktopMode(candidate.desktopMode);
+  const inferredCompleted = desktopMode !== null;
+  const profiles = [];
+  const profileSource = Array.isArray(candidate.profiles) ? candidate.profiles : [];
+  for (const [index, profileValue] of profileSource.entries()) {
+    const normalizedProfile = normalizeProfileRecord(profileValue, index);
+    if (!normalizedProfile) {
+      continue;
+    }
+    const uniqueName = ensureUniqueProfileName(normalizedProfile.name, profiles);
+    const idAlreadyUsed = profiles.some((profile) => profile.id === normalizedProfile.id);
+    const id = idAlreadyUsed ? createDeterministicProfileId(uniqueName, normalizedProfile.serverUrl, profiles) : normalizedProfile.id;
+    profiles.push({ ...normalizedProfile, name: uniqueName, id });
+  }
+  const persistedActiveId = typeof candidate.activeProfileId === "string" ? candidate.activeProfileId : null;
+  const activeProfileId = persistedActiveId && profiles.some((profile) => profile.id === persistedActiveId) ? persistedActiveId : null;
+  return {
+    desktopMode,
+    hasCompletedModeSelection: typeof candidate.hasCompletedModeSelection === "boolean" ? candidate.hasCompletedModeSelection : inferredCompleted,
+    activeProfileId,
+    profiles
+  };
+}
+function buildSavedProfile(settings, input) {
+  const existing = input.id ? settings.profiles.find((item) => item.id === input.id) : void 0;
+  const normalizedServerUrl = normalizeServerUrl(input.serverUrl);
+  const normalizedName = normalizeProfileName(input.name);
+  const name = ensureUniqueProfileName(normalizedName, settings.profiles, existing?.id);
+  const timestamp = nowIso();
+  return {
+    id: existing?.id ?? createDeterministicProfileId(name, normalizedServerUrl, settings.profiles, existing?.id),
+    name,
+    serverUrl: normalizedServerUrl,
+    authToken: input.authToken ?? null,
+    createdAt: existing?.createdAt ?? timestamp,
+    updatedAt: timestamp,
+    lastUsedAt: existing?.lastUsedAt ?? null
+  };
+}
+function applyDeleteProfile(settings, profileId) {
+  const profiles = settings.profiles.filter((item) => item.id !== profileId);
+  const activeProfileId = settings.activeProfileId !== profileId ? settings.activeProfileId : profiles.length > 0 ? profiles[0]?.id ?? null : null;
+  return { ...settings, profiles, activeProfileId };
+}
+function applySetActiveProfile(settings, profileId) {
+  const activeProfileId = profileId && settings.profiles.some((item) => item.id === profileId) ? profileId : null;
+  const timestamp = nowIso();
+  const profiles = settings.profiles.map(
+    (item) => item.id === activeProfileId ? { ...item, lastUsedAt: timestamp, updatedAt: timestamp } : item
+  );
+  return {
+    ...settings,
+    activeProfileId,
+    profiles
+  };
+}
+async function readShellSettings() {
+  try {
+    const raw = await readFile2(getSettingsPath(), "utf-8");
+    return normalize(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function getDesktopShellModeState(settings) {
+  if (!settings.hasCompletedModeSelection || settings.desktopMode === null) {
+    return {
+      isFirstRun: true,
+      desktopMode: null
+    };
+  }
+  return {
+    isFirstRun: false,
+    desktopMode: settings.desktopMode
+  };
+}
+async function writeShellSettings(settings) {
+  const path2 = getSettingsPath();
+  const temp = `${path2}.tmp`;
+  await writeFile2(temp, JSON.stringify(settings, null, 2), "utf-8");
+  await rename2(temp, path2);
+}
+
+// src/ipc.ts
+function isDesktopLaunchMode(value) {
+  return value === "choose" || value === "local" || value === "remote";
+}
+function toShellState(settings, runtimeStatus) {
+  return {
+    host: "desktop-shell",
+    desktopModeState: getDesktopShellModeState(settings),
+    desktopMode: settings.desktopMode ?? void 0,
+    activeProfileId: settings.activeProfileId,
+    profiles: settings.profiles,
+    localRuntime: runtimeStatus ?? { source: "none", state: "stopped" }
+  };
+}
+async function emitShellState(mainWindow2, getRuntimeStatus) {
+  const state = toShellState(await readShellSettings(), getRuntimeStatus?.());
+  mainWindow2.webContents.send("shell:state", state);
+  return state;
+}
+function registerIpcHandlers(mainWindow2, tray2, options = {}) {
+  ipcMain.handle("window:minimize", () => mainWindow2.minimize());
+  ipcMain.handle("window:maximize", () => {
+    const isCurrentlyMaximized = mainWindow2.isMaximized();
+    if (isCurrentlyMaximized) {
+      mainWindow2.unmaximize();
+      return false;
+    }
+    mainWindow2.maximize();
+    return true;
+  });
+  ipcMain.handle("window:close", () => mainWindow2.close());
+  ipcMain.handle("window:isMaximized", () => mainWindow2.isMaximized());
+  ipcMain.handle("platform:get", () => process.platform);
+  ipcMain.handle("app:getSystemInfo", () => ({
+    platform: process.platform,
+    arch: process.arch,
+    electronVersion: process.versions.electron,
+    nodeVersion: process.versions.node,
+    appVersion: app5.getVersion()
+  }));
+  ipcMain.handle("app:checkForUpdates", async () => {
+    try {
+      return await triggerUpdateCheck(mainWindow2);
+    } catch (error) {
+      return { status: "error", error: error instanceof Error ? error.message : String(error) };
+    }
+  });
+  ipcMain.handle("tray:updateStatus", (_event, status) => updateTrayStatus(tray2, status));
+  ipcMain.handle("native:showExportDialog", () => showExportSettingsDialog(mainWindow2));
+  ipcMain.handle("native:showImportDialog", () => showImportSettingsDialog(mainWindow2));
+  ipcMain.handle("app:getServerPort", () => options.getServerPort?.());
+  ipcMain.handle("desktopRuntime:getStatus", async () => options.getRuntimeStatus?.() ?? { source: "none", state: "stopped" });
+  ipcMain.handle("desktopRuntime:startLocal", async () => options.startLocalRuntime?.() ?? { source: "none", state: "stopped" });
+  ipcMain.handle("desktopRuntime:stopLocal", async () => options.stopLocalRuntime?.() ?? { source: "none", state: "stopped" });
+  ipcMain.handle("desktopLaunchMode:getMode", async () => options.getDesktopLaunchMode?.() ?? "choose");
+  ipcMain.handle("desktopLaunchMode:getContext", async () => options.getDesktopLaunchContext?.() ?? null);
+  ipcMain.handle("desktopLaunchMode:setMode", async (_event, mode) => {
+    if (!isDesktopLaunchMode(mode)) {
+      throw new Error("Invalid desktop launch mode");
+    }
+    if (options.onDesktopLaunchModeChange) {
+      await options.onDesktopLaunchModeChange(mode);
+      return options.getDesktopLaunchMode?.() ?? mode;
+    }
+    if ((mode === "local" || mode === "remote") && options.onDesktopModeChange) {
+      await options.onDesktopModeChange(mode);
+      return options.getDesktopLaunchMode?.() ?? mode;
+    }
+    return options.getDesktopLaunchMode?.() ?? mode;
+  });
+  ipcMain.handle("shell:getState", () => readShellSettings().then((settings) => toShellState(settings, options.getRuntimeStatus?.())));
+  ipcMain.handle("shell:listProfiles", async () => (await readShellSettings()).profiles);
+  ipcMain.handle("shell:saveProfile", async (_event, profile) => {
+    const settings = await readShellSettings();
+    const nextProfile = buildSavedProfile(settings, profile);
+    const existing = settings.profiles.find((item) => item.id === nextProfile.id);
+    settings.profiles = existing ? settings.profiles.map((item) => item.id === existing.id ? nextProfile : item) : [...settings.profiles, nextProfile];
+    await writeShellSettings(settings);
+    await emitShellState(mainWindow2, options.getRuntimeStatus);
+    return nextProfile;
+  });
+  ipcMain.handle("shell:deleteProfile", async (_event, profileId) => {
+    const settings = applyDeleteProfile(await readShellSettings(), profileId);
+    await writeShellSettings(settings);
+    await emitShellState(mainWindow2, options.getRuntimeStatus);
+  });
+  ipcMain.handle("shell:setActiveProfile", async (_event, profileId) => {
+    const settings = applySetActiveProfile(await readShellSettings(), profileId);
+    await writeShellSettings(settings);
+    return emitShellState(mainWindow2, options.getRuntimeStatus);
+  });
+  ipcMain.handle("shell:getDesktopModeState", async () => {
+    const settings = await readShellSettings();
+    return getDesktopShellModeState(settings);
+  });
+  ipcMain.handle("shell:setDesktopMode", async (_event, mode) => {
+    const settings = await readShellSettings();
+    settings.desktopMode = mode;
+    settings.hasCompletedModeSelection = true;
+    await writeShellSettings(settings);
+    await options.onDesktopModeChange?.(mode);
+    return emitShellState(mainWindow2, options.getRuntimeStatus);
+  });
+  ipcMain.handle("shell:resetDesktopMode", async () => {
+    const settings = await readShellSettings();
+    settings.desktopMode = null;
+    settings.hasCompletedModeSelection = false;
+    await writeShellSettings(settings);
+    await options.stopLocalRuntime?.().catch(() => void 0);
+    return emitShellState(mainWindow2, options.getRuntimeStatus);
+  });
+  ipcMain.handle("shell:startQrScan", async () => {
+    throw new Error("QR scanning is not available in desktop shell");
+  });
+  ipcMain.handle("shell:openConnectionManager", () => {
+    mainWindow2.webContents.send("shell:open-connection-manager");
+  });
+}
+
+// src/menu.ts
+import {
+  Menu as Menu2,
+  shell
+} from "electron";
+function runMenuAction(label, action) {
+  if (!action) return;
+  void Promise.resolve(action()).catch((error) => {
+    console.error(`[desktop/menu] ${label} failed`, error);
+  });
+}
+function buildConnectionSubmenu(options) {
+  return {
+    label: "Connection",
+    submenu: [
+      {
+        label: "Use Local Server",
+        click: () => runMenuAction("onStartLocalRuntime", options.onStartLocalRuntime)
+      },
+      {
+        label: "Shut Down Local Server",
+        click: () => runMenuAction("onStopLocalRuntime", options.onStopLocalRuntime)
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Connect to Remote Server\u2026",
+        click: () => runMenuAction("onConnectRemoteServer", options.onConnectRemoteServer ?? options.onChangeLaunchMode)
+      },
+      {
+        label: "Change Launch Mode\u2026",
+        click: () => runMenuAction("onChangeLaunchMode", options.onChangeLaunchMode)
+      }
+    ]
+  };
+}
+function buildAppSubmenu(options) {
+  return {
+    label: options.appName,
+    submenu: [
+      {
+        label: `About ${options.appName}`
+      },
+      {
+        label: "Check for Updates\u2026",
+        click: () => runMenuAction("onCheckForUpdates", options.onCheckForUpdates)
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Preferences",
+        accelerator: "CmdOrCtrl+,"
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: `Hide ${options.appName}`,
+        role: "hide"
+      },
+      {
+        label: "Hide Others",
+        role: "hideOthers"
+      },
+      {
+        label: "Show All",
+        role: "unhide"
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: `Quit ${options.appName}`,
+        accelerator: "CmdOrCtrl+Q",
+        role: "quit"
+      }
+    ]
+  };
+}
+function buildEditSubmenu() {
+  return {
+    label: "Edit",
+    submenu: [
+      {
+        label: "Undo",
+        accelerator: "CmdOrCtrl+Z",
+        role: "undo"
+      },
+      {
+        label: "Redo",
+        accelerator: "Shift+CmdOrCtrl+Z",
+        role: "redo"
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Cut",
+        accelerator: "CmdOrCtrl+X",
+        role: "cut"
+      },
+      {
+        label: "Copy",
+        accelerator: "CmdOrCtrl+C",
+        role: "copy"
+      },
+      {
+        label: "Paste",
+        accelerator: "CmdOrCtrl+V",
+        role: "paste"
+      },
+      {
+        label: "Select All",
+        accelerator: "CmdOrCtrl+A",
+        role: "selectAll"
+      }
+    ]
+  };
+}
+function buildViewSubmenu(options) {
+  const { webContents } = options.mainWindow;
+  return {
+    label: "View",
+    submenu: [
+      {
+        label: "Reload",
+        accelerator: "CmdOrCtrl+R",
+        click: () => webContents.reload()
+      },
+      {
+        label: "Force Reload",
+        accelerator: "CmdOrCtrl+Shift+R",
+        click: () => webContents.reloadIgnoringCache()
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Toggle Dev Tools",
+        accelerator: "Alt+CmdOrCtrl+I",
+        click: () => webContents.toggleDevTools()
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Zoom In",
+        accelerator: "CmdOrCtrl+Plus",
+        click: () => {
+          const level = webContents.getZoomLevel();
+          webContents.setZoomLevel(level + 0.5);
+        }
+      },
+      {
+        label: "Zoom Out",
+        accelerator: "CmdOrCtrl+-",
+        click: () => {
+          const level = webContents.getZoomLevel();
+          webContents.setZoomLevel(level - 0.5);
+        }
+      },
+      {
+        label: "Reset Zoom",
+        accelerator: "CmdOrCtrl+0",
+        click: () => {
+          webContents.setZoomLevel(0);
+        }
+      },
+      {
+        type: "separator"
+      },
+      {
+        label: "Toggle Full Screen",
+        accelerator: "F11",
+        role: "togglefullscreen"
+      }
+    ]
+  };
+}
+function buildWindowSubmenu(isMac) {
+  const windowItems = [
+    {
+      label: "Minimize",
+      accelerator: "CmdOrCtrl+M",
+      role: "minimize"
+    }
+  ];
+  if (isMac) {
+    windowItems.push({
+      label: "Zoom",
+      role: "zoom"
+    });
+  }
+  windowItems.push(
+    {
+      type: "separator"
+    },
+    {
+      label: "Close",
+      accelerator: "CmdOrCtrl+W",
+      role: "close"
+    }
+  );
+  if (isMac) {
+    windowItems.push(
+      {
+        type: "separator"
+      },
+      {
+        label: "Bring All to Front",
+        role: "front"
+      }
+    );
+  }
+  return {
+    label: "Window",
+    submenu: windowItems
+  };
+}
+function buildHelpSubmenu(options) {
+  return {
+    label: "Help",
+    submenu: [
+      {
+        label: "Check for Updates\u2026",
+        click: () => runMenuAction("onCheckForUpdates", options.onCheckForUpdates)
+      },
+      {
+        label: "Fusion Documentation",
+        click: () => {
+          void shell.openExternal("https://github.com/Runfusion/Fusion#readme");
+        }
+      }
+    ]
+  };
+}
+function buildMenuTemplate(options) {
+  const isMac = process.platform === "darwin";
+  const template = [
+    buildEditSubmenu(),
+    buildViewSubmenu(options),
+    buildConnectionSubmenu(options),
+    buildWindowSubmenu(isMac),
+    buildHelpSubmenu(options)
+  ];
+  if (isMac) {
+    template.unshift(buildAppSubmenu(options));
+  }
+  return template;
+}
+function buildAppMenu(options) {
+  const menu = Menu2.buildFromTemplate(buildMenuTemplate(options));
+  Menu2.setApplicationMenu(menu);
+  return menu;
+}
+
+// src/renderer.ts
+import { pathToFileURL } from "node:url";
+import { join as join3 } from "node:path";
+var DEFAULT_DEV_DASHBOARD_URL = "http://localhost:5173";
+function isDevelopmentMode() {
+  return process.env.NODE_ENV === "development" || process.argv.includes("--dev");
+}
+function getRendererUrl() {
+  if (isDevelopmentMode()) {
+    return process.env.FUSION_DASHBOARD_URL ?? DEFAULT_DEV_DASHBOARD_URL;
+  }
+  const rendererIndexPath = join3(import.meta.dirname, "client", "index.html");
+  return pathToFileURL(rendererIndexPath).toString();
+}
+function getRendererFilePath() {
+  if (isDevelopmentMode()) {
+    return "";
+  }
+  return join3(import.meta.dirname, "client", "index.html");
+}
+function isUrlRenderer() {
+  if (isDevelopmentMode()) {
+    const override = process.env.FUSION_USE_FILE_RENDERER;
+    return override !== "true";
+  }
+  return false;
+}
+var IS_DEVELOPMENT = isDevelopmentMode();
+
+// src/local-runtime.ts
+import { once } from "node:events";
+
+// src/engine-runtime.ts
+import { basename } from "node:path";
+async function ensureDesktopRuntimeProject(centralCore, rootDir) {
+  const existing = await centralCore.getProjectByPath(rootDir);
+  if (existing) {
+    return existing;
+  }
+  const projects = await centralCore.listProjects();
+  if (projects.length > 0) {
+    return projects[0];
+  }
+  const registered = await centralCore.registerProject({
+    path: rootDir,
+    name: basename(rootDir) || "Fusion Desktop",
+    isolationMode: "in-process"
+  });
+  return centralCore.updateProject(registered.id, { status: "active" });
+}
+
+// src/local-runtime.ts
+async function createStoreDefault(rootDir) {
+  const { TaskStore } = await import("@fusion/core");
+  return new TaskStore(rootDir);
+}
+async function createDashboardServerDefault(store, rootDir) {
+  const { CentralCore } = await import("@fusion/core");
+  const { createServer } = await import("@fusion/dashboard");
+  const { ProjectEngineManager } = await import("@fusion/engine");
+  const centralCore = new CentralCore();
+  const engineManager = new ProjectEngineManager(centralCore);
+  const cleanup = async () => {
+    await engineManager.stopAll();
+    await centralCore.close?.();
+  };
+  try {
+    await centralCore.init();
+    const rootProject = await ensureDesktopRuntimeProject(centralCore, rootDir);
+    await engineManager.startAll();
+    engineManager.startReconciliation();
+    const primaryEngine = await engineManager.ensureEngine(rootProject.id);
+    const app7 = createServer(store, {
+      engine: primaryEngine,
+      engineManager,
+      centralCore,
+      onProjectFirstAccessed: (projectId) => engineManager.onProjectAccessed(projectId)
+    });
+    return {
+      server: app7.listen(0),
+      cleanup
+    };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function parsePort(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function getAddressPort(server) {
+  const address = server.address();
+  const port = address?.port;
+  if (!port) {
+    throw new Error("Failed to resolve local server port");
+  }
+  return port;
+}
+var LocalRuntimeManager = class {
+  constructor(options) {
+    this.options = options;
+    this.getExternalPort = options.getExternalPort ?? (() => parsePort(process.env.FUSION_SERVER_PORT));
+    this.createStore = options.createStore ?? createStoreDefault;
+    this.createDashboardServer = options.createDashboardServer ?? createDashboardServerDefault;
+  }
+  runtime = null;
+  startupPromise = null;
+  stopPromise = null;
+  status = { source: "none", state: "stopped" };
+  getExternalPort;
+  createStore;
+  createDashboardServer;
+  getStatus() {
+    if (this.runtime) {
+      return {
+        source: "embedded-local",
+        state: "running",
+        port: this.runtime.port,
+        baseUrl: this.runtime.baseUrl
+      };
+    }
+    const externalPort = this.getExternalPort();
+    if (externalPort) {
+      this.status = {
+        source: "external-cli",
+        state: "running",
+        port: externalPort,
+        baseUrl: `http://127.0.0.1:${externalPort}`
+      };
+    }
+    return this.status;
+  }
+  getServerPort() {
+    return this.getStatus().port;
+  }
+  async startLocal() {
+    const externalPort = this.getExternalPort();
+    if (externalPort) {
+      this.status = {
+        source: "external-cli",
+        state: "running",
+        port: externalPort,
+        baseUrl: `http://127.0.0.1:${externalPort}`
+      };
+      return this.status;
+    }
+    if (this.runtime) {
+      return this.getStatus();
+    }
+    if (this.startupPromise) {
+      return this.startupPromise;
+    }
+    this.status = { source: "embedded-local", state: "starting" };
+    this.startupPromise = this.startEmbedded();
+    try {
+      return await this.startupPromise;
+    } finally {
+      this.startupPromise = null;
+    }
+  }
+  async startEmbedded() {
+    let store = null;
+    let server = null;
+    let cleanup;
+    try {
+      store = await this.createStore(this.options.rootDir);
+      await store.init();
+      await store.watch();
+      const dashboardServer = await this.createDashboardServer(store, this.options.rootDir);
+      cleanup = "server" in dashboardServer ? dashboardServer.cleanup : void 0;
+      server = "server" in dashboardServer ? dashboardServer.server : dashboardServer;
+      await Promise.race([
+        once(server, "listening"),
+        once(server, "error").then(([error]) => {
+          throw error;
+        })
+      ]);
+      const port = getAddressPort(server);
+      const baseUrl = `http://127.0.0.1:${port}`;
+      this.runtime = { store, server, port, baseUrl, cleanup };
+      this.status = { source: "embedded-local", state: "running", port, baseUrl };
+      return this.status;
+    } catch (error) {
+      if (server) {
+        await new Promise((resolve2) => {
+          server.close(() => resolve2());
+        });
+      }
+      await cleanup?.();
+      if (store) {
+        store.close();
+      }
+      this.runtime = null;
+      this.status = {
+        source: "embedded-local",
+        state: "error",
+        error: error instanceof Error ? error.message : String(error)
+      };
+      throw error;
+    }
+  }
+  async stopLocal() {
+    if (this.stopPromise) {
+      return this.stopPromise;
+    }
+    this.stopPromise = this.stopInternal();
+    try {
+      return await this.stopPromise;
+    } finally {
+      this.stopPromise = null;
+    }
+  }
+  async stopInternal() {
+    if (this.runtime) {
+      const runtime = this.runtime;
+      this.runtime = null;
+      await new Promise((resolve2) => runtime.server.close(() => resolve2()));
+      await runtime.cleanup?.();
+      runtime.store.close();
+      this.status = { source: "none", state: "stopped" };
+      return this.status;
+    }
+    if (this.getStatus().source === "external-cli") {
+      return this.status;
+    }
+    this.status = { source: "none", state: "stopped" };
+    return this.status;
+  }
+};
+
+// src/main.ts
+function enableSourceMaps() {
+  const processWithSourceMaps = process;
+  processWithSourceMaps.setSourceMapsEnabled?.(true);
+}
+enableSourceMaps();
+var mainWindow = null;
+var tray = null;
+var localRuntimeManager = null;
+var currentDesktopLaunchMode = "choose";
+var currentRemoteLaunch = null;
+var localRuntimeStartupAttempted = false;
+var stopUpdateCheckInterval = null;
+function getAppWithQuitFlag() {
+  return app6;
+}
+async function startLocalRuntimeOnce() {
+  if (!localRuntimeManager || localRuntimeStartupAttempted) {
+    return;
+  }
+  const status = localRuntimeManager.getStatus();
+  if (status.source === "embedded-local" && status.state === "running") {
+    localRuntimeStartupAttempted = true;
+    return;
+  }
+  localRuntimeStartupAttempted = true;
+  await localRuntimeManager.startLocal();
+}
+function getCurrentDesktopLaunchMode() {
+  return currentDesktopLaunchMode;
+}
+async function resetLaunchModeAndReload(window) {
+  try {
+    const settings = await readShellSettings();
+    settings.desktopMode = null;
+    settings.hasCompletedModeSelection = false;
+    await writeShellSettings(settings);
+    await saveDesktopLaunchMode("choose");
+  } catch (error) {
+    console.error("[desktop/main] Failed to reset shell settings", error);
+  }
+  if (localRuntimeManager) {
+    try {
+      await localRuntimeManager.stopLocal();
+    } catch (error) {
+      console.error("[desktop/main] Failed to stop local runtime during reset", error);
+    }
+  }
+  currentDesktopLaunchMode = "choose";
+  currentRemoteLaunch = null;
+  localRuntimeStartupAttempted = false;
+  try {
+    if (isUrlRenderer()) {
+      await window.loadURL(getRendererUrl());
+    } else {
+      await window.loadFile(getRendererFilePath());
+    }
+  } catch (error) {
+    console.error("[desktop/main] reload failed", error);
+  }
+}
+function createMainWindow(state, launchTargetUrl) {
+  const hasValidPosition = typeof state?.x === "number" && typeof state?.y === "number";
+  const window = new BrowserWindow4({
+    width: state?.width ?? DEFAULT_WINDOW_STATE.width,
+    height: state?.height ?? DEFAULT_WINDOW_STATE.height,
+    ...hasValidPosition ? { x: state.x, y: state.y } : {},
+    title: "Fusion",
+    webPreferences: {
+      preload: join4(import.meta.dirname, "preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  if (launchTargetUrl) {
+    void window.loadURL(launchTargetUrl);
+  } else if (isUrlRenderer()) {
+    void window.loadURL(getRendererUrl());
+  } else {
+    void window.loadFile(getRendererFilePath());
+  }
+  const showFallbackTimer = setTimeout(() => {
+    window.show();
+    window.focus();
+  }, 2e3);
+  window.once("ready-to-show", () => {
+    clearTimeout(showFallbackTimer);
+    window.show();
+    window.focus();
+  });
+  window.on("close", (event) => {
+    saveWindowState(window);
+    if (getAppWithQuitFlag().isQuitting) {
+      return;
+    }
+    event.preventDefault();
+    window.hide();
+  });
+  window.on("closed", () => {
+    mainWindow = null;
+  });
+  mainWindow = window;
+  return window;
+}
+function resolveLocalRuntimeRoot() {
+  const override = process.env.FUSION_HOME?.trim();
+  if (override) {
+    return resolve(override);
+  }
+  return app6.getPath("home");
+}
+async function initializeApp() {
+  const state = await loadWindowState();
+  const rememberedLaunchMode = await loadDesktopLaunchMode();
+  localRuntimeManager = new LocalRuntimeManager({ rootDir: resolveLocalRuntimeRoot() });
+  currentDesktopLaunchMode = rememberedLaunchMode;
+  currentRemoteLaunch = null;
+  localRuntimeStartupAttempted = false;
+  if (rememberedLaunchMode === "remote") {
+    const shellSettings = await readShellSettings();
+    const normalizedRemoteLaunch = normalizeDesktopRemoteLaunch(shellSettings);
+    if (normalizedRemoteLaunch) {
+      currentRemoteLaunch = normalizedRemoteLaunch;
+    } else {
+      currentDesktopLaunchMode = "choose";
+      await saveDesktopLaunchMode("choose");
+    }
+  }
+  if (rememberedLaunchMode === "local") {
+    try {
+      await startLocalRuntimeOnce();
+    } catch (error) {
+      await localRuntimeManager.stopLocal();
+      currentDesktopLaunchMode = "choose";
+      localRuntimeStartupAttempted = false;
+      await saveDesktopLaunchMode("choose");
+      console.error("[desktop/main] Failed to restore local mode; falling back to chooser", error);
+    }
+  }
+  if (currentDesktopLaunchMode === "choose" && process.env.FUSION_DESKTOP_MODE === "local") {
+    await startLocalRuntimeOnce();
+    currentDesktopLaunchMode = "local";
+  }
+  const windowState = state ? clampWindowStateToVisibleDisplay(
+    state,
+    typeof screen?.getAllDisplays === "function" ? screen.getAllDisplays().map((display) => ({ workArea: display.workArea })) : []
+  ) : void 0;
+  const createdWindow = createMainWindow(
+    windowState,
+    currentDesktopLaunchMode === "remote" && currentRemoteLaunch ? buildRemoteShellHandoffUrl(currentRemoteLaunch) : void 0
+  );
+  buildAppMenu({
+    mainWindow: createdWindow,
+    appName: "Fusion",
+    onChangeLaunchMode: async () => {
+      await resetLaunchModeAndReload(createdWindow);
+    },
+    /*
+     * FNXC:DesktopRuntimeMode 2026-06-21-02:04:
+     * Menu-driven local/remote switching must only persist local mode after the embedded runtime starts successfully; shutdown stops the local server without rewriting the launch-mode preference.
+     */
+    onStartLocalRuntime: async () => {
+      if (!localRuntimeManager) return;
+      localRuntimeStartupAttempted = false;
+      await startLocalRuntimeOnce();
+      currentRemoteLaunch = null;
+      currentDesktopLaunchMode = "local";
+      await saveDesktopLaunchMode("local");
+      createdWindow.webContents.reload();
+    },
+    onStopLocalRuntime: async () => {
+      await localRuntimeManager?.stopLocal();
+    },
+    onConnectRemoteServer: async () => {
+      await resetLaunchModeAndReload(createdWindow);
+    },
+    onCheckForUpdates: async () => {
+      await triggerUpdateCheck(createdWindow);
+    }
+  });
+  tray = new Tray2(nativeImage2.createEmpty());
+  setupTray(createdWindow, tray);
+  registerIpcHandlers(createdWindow, tray, {
+    onDesktopModeChange: async (mode) => {
+      if (!localRuntimeManager) {
+        return;
+      }
+      currentDesktopLaunchMode = mode;
+      if (mode === "local") {
+        currentRemoteLaunch = null;
+        localRuntimeStartupAttempted = false;
+        await startLocalRuntimeOnce();
+      } else {
+        localRuntimeStartupAttempted = false;
+        await localRuntimeManager.stopLocal();
+        const shellSettings = await readShellSettings();
+        currentRemoteLaunch = normalizeDesktopRemoteLaunch({ ...shellSettings, desktopMode: "remote" });
+      }
+      await saveDesktopLaunchMode(mode);
+    },
+    onDesktopLaunchModeChange: async (mode) => {
+      if (!localRuntimeManager) {
+        return;
+      }
+      currentDesktopLaunchMode = mode;
+      localRuntimeStartupAttempted = false;
+      if (mode === "local") {
+        currentRemoteLaunch = null;
+        await startLocalRuntimeOnce();
+      } else {
+        await localRuntimeManager.stopLocal();
+        const shellSettings = await readShellSettings();
+        currentRemoteLaunch = normalizeDesktopRemoteLaunch({ ...shellSettings, desktopMode: "remote" });
+      }
+      await saveDesktopLaunchMode(mode);
+    },
+    getRuntimeStatus: () => localRuntimeManager?.getStatus() ?? { source: "none", state: "stopped" },
+    startLocalRuntime: () => localRuntimeManager?.startLocal() ?? Promise.resolve({ source: "none", state: "stopped" }),
+    stopLocalRuntime: () => localRuntimeManager?.stopLocal() ?? Promise.resolve({ source: "none", state: "stopped" }),
+    getServerPort: () => localRuntimeManager?.getServerPort(),
+    getDesktopLaunchMode: () => currentDesktopLaunchMode,
+    getDesktopLaunchContext: () => currentRemoteLaunch
+  });
+  registerDeepLinkProtocol();
+  setupDeepLinkHandler(createdWindow);
+  setupAutoUpdater(createdWindow);
+  stopUpdateCheckInterval = startUpdateCheckInterval(createdWindow);
+  if (windowState?.isMaximized === true) {
+    createdWindow.maximize();
+  }
+}
+function run() {
+  const appWithQuitFlag = getAppWithQuitFlag();
+  appWithQuitFlag.isQuitting = false;
+  void app6.whenReady().then(() => initializeApp());
+  app6.on("window-all-closed", () => {
+    if (process.platform !== "darwin") {
+      app6.quit();
+    }
+  });
+  app6.on("before-quit", () => {
+    appWithQuitFlag.isQuitting = true;
+    if (stopUpdateCheckInterval) {
+      stopUpdateCheckInterval();
+      stopUpdateCheckInterval = null;
+    }
+    if (tray) {
+      tray.destroy();
+      tray = null;
+    }
+    if (localRuntimeManager) {
+      void localRuntimeManager.stopLocal();
+    }
+  });
+  app6.on("activate", () => {
+    if (mainWindow === null) {
+      const window = createMainWindow();
+      window.show();
+      return;
+    }
+    if (!mainWindow.isVisible()) {
+      mainWindow.show();
+    }
+    mainWindow.focus();
+  });
+}
+var modulePath = fileURLToPath(import.meta.url);
+var isElectronMain = process.type === "browser";
+var isDirectInvocation = !!process.argv[1] && resolve(process.argv[1]) === modulePath;
+if (isElectronMain || isDirectInvocation) {
+  run();
+}
+export {
+  getRendererUrl as DASHBOARD_URL,
+  IS_DEVELOPMENT,
+  createMainWindow,
+  getCurrentDesktopLaunchMode,
+  initializeApp,
+  resolveLocalRuntimeRoot,
+  run
+};
+//# sourceMappingURL=main.js.map