Function ensureDaemon

apps/kimi-code/src/cli/sub/server/daemon.ts:291–369

(options: EnsureDaemonOptions = {})

 * detached process after this returns.
 */
export async function ensureDaemon(options: EnsureDaemonOptions = {}): Promise<EnsureDaemonResult> {
  const host = options.host ?? DEFAULT_SERVER_HOST;
  const preferred = options.port ?? DEFAULT_SERVER_PORT;
  const logLevel = options.logLevel ?? DEFAULT_DAEMON_LOG_LEVEL;

  // 1. Reuse an already-live daemon if one holds the lock.
  const existing = getLiveLock();
  if (existing) {
    const origin = serverOrigin(lockConnectHost(existing), existing.port);
    if (await waitForServerHealthy(origin, REUSE_HEALTH_TIMEOUT_MS)) {
      return {
        origin,
        reused: true,
        host: existing.host ?? DEFAULT_SERVER_HOST,
        port: existing.port,
      };
    }
    // Live pid but not responding (wedged or mid-boot failure). Fall through
    // and spawn: if it is truly wedged our child loses the lock race and we
    // reconnect below; if it died, stale takeover lets our child claim it.
  }

  // 2. No reusable daemon — pick a free port and spawn one detached.
  const port = await resolveDaemonPort(host, preferred);
  const child = spawnDaemonChild({
    host,
    port,
    logLevel,
    debugEndpoints: options.debugEndpoints,
    insecureNoTls: options.insecureNoTls,
    allowRemoteShutdown: options.allowRemoteShutdown,
    allowRemoteTerminals: options.allowRemoteTerminals,
    allowedHosts: options.allowedHosts,
    idleGraceMs: options.idleGraceMs,
  });

  // Watch for an early exit so a boot failure (e.g. the non-loopback TLS gate,
  // a config error, or a lost lock race with no other daemon to fall back to)
  // surfaces the real error immediately instead of waiting out the full spawn
  // timeout. The exit code/signal plus a tail of the daemon log is what tells
  // the operator *why* it failed.
  let childExit: { code: number | null; signal: NodeJS.Signals | null } | undefined;
  child.once('exit', (code, signal) => {
    childExit = { code, signal };
  });
  child.once('error', () => {
    // Spawn failure (ENOENT etc.) is already recorded in the log by
    // spawnDaemonChild; treat it as an early exit here.
    childExit = { code: -1, signal: null };
  });

  // 3. Wait until some live daemon (ours, or a racer that won the lock) is up.
  const deadline = Date.now() + SPAWN_TIMEOUT_MS;
  while (Date.now() < deadline) {
    const live = getLiveLock();
    if (live) {
      const origin = serverOrigin(lockConnectHost(live), live.port);
      if (await isServerHealthy(origin, 500)) {