Stop local daemon when removing localhost (#1297)

* fix(app): stop local daemon when removing localhost

* fix(app): handle daemon removal rollback

* fix(app): return listen address in desktop e2e mock

* fix(app): refresh daemon status after registration failure

* fix(app): unslop daemon status error coverage

* fix(app): preserve daemon toggle error context

---------

Co-authored-by: Mohamed Boudra <boudra.moha@gmail.com>

packages/app/src/runtime/daemon-start-service.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { DaemonStartService } from "./daemon-start-service";
+import { DaemonStartService, upsertDesktopDaemonConnection } from "./daemon-start-service";
 import type { HostRuntimeStore } from "./host-runtime";
 import type { DesktopDaemonStatus } from "@/desktop/daemon/desktop-daemon";
 
@@ -223,3 +223,50 @@ describe("DaemonStartService", () => {
     expect(notifications).toBe(countAfterFirst);
   });
 });
+
+describe("upsertDesktopDaemonConnection", () => {
+  it("upserts a valid desktop daemon status", async () => {
+    const fake = createFakeStore();
+
+    const result = await upsertDesktopDaemonConnection(fake.store, makeStatus());
+
+    expect(result).toEqual({ ok: true });
+    expect(fake.upserts).toEqual([
+      { listenAddress: "127.0.0.1:6767", serverId: "srv_desktop", hostname: "desktop" },
+    ]);
+  });
+
+  it("rejects a missing listen address without upserting", async () => {
+    const fake = createFakeStore();
+
+    const result = await upsertDesktopDaemonConnection(fake.store, makeStatus({ listen: null }));
+
+    expect(result).toEqual({
+      ok: false,
+      error: "Desktop daemon did not return a listen address.",
+    });
+    expect(fake.upserts).toEqual([]);
+  });
+
+  it("rejects a missing server id without upserting", async () => {
+    const fake = createFakeStore();
+
+    const result = await upsertDesktopDaemonConnection(fake.store, makeStatus({ serverId: "" }));
+
+    expect(result).toEqual({
+      ok: false,
+      error: "Desktop daemon did not return a server id.",
+    });
+    expect(fake.upserts).toEqual([]);
+  });
+
+  it("rejects an unsupported listen address without upserting", async () => {
+    const fake = createFakeStore();
+
+    const result = await upsertDesktopDaemonConnection(fake.store, makeStatus({ listen: "???" }));
+
+    expect(result.ok).toBe(false);
+    expect(result.ok ? "" : result.error).toContain("unsupported listen address");
+    expect(fake.upserts).toEqual([]);
+  });
+});

packages/app/src/runtime/daemon-start-service.ts

@@ -4,13 +4,41 @@ import type { HostRuntimeStore } from "@/runtime/host-runtime";
 
 export type DaemonStartResult = { ok: true } | { ok: false; error: string };
 
+type DaemonConnectionStore = Pick<HostRuntimeStore, "upsertConnectionFromListen">;
+
 export interface DaemonStartServiceDeps {
-  store: Pick<HostRuntimeStore, "upsertConnectionFromListen">;
+  store: DaemonConnectionStore;
   startDesktopDaemon?: () => Promise<DesktopDaemonStatus>;
 }
 
+export async function upsertDesktopDaemonConnection(
+  store: DaemonConnectionStore,
+  daemon: DesktopDaemonStatus,
+): Promise<DaemonStartResult> {
+  const listenAddress = daemon.listen?.trim() ?? "";
+  const serverId = daemon.serverId.trim();
+  if (!listenAddress) {
+    return { ok: false, error: "Desktop daemon did not return a listen address." };
+  }
+  if (!serverId) {
+    return { ok: false, error: "Desktop daemon did not return a server id." };
+  }
+  if (!connectionFromListen(listenAddress)) {
+    return {
+      ok: false,
+      error: `Desktop daemon returned an unsupported listen address: ${listenAddress}`,
+    };
+  }
+  await store.upsertConnectionFromListen({
+    listenAddress,
+    serverId,
+    hostname: daemon.hostname,
+  });
+  return { ok: true };
+}
+
 export class DaemonStartService {
-  private readonly store: Pick<HostRuntimeStore, "upsertConnectionFromListen">;
+  private readonly store: DaemonConnectionStore;
   private readonly invokeStartDesktopDaemon: () => Promise<DesktopDaemonStatus>;
   private readonly listeners = new Set<() => void>();
   private lastError: string | null = null;
@@ -25,23 +53,8 @@ export class DaemonStartService {
     this.beginRequest();
     try {
       const daemon = await this.invokeStartDesktopDaemon();
-      const listenAddress = daemon.listen?.trim() ?? "";
-      const serverId = daemon.serverId.trim();
-      if (!listenAddress) {
-        return this.fail("Desktop daemon did not return a listen address.");
-      }
-      if (!serverId) {
-        return this.fail("Desktop daemon did not return a server id.");
-      }
-      if (!connectionFromListen(listenAddress)) {
-        return this.fail(`Desktop daemon returned an unsupported listen address: ${listenAddress}`);
-      }
-      await this.store.upsertConnectionFromListen({
-        listenAddress,
-        serverId,
-        hostname: daemon.hostname,
-      });
-      return { ok: true };
+      const result = await upsertDesktopDaemonConnection(this.store, daemon);
+      return result.ok ? result : this.fail(result.error);
     } catch (error) {
       return this.fail(error instanceof Error ? error.message : String(error));
     } finally {