chore(windows): instrument detached daemon launch

packages/server/scripts/supervisor.ts

@@ -1,4 +1,5 @@
 import { fork, spawn, type ChildProcess } from "child_process";
+import { appendFileSync } from "node:fs";
 
 type WorkerLifecycleMessage =
   | {
@@ -12,6 +13,7 @@ type WorkerLifecycleMessage =
 type SupervisorOptions = {
   name: string;
   startupMessage: string;
+  launchLogPath?: string;
   resolveWorkerEntry: () => string;
   workerArgs?: string[];
   workerEnv?: NodeJS.ProcessEnv;
@@ -63,6 +65,28 @@ export function runSupervisor(options: SupervisorOptions): void {
     process.stderr.write(`[${options.name}] ${message}\n`);
   };
 
+  const logLaunch = (message: string, details?: Record<string, unknown>): void => {
+    if (!options.launchLogPath) {
+      return;
+    }
+
+    const line = [
+      new Date().toISOString(),
+      `[${options.name}]`,
+      `pid=${process.pid}`,
+      message,
+      details ? JSON.stringify(details) : "",
+    ]
+      .filter((part) => part.length > 0)
+      .join(" ");
+
+    try {
+      appendFileSync(options.launchLogPath, `${line}\n`, "utf-8");
+    } catch {
+      // Keep launch debugging best-effort so daemon startup behavior is unchanged.
+    }
+  };
+
   const exitSupervisor = (code: number): void => {
     if (exiting) {
       return;
@@ -92,11 +116,22 @@ export function runSupervisor(options: SupervisorOptions): void {
 
     const spawnSpec = resolveWorkerSpawnSpec?.(workerEntry) ?? null;
     if (spawnSpec) {
+      logLaunch("spawning worker via explicit spawn spec", {
+        workerEntry,
+        command: spawnSpec.command,
+        args: spawnSpec.args,
+        workerArgs,
+      });
       child = spawn(spawnSpec.command, spawnSpec.args, {
         stdio: ["inherit", "inherit", "inherit", "ipc"],
         env: spawnSpec.env ?? workerEnv,
       });
     } else {
+      logLaunch("spawning worker via fork", {
+        workerEntry,
+        workerArgs,
+        workerExecArgv,
+      });
       child = fork(workerEntry, workerArgs, {
         stdio: "inherit",
         env: workerEnv,
@@ -104,8 +139,35 @@ export function runSupervisor(options: SupervisorOptions): void {
       });
     }
 
+    logLaunch("worker spawn returned", {
+      childPid: child.pid ?? null,
+      connected: child.connected,
+      spawnfile: child.spawnfile,
+      spawnargs: child.spawnargs,
+    });
+
+    child.on("spawn", () => {
+      logLaunch("worker emitted spawn", {
+        childPid: child?.pid ?? null,
+      });
+    });
+
+    child.on("error", (error) => {
+      logLaunch("worker emitted error", {
+        childPid: child?.pid ?? null,
+        message: error.message,
+      });
+    });
+
     child.on("message", (msg: unknown) => {
       const lifecycleMessage = parseLifecycleMessage(msg);
+      logLaunch("worker emitted ipc message", {
+        childPid: child?.pid ?? null,
+        rawType:
+          typeof msg === "object" && msg !== null && "type" in msg
+            ? (msg as { type?: unknown }).type
+            : typeof msg,
+      });
       if (!lifecycleMessage) {
         return;
       }
@@ -119,6 +181,13 @@ export function runSupervisor(options: SupervisorOptions): void {
     });
 
     child.on("exit", (code, signal) => {
+      logLaunch("worker emitted exit", {
+        childPid: child?.pid ?? null,
+        code,
+        signal,
+        restarting,
+        shuttingDown,
+      });
       const exitDescriptor = describeExit(code, signal);
 
       if (shuttingDown) {
@@ -137,6 +206,20 @@ export function runSupervisor(options: SupervisorOptions): void {
       log(`Worker exited (${exitDescriptor}). Supervisor exiting.`);
       exitSupervisor(typeof code === "number" ? code : 0);
     });
+
+    child.on("close", (code, signal) => {
+      logLaunch("worker emitted close", {
+        childPid: child?.pid ?? null,
+        code,
+        signal,
+      });
+    });
+
+    child.on("disconnect", () => {
+      logLaunch("worker emitted disconnect", {
+        childPid: child?.pid ?? null,
+      });
+    });
   };
 
   const requestRestart = (reason: string) => {
@@ -169,6 +252,12 @@ export function runSupervisor(options: SupervisorOptions): void {
   process.on("SIGINT", () => forwardSignal("SIGINT"));
   process.on("SIGTERM", () => forwardSignal("SIGTERM"));
 
+  logLaunch("supervisor starting", {
+    startupMessage: options.startupMessage,
+    restartOnCrash,
+    workerArgs,
+    workerExecArgv,
+  });
   process.stdout.write(`[${options.name}] ${options.startupMessage}\n`);
   spawnWorker();
 }