fix(server): fix daemon startup race and reduce log bloat

The desktop app could time out connecting to the daemon on first launch because the PID file advertised a listen address before the HTTP server was actually listening. The supervisor now writes the PID lock with listen: null and updates it only after the worker sends a paseo:ready IPC message confirming the server is listening. - Rename daemon-runner.ts to supervisor-entrypoint.ts - PID lock acquired with listen: null, updated via paseo:ready IPC - Worker sends paseo:ready after httpServer.listen() resolves - Desktop polls until listen is non-null before returning to the app - Remove PASEO_PID_LOCK_MODE and external lock mode - Remove unnecessary env overrides (PASEO_HOME, PASEO_CORS_ORIGINS) from desktop daemon spawn - Reduce trace log bloat: inbound/outbound WebSocket messages now log only message type and payload size instead of full payloads - Supervisor restarts worker on SIGKILL (covers OOM)
2026-03-30 12:37:07 +07:00
parent e758734807
commit 8d0a9f9224
21 changed files with 198 additions and 147 deletions
@@ -0,0 +1,149 @@
+import { fileURLToPath } from "url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import {
+  acquirePidLock,
+  PidLockError,
+  releasePidLock,
+  updatePidLock,
+} from "../src/server/pid-lock.js";
+import { resolvePaseoHome } from "../src/server/paseo-home.js";
+import { runSupervisor } from "./supervisor.js";
+import { applySherpaLoaderEnv } from "../src/server/speech/providers/local/sherpa/sherpa-runtime-env.js";
+
+type DaemonRunnerConfig = {
+  devMode: boolean;
+  workerArgs: string[];
+};
+
+function parseConfig(argv: string[]): DaemonRunnerConfig {
+  let devMode = false;
+  const workerArgs: string[] = [];
+
+  for (const arg of argv) {
+    if (arg === "--dev") {
+      devMode = true;
+      continue;
+    }
+    workerArgs.push(arg);
+  }
+
+  return { devMode, workerArgs };
+}
+
+function resolveWorkerEntry(): string {
+  const candidates = [
+    fileURLToPath(new URL("../server/server/index.js", import.meta.url)),
+    fileURLToPath(new URL("../dist/server/server/index.js", import.meta.url)),
+    fileURLToPath(new URL("../src/server/index.ts", import.meta.url)),
+    fileURLToPath(new URL("../../src/server/index.ts", import.meta.url)),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+function resolveDevWorkerEntry(): string {
+  const candidate = fileURLToPath(new URL("../src/server/index.ts", import.meta.url));
+  if (!existsSync(candidate)) {
+    throw new Error(`Dev worker entry not found: ${candidate}`);
+  }
+  return candidate;
+}
+
+function resolveWorkerExecArgv(workerEntry: string): string[] {
+  return workerEntry.endsWith(".ts") ? ["--import", "tsx"] : [];
+}
+
+function resolvePackagedNodeEntrypointRunnerPath(currentScriptPath: string): string | null {
+  const packageMarker = `${path.sep}node_modules${path.sep}@getpaseo${path.sep}server${path.sep}`;
+  const markerIndex = currentScriptPath.lastIndexOf(packageMarker);
+  if (markerIndex === -1) {
+    return null;
+  }
+
+  const appRoot = currentScriptPath.slice(0, markerIndex);
+  const runnerPath = path.join(appRoot, "dist", "daemon", "node-entrypoint-runner.js");
+  return existsSync(runnerPath) ? runnerPath : null;
+}
+
+async function main(): Promise<void> {
+  const config = parseConfig(process.argv.slice(2));
+  const workerEntry = config.devMode ? resolveDevWorkerEntry() : resolveWorkerEntry();
+  const workerExecArgv = resolveWorkerExecArgv(workerEntry);
+  const workerEnv: NodeJS.ProcessEnv = { ...process.env };
+  const packagedNodeEntrypointRunner =
+    process.env.ELECTRON_RUN_AS_NODE === "1"
+      ? resolvePackagedNodeEntrypointRunnerPath(fileURLToPath(import.meta.url))
+      : null;
+
+  applySherpaLoaderEnv(workerEnv);
+
+  const paseoHome = resolvePaseoHome(workerEnv);
+
+  try {
+    await acquirePidLock(paseoHome, null, {
+      ownerPid: process.pid,
+    });
+  } catch (error) {
+    if (error instanceof PidLockError) {
+      process.stderr.write(`${error.message}\n`);
+      process.exit(1);
+      return;
+    }
+    throw error;
+  }
+
+  let lockReleased = false;
+  const releaseLock = async (): Promise<void> => {
+    if (lockReleased) {
+      return;
+    }
+    lockReleased = true;
+    await releasePidLock(paseoHome, {
+      ownerPid: process.pid,
+    });
+  };
+
+  runSupervisor({
+    name: "DaemonRunner",
+    startupMessage: config.devMode
+      ? "Starting daemon worker (dev mode, crash restarts enabled)"
+      : "Starting daemon worker (IPC restart enabled)",
+    resolveWorkerEntry: () => workerEntry,
+    workerArgs: config.workerArgs,
+    workerEnv,
+    workerExecArgv,
+    resolveWorkerSpawnSpec: packagedNodeEntrypointRunner
+      ? (resolvedWorkerEntry) => ({
+          command: process.execPath,
+          args: [
+            packagedNodeEntrypointRunner,
+            "node-script",
+            resolvedWorkerEntry,
+            ...config.workerArgs,
+          ],
+          env: {
+            ...workerEnv,
+            ELECTRON_RUN_AS_NODE: "1",
+          },
+        })
+      : undefined,
+    restartOnCrash: config.devMode,
+    onWorkerReady: async ({ listen }) => {
+      await updatePidLock(paseoHome, { listen }, { ownerPid: process.pid });
+    },
+    onSupervisorExit: releaseLock,
+  });
+}
+
+void main().catch((error) => {
+  const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});