feat(cli): enable daemon in binary via self-spawning

**Problem**: Daemon was disabled in binary builds because the separate
daemon script wasn't available in the compiled executable.

**Solution**: Binary now spawns itself in daemon mode using a special
--internal-daemon flag. This provides full terminal color polling in
both dev and binary modes with no external dependencies.

**Architecture**:
- Created entry.tsx as new entry point that routes based on flag
- Binary checks for --internal-daemon flag at startup
- If present: runs daemon logic (OSC polling + socket server)
- If absent: loads main CLI app (index.tsx)
- Theme system spawns binary itself instead of looking for script file

**Benefits**:
✅ Full theme detection in binary mode (terminal + IDE + OS)
✅ No external dependencies or file extraction needed
✅ Same codebase for dev and binary modes
✅ Clean process management with health checks

**Changes**:
- src/entry.tsx: New entry point with flag routing
- src/utils/terminal-theme-daemon-runner.ts: Wrapper for daemon main
- src/utils/terminal-theme-daemon.ts: Export runDaemonMain(), conditional auto-run
- src/utils/theme-system.ts: Self-spawn logic for binary mode
- scripts/build-binary.ts: Use entry.tsx as compilation entry point

**Testing**:
✅ Binary compiles successfully (78MB)
✅ Main process spawns daemon child process
✅ Socket communication works
✅ Clean cleanup on exit
✅ All 20 unit tests pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: brandonkachen

cli/scripts/build-binary.ts

@@ -156,7 +156,7 @@ async function main() {
 
   const buildArgs = [
     'build',
-    'src/index.tsx',
+    'src/entry.tsx',
     '--compile',
     `--target=${targetInfo.bunTarget}`,
     `--outfile=${outputFile}`,

cli/src/entry.tsx

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+/**
+ * Entry point for the CLI binary
+ * Checks --internal-daemon flag and routes to either daemon or main app
+ */
+
+// Check if running in daemon mode (self-spawned for terminal theme polling)
+if (process.argv.includes('--internal-daemon')) {
+  // Import and run daemon
+  import('./utils/terminal-theme-daemon-runner').then(async (mod) => {
+    try {
+      await mod.runDaemon()
+      // Daemon runs indefinitely, but if it exits:
+      process.exit(0)
+    } catch (err) {
+      console.error('Daemon error:', err)
+      process.exit(1)
+    }
+  })
+} else {
+  // Normal app mode - import and run main app
+  import('./index')
+}

cli/src/utils/terminal-theme-daemon-runner.ts

@@ -0,0 +1,11 @@
+/**
+ * Daemon runner - exports the daemon main function
+ * This is called when the binary is spawned with --internal-daemon flag
+ */
+
+// Import the daemon main function
+import { runDaemonMain } from './terminal-theme-daemon'
+
+export async function runDaemon() {
+  await runDaemonMain()
+}

cli/src/utils/terminal-theme-daemon.ts

@@ -15,7 +15,11 @@ const IDLE_EXIT_MS = 15_000
 const HEALTH_CHECK_INTERVAL_MS = 10_000
 
 // Socket configuration
-const SOCKET_PATH = process.env.SOCKET_PATH || '/tmp/codebuff-terminal-theme.sock'
+const SOCKET_PATH = process.env.SOCKET_PATH || (
+  process.platform === 'win32'
+    ? `\\\\.\\pipe\\codebuff-terminal-theme-${process.pid}`
+    : '/tmp/codebuff-terminal-theme.sock'
+)
 const PARENT_PID = process.env.PARENT_PID ? parseInt(process.env.PARENT_PID, 10) : null
 
 // Protocol constants
@@ -84,7 +88,9 @@ function cleanup() {
     if (server) server.close()
   } catch {}
   try {
-    if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH)
+    if (process.platform !== 'win32') {
+      if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH)
+    }
   } catch {}
   if (pollInterval) {
     try { clearInterval(pollInterval) } catch {}
@@ -116,12 +122,14 @@ async function pollAndBroadcast() {
   }
 }
 
