Fix built-in daemon management toggle

packages/app/src/app/_layout.tsx

@@ -50,11 +50,12 @@ import {
 import { SidebarCalloutProvider } from "@/contexts/sidebar-callout-context";
 import { ToastProvider } from "@/contexts/toast-context";
 import { VoiceProvider } from "@/contexts/voice-context";
-import { startHostRuntimeBootstrap } from "@/app/host-runtime-bootstrap";
+import { startDaemonIfGateAllows, startHostRuntimeBootstrap } from "@/app/host-runtime-bootstrap";
 import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
 import { listenToDesktopEvent } from "@/desktop/electron/events";
 import { updateDesktopWindowControls } from "@/desktop/electron/window";
 import { getDesktopHost } from "@/desktop/host";
+import { loadDesktopSettings } from "@/desktop/settings/desktop-settings";
 import { RosettaCalloutSource } from "@/desktop/updates/rosetta-callout-source";
 import { UpdateCalloutSource } from "@/desktop/updates/update-callout-source";
 import { useActiveWorktreeNewAction } from "@/hooks/use-active-worktree-new-action";
@@ -312,6 +313,14 @@ function useDaemonStartIsRunning(): boolean {
 
 const STARTUP_GIVE_UP_TIMEOUT_MS = 5_000;
 
+async function shouldStartBuiltInDaemon(): Promise<boolean> {
+  if (!shouldUseDesktopDaemon()) {
+    return false;
+  }
+  const settings = await loadDesktopSettings();
+  return settings.daemon.manageBuiltInDaemon;
+}
+
 function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
   useEffect(() => {
     const store = getHostRuntimeStore();
@@ -319,7 +328,7 @@ function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
     startHostRuntimeBootstrap({
       store,
       daemonStartService,
-      shouldStartDaemon: shouldUseDesktopDaemon(),
+      shouldStartDaemon: shouldStartBuiltInDaemon,
     });
   }, []);
 
@@ -346,7 +355,10 @@ function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
   }, [anyOnlineHostServerId, daemonStartError, daemonStartIsRunning, hasGivenUpWaitingForHost]);
 
   const retry = useCallback(() => {
-    void getDaemonStartService({ store: getHostRuntimeStore() }).start();
+    startDaemonIfGateAllows({
+      daemonStartService: getDaemonStartService({ store: getHostRuntimeStore() }),
+      shouldStartDaemon: shouldStartBuiltInDaemon,
+    });
   }, []);
 
   const splashError = !anyOnlineHostServerId ? daemonStartError : null;

packages/app/src/app/host-runtime-bootstrap.test.ts

@@ -55,6 +55,21 @@ describe("startHostRuntimeBootstrap", () => {
     expect(daemonStartService.start).not.toHaveBeenCalled();
   });
 
