Method start

src/mcp/daemon.ts:206–305

* Bind the socket, kick off engine init, and register signal handlers. The * lockfile body was already written atomically by `tryAcquireDaemonLock`, so * there is nothing to write here. The promise resolves once the server is * listening — the daemon then sticks around until idle/shutdown.

()

   * listening — the daemon then sticks around until idle/shutdown.
   */
  async start(): Promise<DaemonStartResult> {
    // Engine init is deliberately backgrounded — see #172. The first session
    // to land waits on `ensureInitialized` either way, and unloaded sessions
    // (cross-project tool calls only) shouldn't pay any open cost.
    void this.engine.ensureInitialized(this.projectRoot);

    // Walk the ordered socket candidates and bind the first that works. The
    // in-project path comes first; the deterministic tmpdir path is the fallback
    // for a filesystem that can't host an AF_UNIX node at all (ExFAT/FAT external
    // volumes, some network mounts, WSL2 DrvFs → ENOTSUP/EACCES; #997, #974). The
    // `listen` closure clears a stale socket (left by a SIGKILL'd previous daemon)
    // before each attempt — safe because we hold the lockfile, so no live daemon
    // owns it; without it `listen` would wedge on EADDRINUSE.
    const candidates = getDaemonSocketCandidates(this.projectRoot);
    const listen = (socketPath: string): Promise<net.Server> =>
      new Promise<net.Server>((resolve, reject) => {
        if (process.platform !== 'win32') {
          try { fs.unlinkSync(socketPath); } catch { /* not-exists is fine */ }
        }
        const server = net.createServer((socket) => this.handleConnection(socket));
        server.once('error', reject);
        server.listen(socketPath, () => {
          // POSIX: tighten permissions to user-only — the socket lives under
          // `.codegraph/` (git-ignored, maybe a shared FS) or tmpdir.
          if (process.platform !== 'win32') {
            try { fs.chmodSync(socketPath, 0o600); } catch { /* best-effort */ }
          }
          resolve(server);
        });
      });

    let bound: { server: net.Server; socketPath: string };
    try {
      bound = await bindFirstUsableSocket(candidates, listen, {
        onRelocate: (from, to, code) =>
          process.stderr.write(
            `[CodeGraph daemon] Socket ${from} unusable (${code}); relocating to ${to}.\n`
          ),
      });
    } catch (err) {
      // Every candidate failed (the last one, or a non-relocatable error like a
      // racing EADDRINUSE). We already hold the lockfile `tryAcquireDaemonLock`
      // wrote; release it and any partial sockets so the NEXT launcher doesn't
      // spin respawning us on a stale lock pointing at our now-dying pid. Then
      // re-throw so the caller (the bin's try/catch) exits this detached daemon
      // cleanly and every launcher falls back to direct mode (#974).
      this.cleanupLockfile();
      if (process.platform !== 'win32') {
        for (const candidate of candidates) {
          try { fs.unlinkSync(candidate); } catch { /* may not exist */ }
        }
      }
      throw err;
    }

    this.server = bound.server;
    // Adopt the path we ACTUALLY bound — it may be a tmpdir fallback past an
    // unusable in-project location. Everything downstream (lockfile, registry,