-async function main() {
-  // Clean up stale socket
-  if (existsSync(SOCKET_PATH)) {
-    try {
-      unlinkSync(SOCKET_PATH)
-    } catch {}
+export async function runDaemonMain() {
+  // Clean up stale socket on Unix only; Windows named pipes are not filesystem entries
+  if (process.platform !== 'win32') {
+    if (existsSync(SOCKET_PATH)) {
+      try {
+        unlinkSync(SOCKET_PATH)
+      } catch {}
+    }
   }
 
   // Create Unix domain socket server
@@ -164,11 +172,13 @@ async function main() {
   })
 
   server.listen(SOCKET_PATH, () => {
-    // Set restrictive permissions (owner read/write only)
-    try {
-      chmodSync(SOCKET_PATH, 0o600)
-    } catch {
-      // Best effort; some platforms may not support chmod on sockets
+    // Set restrictive permissions (owner read/write only) on Unix domain sockets
+    if (process.platform !== 'win32') {
+      try {
+        chmodSync(SOCKET_PATH, 0o600)
+      } catch {
+        // Best effort; some platforms may not support chmod on sockets
+      }
     }
   })
 
@@ -180,14 +190,20 @@ async function main() {
     pollAndBroadcast().catch(() => {})
   }, POLL_INTERVAL_MS)
   // Don't keep the event loop alive for the interval alone
-  ;(pollInterval as any)?.unref?.()
+  const intervalTimer = pollInterval as any
+  if (intervalTimer?.unref) {
+    intervalTimer.unref()
+  }
 
   // Health check: verify parent process is still alive
   if (PARENT_PID) {
     healthCheckInterval = setInterval(() => {
       performHealthCheck()
     }, HEALTH_CHECK_INTERVAL_MS)
-    ;(healthCheckInterval as any)?.unref?.()
+    const healthTimer = healthCheckInterval as any
+    if (healthTimer?.unref) {
+      healthTimer.unref()
+    }
   }
 
   // If no one connects, exit after idle period
@@ -205,4 +221,7 @@ process.on('exit', () => cleanup())
 process.on('uncaughtException', () => { try { cleanup() } finally { process.exit(1) } })
 process.on('unhandledRejection', () => { try { cleanup() } finally { process.exit(1) } })
 
-main().catch(() => { try { cleanup() } finally { process.exit(1) } })
+// Only auto-run if executed directly (not imported)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runDaemonMain().catch(() => { try { cleanup() } finally { process.exit(1) } })
+}

cli/src/utils/theme-system.ts

@@ -282,6 +282,12 @@ function getSocketDir(): string {
  * Get socket path for daemon communication
  */
 function getSocketPath(): string {
+  // On Windows use a named pipe path: \\ . \pipe\<name>
+  if (process.platform === 'win32') {
+    // Keep name unique per-process to avoid collisions
+    return `\\\\.\\pipe\\codebuff-terminal-theme-${process.pid}`
+  }
+  // Unix-like: use a filesystem socket under a secure runtime dir
   const dir = getSocketDir()
   return join(dir, `codebuff-terminal-theme-${process.pid}.sock`)
 }
@@ -454,47 +460,56 @@ const startTerminalColorPolling = () => {
   // Allow disabling polling via env
   if (themeWatchDisabled()) return
 
-  // In compiled binary builds, skip external daemon spawn (no filesystem)
-  if (process.env.CODEBUFF_IS_BINARY === 'true') {
-    logger.debug(
-      { source: 'theme', reason: 'compiled-binary' },
-      'skip terminal polling in binary build',
-    )
-    return
-  }
-
   const supportsOSC = terminalLikelySupportsOSC()
   if (!supportsOSC) {
     logger.debug({ source: 'theme', reason: 'no-osc-support' }, 'skip terminal polling')
     return
   }
 
   try {
-    // Resolve compiled daemon in dist, fallback to TS in src during dev
-    const jsPathRoot = join(__dirname, 'terminal-theme-daemon.js')
-    const jsPathUtils = join(__dirname, 'utils', 'terminal-theme-daemon.js')
-    const tsPath = join(__dirname, 'terminal-theme-daemon.ts')
-    const daemonPath =
-      (existsSync(jsPathRoot) && jsPathRoot) ||
-      (existsSync(jsPathUtils) && jsPathUtils) ||
-      (existsSync(tsPath) && tsPath) ||
-      ''
-
-    logger.debug(
-      { source: 'theme', daemonPath, exists: existsSync(daemonPath) },
-      'resolved terminal theme daemon path',
-    )
+    // Determine the executable to spawn
+    // In binary mode: spawn ourselves with --internal-daemon flag
+    // In dev mode: spawn the TS file directly with bun/node
+    let daemonExec: string
+    let daemonArgs: string[]
+
+    if (process.env.CODEBUFF_IS_BINARY === 'true') {
+      // Binary build: use the current executable
+      daemonExec = process.execPath
+      daemonArgs = ['--internal-daemon']
+      logger.debug(
+        { source: 'theme', executable: daemonExec },
+        'spawning daemon from binary (self-spawn)',
+      )
+    } else {
+      // Dev mode: look for the daemon script
+      const jsPathRoot = join(__dirname, 'terminal-theme-daemon.js')
+      const jsPathUtils = join(__dirname, 'utils', 'terminal-theme-daemon.js')
+      const tsPath = join(__dirname, 'terminal-theme-daemon.ts')
+      const daemonPath =
+        (existsSync(jsPathRoot) && jsPathRoot) ||
+        (existsSync(jsPathUtils) && jsPathUtils) ||
+        (existsSync(tsPath) && tsPath) ||
+        ''
+
+      if (!daemonPath) {
+        logger.debug(
+          { source: 'theme' },
+          'no daemon script available; skipping terminal polling',
+        )
+        return
+      }
 
-    if (!daemonPath) {
+      daemonExec = process.execPath
+      daemonArgs = [daemonPath]
       logger.debug(
-        { source: 'theme' },
-        'no daemon path available; skipping terminal polling',
+        { source: 'theme', daemonPath },
+        'spawning daemon from script file',
       )
-      return
     }
 
     // Spawn completely detached with no stdio connection
-    pollerProcess = spawn(process.execPath, [daemonPath], {
+    pollerProcess = spawn(daemonExec, daemonArgs, {
       detached: true,
       stdio: 'ignore',
       env: {