feat(desktop): split daemon and release settings to main process

Move daemon management and release channel settings out of the renderer's AsyncStorage and into a desktop-owned settings store persisted by the main process. Adds a "Keep daemon running after quit" option, a daemon lifecycle section in settings, and a one-time migration of legacy renderer-owned desktop settings.
2026-04-25 13:59:07 +07:00
parent 2b37276577
commit ae3e88e7e1
20 changed files with 1792 additions and 187 deletions
@@ -33,6 +33,11 @@ import {
  runCliJsonCommand,
  runCliTextCommand,
 } from "./runtime-paths.js";
+import {
+  createDesktopSettingsCommandHandlers,
+  type DesktopCommandHandler,
+} from "../settings/desktop-settings-commands.js";
+import { getDesktopSettingsStore } from "../settings/desktop-settings-electron.js";

 const DAEMON_LOG_FILENAME = "daemon.log";
 const PID_POLL_INTERVAL_MS = 100;
@@ -44,7 +49,7 @@ const DETACHED_STARTUP_GRACE_MS = 1200;

 type DesktopDaemonState = "starting" | "running" | "stopped" | "errored";

-interface DesktopDaemonStatus {
+export interface DesktopDaemonStatus {
  serverId: string;
  status: DesktopDaemonState;
  listen: string | null;
@@ -67,10 +72,16 @@ interface DesktopPairingOffer {
  qr: string | null;
 }

-type DesktopCommandHandler = (args?: Record<string, unknown>) => Promise<unknown> | unknown;
-
-function parseReleaseChannel(args: Record<string, unknown> | undefined): AppReleaseChannel {
-  return args?.releaseChannel === "beta" ? "beta" : "stable";
+function parseReleaseChannel(
+  args: Record<string, unknown> | undefined,
+): AppReleaseChannel | undefined {
+  if (args?.releaseChannel === "beta") {
+    return "beta";
+  }
+  if (args?.releaseChannel === "stable") {
+    return "stable";
+  }
+  return undefined;
 }

 // ---------------------------------------------------------------------------
@@ -195,7 +206,7 @@ function resolveDesktopAppVersion(): string {
 // Daemon lifecycle
 // ---------------------------------------------------------------------------

-async function resolveStatus(): Promise<DesktopDaemonStatus> {
+export async function resolveDesktopDaemonStatus(): Promise<DesktopDaemonStatus> {
  const home = getPaseoHome();

  try {
@@ -265,8 +276,8 @@ function buildStartupFailureError(

 async function pollForRunningDaemon(): Promise<DesktopDaemonStatus> {
  async function poll(attempt: number): Promise<DesktopDaemonStatus> {
-    if (attempt >= STARTUP_POLL_MAX_ATTEMPTS) return resolveStatus();
-    const status = await resolveStatus();
+    if (attempt >= STARTUP_POLL_MAX_ATTEMPTS) return resolveDesktopDaemonStatus();
+    const status = await resolveDesktopDaemonStatus();
    if (attempt === 0 || attempt === STARTUP_POLL_MAX_ATTEMPTS - 1 || attempt % 10 === 9) {
      logDesktopDaemonLifecycle("polling daemon status after detached start", {
        attempt: attempt + 1,
@@ -284,7 +295,7 @@ async function pollForRunningDaemon(): Promise<DesktopDaemonStatus> {
 }

 async function startDaemon(): Promise<DesktopDaemonStatus> {
-  const current = await resolveStatus();
+  const current = await resolveDesktopDaemonStatus();
  logDesktopDaemonLifecycle("initial status check before start", {
    status: current.status,
    pid: current.pid,
@@ -299,7 +310,7 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
        appVersion: normalizeVersion(resolveDesktopAppVersion()),
        daemonVersion: normalizeVersion(current.version),
      });
-      await stopDaemon();
+      await stopDesktopDaemon();
    } else {
      return current;
    }
@@ -389,8 +400,8 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
  return pollForRunningDaemon();
 }

-async function stopDaemon(): Promise<DesktopDaemonStatus> {
-  const status = await resolveStatus();
+export async function stopDesktopDaemon(): Promise<DesktopDaemonStatus> {
+  const status = await resolveDesktopDaemonStatus();
  if (status.status !== "running" || !status.pid) return status;

  const pid = status.pid;
@@ -406,11 +417,11 @@ async function stopDaemon(): Promise<DesktopDaemonStatus> {
    throw new Error(`Timed out waiting for daemon PID ${pid} to stop`);
  }

-  return await resolveStatus();
+  return await resolveDesktopDaemonStatus();
 }

 async function restartDaemon(): Promise<DesktopDaemonStatus> {
-  await stopDaemon();
+  await stopDesktopDaemon();
  return startDaemon();
 }

@@ -427,7 +438,7 @@ async function getCliDaemonStatus(): Promise<string> {
 }

 async function getDaemonPairing(): Promise<DesktopPairingOffer> {
-  const status = await resolveStatus();
+  const status = await resolveDesktopDaemonStatus();
  if (status.status !== "running") {
    return {
      relayEnabled: false,
@@ -457,7 +468,7 @@ async function getDaemonPairing(): Promise<DesktopPairingOffer> {
 }

 async function getLocalDaemonVersion(): Promise<{ version: string | null; error: string | null }> {
-  const status = await resolveStatus();
+  const status = await resolveDesktopDaemonStatus();
  if (status.status !== "running") {
    return { version: null, error: "Daemon is not running." };
  }
@@ -467,12 +478,10 @@ async function getLocalDaemonVersion(): Promise<{ version: string | null; error:
  };
 }

-function resolveCurrentUpdateVersion(): string {
-  return resolveDesktopAppVersion();
-}
-
-function getSystemIdleTimeMs(): number {
-  return powerMonitor.getSystemIdleTime() * 1000;
+async function resolveRequestedReleaseChannel(
+  args: Record<string, unknown> | undefined,
+): Promise<AppReleaseChannel> {
+  return parseReleaseChannel(args) ?? (await getDesktopSettingsStore().get()).releaseChannel;
 }

 // ---------------------------------------------------------------------------
@@ -481,13 +490,14 @@ function getSystemIdleTimeMs(): number {

 export function createDaemonCommandHandlers(): Record<string, DesktopCommandHandler> {
  return {
-    desktop_daemon_status: () => resolveStatus(),
+    ...createDesktopSettingsCommandHandlers({ settingsStore: getDesktopSettingsStore() }),
+    desktop_daemon_status: () => resolveDesktopDaemonStatus(),
    start_desktop_daemon: () => startDaemon(),
-    stop_desktop_daemon: () => stopDaemon(),
+    stop_desktop_daemon: () => stopDesktopDaemon(),
    restart_desktop_daemon: () => restartDaemon(),
    desktop_daemon_logs: () => getDaemonLogs(),
    desktop_daemon_pairing: () => getDaemonPairing(),
-    desktop_get_system_idle_time: () => getSystemIdleTimeMs(),
+    desktop_get_system_idle_time: () => powerMonitor.getSystemIdleTime() * 1000,
    cli_daemon_status: () => getCliDaemonStatus(),
    write_attachment_base64: (args) => writeAttachmentBase64(args ?? {}),
    copy_attachment_file: (args) => copyAttachmentFileToManagedStorage(args ?? {}),
@@ -511,15 +521,18 @@ export function createDaemonCommandHandlers(): Record<string, DesktopCommandHand
      if (sessionId) closeLocalTransportSession(sessionId);
    },
    check_app_update: async (args) => {
-      const currentVersion = await resolveCurrentUpdateVersion();
-      return checkForAppUpdate({ currentVersion, releaseChannel: parseReleaseChannel(args) });
+      const currentVersion = resolveDesktopAppVersion();
+      return checkForAppUpdate({
+        currentVersion,
+        releaseChannel: await resolveRequestedReleaseChannel(args),
+      });
    },
    install_app_update: async (args) => {
-      const currentVersion = await resolveCurrentUpdateVersion();
+      const currentVersion = resolveDesktopAppVersion();
      return downloadAndInstallUpdate(
-        { currentVersion, releaseChannel: parseReleaseChannel(args) },
+        { currentVersion, releaseChannel: await resolveRequestedReleaseChannel(args) },
        async () => {
-          await stopDaemon();
+          await stopDesktopDaemon();
        },
      );
    },
@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { DEFAULT_DESKTOP_SETTINGS } from "../settings/desktop-settings";
+import {
+  createBeforeQuitHandler,
+  shouldStopDesktopManagedDaemonOnQuit,
+  stopDesktopManagedDaemonOnQuitIfNeeded,
+} from "./quit-lifecycle";
+
+describe("quit-lifecycle", () => {
+  it("stops only when quit persistence disables keep-running and the daemon is desktop-managed", () => {
+    expect(
+      shouldStopDesktopManagedDaemonOnQuit({
+        settings: {
+          ...DEFAULT_DESKTOP_SETTINGS,
+          daemon: {
+            ...DEFAULT_DESKTOP_SETTINGS.daemon,
+            keepRunningAfterQuit: false,
+          },
+        },
+        daemonStatus: {
+          status: "running",
+          desktopManaged: true,
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it("does not stop a manually started daemon on quit", async () => {
+    const stopDaemon = vi.fn(async () => undefined);
+
+    const stopped = await stopDesktopManagedDaemonOnQuitIfNeeded({
+      settingsStore: {
+        get: async () => ({
+          ...DEFAULT_DESKTOP_SETTINGS,
+          daemon: {
+            ...DEFAULT_DESKTOP_SETTINGS.daemon,
+            keepRunningAfterQuit: false,
+          },
+        }),
+        patch: async () => DEFAULT_DESKTOP_SETTINGS,
+        migrateLegacyRendererSettings: async () => DEFAULT_DESKTOP_SETTINGS,
+      },
+      resolveStatus: async () => ({
+        status: "running",
+        desktopManaged: false,
+      }),
+      stopDaemon,
+    });
+
+    expect(stopped).toBe(false);
+    expect(stopDaemon).not.toHaveBeenCalled();
+  });
+
+  it("gates quit until the stop decision completes, then lets the next quit pass through", async () => {
+    let resolveStopDecision: (() => void) | null = null;
+    const app = { quit: vi.fn() };
+    const closeTransportSessions = vi.fn();
+    const onStopError = vi.fn();
+    const preventDefault = vi.fn();
+    const secondPreventDefault = vi.fn();
+
+    const handleBeforeQuit = createBeforeQuitHandler({
+      app,
+      closeTransportSessions,
+      stopDesktopManagedDaemonIfNeeded: vi.fn(
+        () =>
+          new Promise<boolean>((resolve) => {
+            resolveStopDecision = () => resolve(false);
+          }),
+      ),
+      onStopError,
+    });
+
+    handleBeforeQuit({ preventDefault });
+
+    expect(preventDefault).toHaveBeenCalledTimes(1);
+    expect(closeTransportSessions).toHaveBeenCalledTimes(1);
+    expect(app.quit).not.toHaveBeenCalled();
+    expect(resolveStopDecision).not.toBeNull();
+
+    resolveStopDecision?.();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(app.quit).toHaveBeenCalledTimes(1);
+    expect(onStopError).not.toHaveBeenCalled();
+
+    handleBeforeQuit({ preventDefault: secondPreventDefault });
+
+    expect(secondPreventDefault).not.toHaveBeenCalled();
+    expect(closeTransportSessions).toHaveBeenCalledTimes(2);
+    expect(app.quit).toHaveBeenCalledTimes(1);
+  });
+});
@@ -0,0 +1,93 @@
+import type { DesktopSettingsStore } from "../settings/desktop-settings.js";
+
+interface QuitLifecycleSettings {
+  daemon: {
+    keepRunningAfterQuit: boolean;
+  };
+}
+
+interface QuitLifecycleStatus {
+  status: "starting" | "running" | "stopped" | "errored";
+  desktopManaged: boolean;
+}
+
+interface BeforeQuitEvent {
+  preventDefault(): void;
+}
+
+interface BeforeQuitApp {
+  quit(): void;
+}
+
+export function shouldStopDesktopManagedDaemonOnQuit({
+  settings,
+  daemonStatus,
+}: {
+  settings: QuitLifecycleSettings;
+  daemonStatus: QuitLifecycleStatus;
+}): boolean {
+  return (
+    settings.daemon.keepRunningAfterQuit === false &&
+    daemonStatus.status === "running" &&
+    daemonStatus.desktopManaged
+  );
+}
+
+export async function stopDesktopManagedDaemonOnQuitIfNeeded({
+  settingsStore,
+  resolveStatus,
+  stopDaemon,
+}: {
+  settingsStore: DesktopSettingsStore;
+  resolveStatus: () => Promise<QuitLifecycleStatus>;
+  stopDaemon: () => Promise<unknown>;
+}): Promise<boolean> {
+  const settings = await settingsStore.get();
+  const daemonStatus = await resolveStatus();
+
+  if (!shouldStopDesktopManagedDaemonOnQuit({ settings, daemonStatus })) {
+    return false;
+  }
+
+  await stopDaemon();
+  return true;
+}
+
+export function createBeforeQuitHandler({
+  app,
+  closeTransportSessions,
+  stopDesktopManagedDaemonIfNeeded,
+  onStopError,
+}: {
+  app: BeforeQuitApp;
+  closeTransportSessions: () => void;
+  stopDesktopManagedDaemonIfNeeded: () => Promise<boolean>;
+  onStopError: (error: unknown) => void;
+}): (event: BeforeQuitEvent) => void {
+  let allowingQuitToContinue = false;
+  let quittingInProgress = false;
+
+  return (event) => {
+    closeTransportSessions();
+
+    if (allowingQuitToContinue) {
+      return;
+    }
+
+    event.preventDefault();
+    if (quittingInProgress) {
+      return;
+    }
+
+    quittingInProgress = true;
+    void stopDesktopManagedDaemonIfNeeded()
+      .catch((error) => {
+        onStopError(error);
+      })
+      .finally(() => {
+        allowingQuitToContinue = true;
+        quittingInProgress = false;
+        app.quit();
+      });
+  };
+}