Simplify daemon recovery and management

Author: backnotprop

apps/hook/server/index.ts

@@ -72,7 +72,7 @@ import {
   buildPlanFileRule,
 } from "@plannotator/shared/prompts";
 import { openBrowser } from "@plannotator/server/browser";
-import { discoverDaemon } from "@plannotator/server/daemon/client";
+import { cleanupDaemonState, discoverDaemon } from "@plannotator/server/daemon/client";
 import { startDaemonRuntime } from "@plannotator/server/daemon/runtime";
 import { createDaemonSessionFactory } from "@plannotator/server/daemon/session-factory";
 import { hostnameOrFallback } from "@plannotator/shared/project";
@@ -266,6 +266,15 @@ async function runDaemonCommand(): Promise<void> {
   if (command === "stop") {
     const daemon = await discoverDaemon({ validateEnvironment: false });
     if (!daemon.ok) {
+      if (daemon.state && (daemon.code === "incompatible" || daemon.code === "unhealthy")) {
+        await cleanupDaemonState(daemon.state);
+        console.log(JSON.stringify({ ok: true, stopped: true, recovered: daemon.code }));
+        process.exit(0);
+      }
+      if (daemon.code === "missing" || daemon.code === "stale" || daemon.code === "malformed") {
+        console.log(JSON.stringify({ ok: true, stopped: false, code: daemon.code, message: daemon.message }));
+        process.exit(0);
+      }
       console.log(JSON.stringify({ ok: false, code: daemon.code, message: daemon.message }));
       process.exit(1);
     }
@@ -280,7 +289,9 @@ async function runDaemonCommand(): Promise<void> {
       console.log(JSON.stringify({ ok: true, alreadyRunning: true, status: existing.status }));
       process.exit(0);
     }
-    if (existing.code === "incompatible" || existing.code === "unhealthy" || existing.code === "mismatch") {
+    if (existing.state && (existing.code === "incompatible" || existing.code === "unhealthy")) {
+      await cleanupDaemonState(existing.state);
+    } else if (existing.code === "mismatch") {
       console.log(JSON.stringify({ ok: false, code: existing.code, message: existing.message }));
       process.exit(1);
     }
@@ -401,7 +412,9 @@ async function ensureDaemonClient(options: { pluginError?: boolean } = {}) {
   const fail = options.pluginError ? emitPluginError : emitCommandError;
   const existing = await discoverDaemon();
   if (existing.ok) return existing.client;
-  if (existing.code === "incompatible" || existing.code === "unhealthy" || existing.code === "mismatch") {
+  if (existing.state && (existing.code === "incompatible" || existing.code === "unhealthy")) {
+    await cleanupDaemonState(existing.state);
+  } else if (existing.code === "mismatch") {
     fail(`daemon-${existing.code}`, existing.message);
   }
 
@@ -572,7 +585,7 @@ if (args[0] === "sessions") {
   // SESSION DISCOVERY MODE
   // ============================================
 
-  const daemon = await discoverDaemon();
+  const daemon = await discoverDaemon({ validateEnvironment: false });
   if (!daemon.ok) {
     console.error("No active Plannotator daemon.");
     process.exit(0);

packages/server/daemon/client.test.ts

@@ -1,10 +1,10 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { getDaemonCapabilities } from "@plannotator/shared/daemon-protocol";
-import { createDaemonState, writeDaemonState } from "./state";
-import { DaemonClient, discoverDaemon } from "./client";
+import { createDaemonState, getDaemonPaths, writeDaemonState } from "./state";
+import { cleanupDaemonState, DaemonClient, discoverDaemon } from "./client";
 
 let dirs: string[] = [];
 const envKeys = ["PLANNOTATOR_REMOTE", "PLANNOTATOR_PORT", "SSH_TTY", "SSH_CONNECTION"];
@@ -41,13 +41,12 @@ function state() {
     hostname: "127.0.0.1",
     isRemote: false,
     remoteSource: "local",
-    token: "token",
     startedAt: "2026-01-01T00:00:00.000Z",
   });
 }
 
 describe("DaemonClient", () => {
-  test("sends auth token and JSON body to daemon routes", async () => {
+  test("sends JSON body to daemon routes", async () => {
     const calls: Request[] = [];
     const client = new DaemonClient(state(), {
       fetch: async (input, init) => {
@@ -60,7 +59,7 @@ describe("DaemonClient", () => {
     await client.createSession({ request: { action: "plan", origin: "opencode", plan: "x" } });
 
     expect(calls[0].url).toBe("http://127.0.0.1:4321/daemon/sessions");
-    expect(calls[0].headers.get("authorization")).toBe("Bearer token");
+    expect(calls[0].headers.get("authorization")).toBeNull();
     expect(calls[0].headers.get("content-type")).toBe("application/json");
     expect(await calls[0].json()).toEqual({ request: { action: "plan", origin: "opencode", plan: "x" } });
   });
@@ -73,6 +72,26 @@ describe("DaemonClient", () => {
     expect(result.ok).toBe(false);
     expect(result.error.code).toBe("daemon-unhealthy");
   });
+
+  test("cleans daemon state and best-effort shuts down recorded endpoint", async () => {
+    const baseDir = tempBase();
+    const paths = getDaemonPaths({ baseDir });
+    writeDaemonState(state(), { baseDir });
+    writeFileSync(paths.lockPath, "123\n", "utf-8");
+    const calls: string[] = [];
+
+    await cleanupDaemonState(state(), {
+      baseDir,
+      fetch: async (input) => {
+        calls.push(String(input));
+        return Response.json({ ok: true });
+      },
+    });
+
+    expect(calls).toEqual(["http://127.0.0.1:4321/daemon/shutdown"]);
+    expect(existsSync(paths.statePath)).toBe(false);
+    expect(existsSync(paths.lockPath)).toBe(false);
+  });
 });
 
 describe("discoverDaemon", () => {

packages/server/daemon/client.ts

@@ -10,7 +10,7 @@ import {
   type DaemonStatus,
 } from "@plannotator/shared/daemon-protocol";
 import { getServerPort, isRemoteSession } from "../remote";
-import { readDaemonState, removeDaemonState, type DaemonState, type DaemonStateOptions } from "./state";
+import { readDaemonState, removeDaemonFiles, type DaemonState, type DaemonStateOptions } from "./state";
 
 export interface DaemonClientOptions extends DaemonStateOptions {
   fetch?: typeof fetch;
@@ -31,43 +31,42 @@ export class DaemonClient {
   }
 
   async capabilities(): Promise<unknown> {
-    return this.getJson("/daemon/capabilities", false);
+    return this.getJson("/daemon/capabilities");
   }
 
   async status(): Promise<DaemonStatus> {
-    return this.getJson("/daemon/status", true) as Promise<DaemonStatus>;
+    return this.getJson("/daemon/status") as Promise<DaemonStatus>;
   }
 
   async listSessions(): Promise<unknown> {
-    return this.getJson("/daemon/sessions", true);
+    return this.getJson("/daemon/sessions");
   }
 
   async createSession(request: DaemonCreateSessionRequest): Promise<DaemonCreateSessionResponse | DaemonErrorResponse> {
     return this.requestJson("/daemon/sessions", {
       method: "POST",
       body: JSON.stringify(request),
-    }, true) as Promise<DaemonCreateSessionResponse | DaemonErrorResponse>;
+    }) as Promise<DaemonCreateSessionResponse | DaemonErrorResponse>;
   }
 
   async waitForResult<T = unknown>(id: string): Promise<DaemonSessionResultResponse<T> | DaemonErrorResponse> {
-    return this.getJson(`/daemon/sessions/${encodeURIComponent(id)}/result`, true) as Promise<DaemonSessionResultResponse<T> | DaemonErrorResponse>;
+    return this.getJson(`/daemon/sessions/${encodeURIComponent(id)}/result`) as Promise<DaemonSessionResultResponse<T> | DaemonErrorResponse>;
   }
 
   async cancelSession(id: string): Promise<DaemonCancelSessionResponse | DaemonErrorResponse> {
-    return this.requestJson(`/daemon/sessions/${encodeURIComponent(id)}/cancel`, { method: "POST" }, true) as Promise<DaemonCancelSessionResponse | DaemonErrorResponse>;
+    return this.requestJson(`/daemon/sessions/${encodeURIComponent(id)}/cancel`, { method: "POST" }) as Promise<DaemonCancelSessionResponse | DaemonErrorResponse>;
   }
 
   async shutdown(): Promise<DaemonShutdownResponse | DaemonErrorResponse> {
-    return this.requestJson("/daemon/shutdown", { method: "POST" }, true) as Promise<DaemonShutdownResponse | DaemonErrorResponse>;
+    return this.requestJson("/daemon/shutdown", { method: "POST" }) as Promise<DaemonShutdownResponse | DaemonErrorResponse>;
   }
 
-  private async getJson(path: string, auth: boolean): Promise<unknown> {
-    return this.requestJson(path, { method: "GET" }, auth);
+  private async getJson(path: string): Promise<unknown> {
+    return this.requestJson(path, { method: "GET" });
   }
 
-  private async requestJson(path: string, init: RequestInit, auth: boolean): Promise<unknown> {
+  private async requestJson(path: string, init: RequestInit): Promise<unknown> {
     const headers = new Headers(init.headers);
-    if (auth) headers.set("authorization", `Bearer ${this.state.token}`);
     if (init.body && !headers.has("content-type")) headers.set("content-type", "application/json");
 
     const res = await this.fetchImpl(`${this.state.baseUrl}${path}`, {
@@ -82,17 +81,31 @@ export class DaemonClient {
   }
 }
 
+function stateBaseUrl(state: unknown): string | undefined {
+  const baseUrl = (state as { baseUrl?: unknown } | null)?.baseUrl;
+  return typeof baseUrl === "string" ? baseUrl : undefined;
+}
+
+export async function cleanupDaemonState(state: unknown, options: DaemonClientOptions = {}): Promise<void> {
+  const fetchImpl = options.fetch ?? fetch;
+  const baseUrl = stateBaseUrl(state);
+  if (baseUrl) {
+    await fetchImpl(`${baseUrl}/daemon/shutdown`, { method: "POST" }).catch(() => undefined);
+  }
+  removeDaemonFiles(options);
+}
+
 export async function discoverDaemon(options: DaemonClientOptions = {}): Promise<DaemonDiscoveryResult> {
   const stateResult = readDaemonState(options);
   if (stateResult.kind === "missing") {
     return { ok: false, code: "missing", message: "No Plannotator daemon state found." };
   }
   if (stateResult.kind === "malformed") {
-    removeDaemonState(options);
+    removeDaemonFiles(options);
     return { ok: false, code: "malformed", message: stateResult.error };
   }
   if (stateResult.kind === "stale") {
-    removeDaemonState(options);
+    removeDaemonFiles(options);
     return { ok: false, code: "stale", message: `Stale Plannotator daemon state for PID ${stateResult.state.pid}.`, state: stateResult.state };
   }
   if (stateResult.kind === "incompatible") {

packages/server/daemon/runtime.test.ts

@@ -28,7 +28,6 @@ describe("startDaemonRuntime", () => {
       baseDir,
       hostname: "127.0.0.1",
       port: 0,
-      token: "token",
       createSession: (_request, { endpoint }) => runtime.store.create({
         id: "s1",
         mode: "plan",
@@ -54,7 +53,6 @@ describe("startDaemonRuntime", () => {
       baseDir,
       hostname: "127.0.0.1",
       port: 0,
-      token: "token",
       createSession: (_request, { endpoint }) => runtime.store.create({
         id: "s1",
         mode: "plan",
@@ -69,7 +67,6 @@ describe("startDaemonRuntime", () => {
       baseDir,
       hostname: "127.0.0.1",
       port: 0,
-      token: "other",
       createSession: () => {
         throw new Error("should not create");
       },
@@ -82,7 +79,6 @@ describe("startDaemonRuntime", () => {
       baseDir,
       hostname: "127.0.0.1",
       port: 0,
-      token: "token",
       createSession: (_request, { endpoint }) => runtime.store.create({
         id: "s1",
         mode: "plan",
@@ -92,10 +88,7 @@ describe("startDaemonRuntime", () => {
       }),
     });
 
-    const res = await fetch(`${runtime.state.baseUrl}/daemon/shutdown`, {
-      method: "POST",
-      headers: { authorization: "Bearer token" },
-    });
+    const res = await fetch(`${runtime.state.baseUrl}/daemon/shutdown`, { method: "POST" });
     expect((await res.json()).shuttingDown).toBe(true);
     expect(readDaemonState({ baseDir }).kind).toBe("missing");
   });

packages/server/daemon/runtime.ts

@@ -12,7 +12,6 @@ export interface StartDaemonRuntimeOptions extends DaemonStateOptions {
   onShutdown?: () => void | Promise<void>;
   hostname?: string;
   port?: number;
-  token?: string;
   binaryVersion?: string;
 }
 
@@ -42,10 +41,11 @@ export async function startDaemonRuntime(options: StartDaemonRuntimeOptions): Pr
   const requestedPort = options.port ?? getServerPort();
   let runtime: DaemonRuntime | undefined;
   let cleanupTimer: ReturnType<typeof setInterval> | undefined;
+  let server: ReturnType<typeof Bun.serve> | undefined;
 
   try {
     let state: DaemonState | undefined;
-    const server = Bun.serve({
+    server = Bun.serve({
       hostname,
       port: requestedPort,
       fetch: (req, server) => {
@@ -70,7 +70,6 @@ export async function startDaemonRuntime(options: StartDaemonRuntimeOptions): Pr
       hostname,
       isRemote,
       remoteSource: getRemoteSource(),
-      token: options.token,
       binaryVersion: options.binaryVersion,
       requestedPort,
     });
@@ -79,17 +78,18 @@ export async function startDaemonRuntime(options: StartDaemonRuntimeOptions): Pr
       void store.cleanupExpired();
     }, 60_000);
 
+    const activeServer = server;
     runtime = {
       state,
       store,
-      server,
+      server: activeServer,
       stop: async () => {
         if (cleanupTimer) {
           clearInterval(cleanupTimer);
           cleanupTimer = undefined;
         }
         await store.cancelAll();
-        server.stop();
+        activeServer.stop();
         removeDaemonState(options);
         lock?.release();
         lock = undefined;
@@ -99,6 +99,7 @@ export async function startDaemonRuntime(options: StartDaemonRuntimeOptions): Pr
     return runtime;
   } catch (err) {
     if (cleanupTimer) clearInterval(cleanupTimer);
+    server?.stop();
     lock.release();
     throw err;
   }