Function spawnDaemonChild

apps/kimi-code/src/cli/sub/server/daemon.ts:209–278

(options: SpawnDaemonChildOptions)

}

export function spawnDaemonChild(options: SpawnDaemonChildOptions): ChildProcess {
  const program = resolveDaemonProgram();
  const logPath = daemonLogPath();
  const logDir = dirname(logPath);
  mkdirSync(logDir, { recursive: true });
  const args = [
    'server',
    'run',
    '--daemon',
    '--port',
    String(options.port),
    '--log-level',
    options.logLevel,
  ];
  if (options.host !== undefined) {
    args.push('--host', options.host);
  }
  if (options.debugEndpoints === true) {
    args.push('--debug-endpoints');
  }
  if (options.insecureNoTls === true) {
    args.push('--insecure-no-tls');
  }
  if (options.allowRemoteShutdown === true) {
    args.push('--allow-remote-shutdown');
  }
  if (options.allowRemoteTerminals === true) {
    args.push('--allow-remote-terminals');
  }
  if (options.idleGraceMs !== undefined) {
    args.push('--idle-grace-ms', String(options.idleGraceMs));
  }
  if (options.allowedHosts !== undefined && options.allowedHosts.length > 0) {
    args.push('--allowed-host', ...options.allowedHosts);
  }
  // On Windows `.mjs` files are not executable PE binaries, so we must run
  // the script through the Node binary rather than spawning it directly. In
  // SEA mode or when re-spawning from an already-running daemon, `program` is
  // `process.execPath` itself, so no script argument is needed.
  const execPath = process.execPath;
  const spawnArgs = program === execPath ? args : [program, ...args];

  const logFd = openSync(logPath, 'a');
  try {
    const child = spawn(execPath, spawnArgs, {
      detached: true,
      // Run from the server log directory instead of inheriting the caller's
      // cwd, so the long-lived daemon does not pin the directory it was
      // launched from (notably blocking its deletion on Windows).
      cwd: logDir,
      stdio: ['ignore', logFd, logFd],
    });
    child.once('error', (error) => {
      // A spawn failure (e.g. ENOENT) surfaces asynchronously on the child,
      // not as a thrown error. Without a listener Node would crash the parent
      // with an unhandled 'error' event; record it instead and let the polling
      // loop in `ensureDaemon` report the timeout.
      try {