+  it("skips daemon-start when the startup gate resolves false", async () => {
+    const store = createFakeStore();
+    const daemonStartService = createFakeDaemonStartService();
+
+    startHostRuntimeBootstrap({
+      store,
+      daemonStartService,
+      shouldStartDaemon: async () => false,
+    });
+    await Promise.resolve();
+
+    expect(store.boot).toHaveBeenCalledTimes(1);
+    expect(daemonStartService.start).not.toHaveBeenCalled();
+  });
+
   it("does not await the daemon-start promise", () => {
     const store = createFakeStore();
     let resolveStart: ((value: { ok: true }) => void) | undefined;

packages/app/src/app/host-runtime-bootstrap.ts

@@ -11,17 +11,39 @@ export interface HostRuntimeBootstrapDaemonStartService {
   start: () => Promise<DaemonStartResult>;
 }
 
+type HostRuntimeBootstrapStartGate = boolean | (() => boolean | Promise<boolean>);
+
 export interface StartHostRuntimeBootstrapInput {
   store: HostRuntimeBootstrapStore;
   daemonStartService: HostRuntimeBootstrapDaemonStartService;
-  shouldStartDaemon: boolean;
+  shouldStartDaemon: HostRuntimeBootstrapStartGate;
 }
 
 export function startHostRuntimeBootstrap(input: StartHostRuntimeBootstrapInput): void {
   input.store.boot();
-  if (input.shouldStartDaemon) {
-    void input.daemonStartService.start();
+  startDaemonIfGateAllows({
+    daemonStartService: input.daemonStartService,
+    shouldStartDaemon: input.shouldStartDaemon,
+  });
+}
+
+export function startDaemonIfGateAllows(input: {
+  daemonStartService: HostRuntimeBootstrapDaemonStartService;
+  shouldStartDaemon: HostRuntimeBootstrapStartGate;
+}): void {
+  if (typeof input.shouldStartDaemon === "boolean") {
+    if (input.shouldStartDaemon) {
+      void input.daemonStartService.start();
+    }
+    return;
   }
+
+  void Promise.resolve(input.shouldStartDaemon()).then((shouldStartDaemon) => {
+    if (shouldStartDaemon) {
+      void input.daemonStartService.start();
+    }
+    return;
+  });
 }
 
 export const WELCOME_ROUTE: Href = "/welcome";

packages/app/src/desktop/components/desktop-updates-section.test.tsx

@@ -208,12 +208,14 @@ vi.mock("@/desktop/updates/desktop-updates", () => ({
 
 const daemonCommandMocks = vi.hoisted(() => ({
   getCliDaemonStatusMock: vi.fn(),
+  startDesktopDaemonMock: vi.fn(),
   stopDesktopDaemonMock: vi.fn(),
 }));
 
 vi.mock("@/desktop/daemon/desktop-daemon", () => ({
   getCliDaemonStatus: daemonCommandMocks.getCliDaemonStatusMock,
   shouldUseDesktopDaemon: vi.fn(() => true),
+  startDesktopDaemon: daemonCommandMocks.startDesktopDaemonMock,
   stopDesktopDaemon: daemonCommandMocks.stopDesktopDaemonMock,
 }));
 
@@ -234,8 +236,15 @@ describe("LocalDaemonSection", () => {
     settingsState.updateSettings.mockReset();
     settingsState.updateSettings.mockResolvedValue();
     daemonStatusState.data.status.status = "running";
+    daemonStatusState.data.status.desktopManaged = true;
     daemonStatusState.setStatus.mockReset();
     daemonStatusState.refetch.mockReset();
+    daemonCommandMocks.startDesktopDaemonMock.mockReset();
+    daemonCommandMocks.startDesktopDaemonMock.mockResolvedValue({
+      ...daemonStatusState.data.status,
+      status: "running",
+      desktopManaged: true,
+    });
     daemonCommandMocks.stopDesktopDaemonMock.mockReset();
     daemonCommandMocks.stopDesktopDaemonMock.mockResolvedValue({
       ...daemonStatusState.data.status,
@@ -297,4 +306,57 @@ describe("LocalDaemonSection", () => {
       },
     });
   });
+
+  it("persists paused management before stopping the desktop-managed daemon", async () => {
+    confirmDialogMock.mockResolvedValue(true);
+    const screen = render(<LocalDaemonSection />);
+
+    fireEvent.click(screen.getByRole("switch", { name: "Manage built-in daemon" }));
+
+    await waitFor(() => {
+      expect(daemonCommandMocks.stopDesktopDaemonMock).toHaveBeenCalledTimes(1);
+    });
+
+    expect(settingsState.updateSettings.mock.invocationCallOrder[0]).toBeLessThan(
+      daemonCommandMocks.stopDesktopDaemonMock.mock.invocationCallOrder[0],
+    );
+  });
+
+  it("does not stop a manually managed daemon when pausing built-in daemon management", async () => {
+    confirmDialogMock.mockResolvedValue(true);
+    daemonStatusState.data.status.desktopManaged = false;
+    const screen = render(<LocalDaemonSection />);
+
+    fireEvent.click(screen.getByRole("switch", { name: "Manage built-in daemon" }));
+
+    await waitFor(() => {
+      expect(settingsState.updateSettings).toHaveBeenCalledWith({
+        daemon: {
+          manageBuiltInDaemon: false,
+        },
+      });
+    });
+    expect(daemonCommandMocks.stopDesktopDaemonMock).not.toHaveBeenCalled();
+  });
+
+  it("starts the built-in daemon when management is re-enabled", async () => {
+    settingsState.settings.daemon.manageBuiltInDaemon = false;
+    const screen = render(<LocalDaemonSection />);
+
+    fireEvent.click(screen.getByRole("switch", { name: "Manage built-in daemon" }));
+
+    await waitFor(() => {
+      expect(daemonCommandMocks.startDesktopDaemonMock).toHaveBeenCalledTimes(1);
+    });
+    expect(settingsState.updateSettings).toHaveBeenCalledWith({
+      daemon: {
+        manageBuiltInDaemon: true,
+      },
+    });
+    expect(daemonStatusState.setStatus).toHaveBeenCalledWith({
+      ...daemonStatusState.data.status,
+      status: "running",
+      desktopManaged: true,
+    });
+  });
 });

packages/app/src/desktop/components/desktop-updates-section.tsx

@@ -14,6 +14,7 @@ import { isVersionMismatch } from "@/desktop/updates/desktop-updates";
 import {
   getCliDaemonStatus,
   shouldUseDesktopDaemon,
+  startDesktopDaemon,
   stopDesktopDaemon,
 } from "@/desktop/daemon/desktop-daemon";
 import { useDaemonStatus } from "@/desktop/hooks/use-daemon-status";
@@ -41,6 +42,12 @@ function useDaemonManagementToggle(args: {
     if (!settings.manageBuiltInDaemon) {
       setIsUpdatingDaemonManagement(true);
       void updateSettings({ manageBuiltInDaemon: true })
+        .then(() => startDesktopDaemon())
+        .then((newStatus) => {
+          setStatus(newStatus);
+          refetch();
+          return;
+        })
         .catch((error) => {
           console.error("[Settings] Failed to update built-in daemon management", error);
           Alert.alert("Error", "Unable to update built-in daemon management.");
@@ -66,25 +73,29 @@ function useDaemonManagementToggle(args: {
 
         setIsUpdatingDaemonManagement(true);
 
-        const stopPromise =
-          daemonStatus?.status === "running"
-            ? stopDesktopDaemon()
-            : Promise.resolve(daemonStatus ?? null);
-
-        void stopPromise
+        void updateSettings({ manageBuiltInDaemon: false })
+          .then(() => {
+            if (daemonStatus?.status === "running" && daemonStatus.desktopManaged) {
+              return stopDesktopDaemon();
+            }
+            return daemonStatus ?? null;
+          })
           .then((newStatus) => {
             if (newStatus) {
               setStatus(newStatus);
             }
-            return updateSettings({ manageBuiltInDaemon: false });
+            return;
           })
           .then(() => {
             refetch();
             return;
           })
           .catch((error) => {
-            console.error("[Settings] Failed to pause built-in daemon management", error);
-            Alert.alert("Error", "Unable to pause built-in daemon management.");
+            console.error("[Settings] Failed to stop built-in daemon", error);
+            Alert.alert(
+              "Error",
+              "Built-in daemon management was paused, but Paseo could not stop the daemon.",
+            );
           })
           .finally(() => {
             setIsUpdatingDaemonManagement(false);