jettypod 4.4.120 → 4.4.121

package/apps/dashboard/electron/main.js

@@ -1,2306 +0,0 @@
-const { app, BrowserWindow, Menu, dialog, shell, ipcMain } = require('electron');
-const { spawn, exec, execFile } = require('child_process');
-const { promisify } = require('util');
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-const path = require('path');
-const fs = require('fs');
-const http = require('http');
-const { WebSocketServer } = require('ws');
-const { registerIpcHandlers, closeDb } = require('./ipc-handlers');
-const { ingestCucumberResults, closeIngesterDb } = require('./test-results-ingester');
-const { autoUpdater } = require('electron-updater');
-const sessionManager = require('./session-manager');
-
-// Track child processes and servers for cleanup
-let nextProcess = null;
-let nextServer = null; // HTTP server for production Next.js
-let mainWindow = null;
-const windows = new Set(); // Track all open windows
-let wss = null;
-let dbPollInterval = null;
-let testResultsPollInterval = null;
-let worktreeCleanupInterval = null;
-let lastDbMtimes = { db: null, wal: null };
-let lastTestResultsMtime = null;
-// Map of worktree path → last mtime for cucumber-results.json
-const worktreeTestResultsMtimes = new Map();
-
-// Track Claude processes by session ID
-const claudeProcesses = new Map();
-
-// Track dev server processes by project path
-// Map: projectPath -> { process, port, command, status }
-const devServerProcesses = new Map();
-
-// Detect if running as packaged app
-const isPackaged = app.isPackaged;
-
-// Suppress noisy EGL GPU driver error logs (eglQueryDeviceAttribEXT: Bad attribute)
-app.commandLine.appendSwitch('enable-logging', 'stderr');
-app.commandLine.appendSwitch('log-level', '2');
-// Disable hardware acceleration to prevent GPU process crashes (exit_code=512)
-// that cause blank white screens. Software rendering is sufficient for this app.
-app.disableHardwareAcceleration();
-
-// Last-selected project persistence (for dev mode)
-const LAST_SELECTED_PROJECT_PATH = path.join(
-  process.env.HOME || process.env.USERPROFILE || '',
-  '.config', 'JettyPod', 'last-selected-project.json'
-);
-
-function readLastSelectedProject() {
-  try {
-    if (fs.existsSync(LAST_SELECTED_PROJECT_PATH)) {
-      const data = JSON.parse(fs.readFileSync(LAST_SELECTED_PROJECT_PATH, 'utf-8'));
-      return data.projectPath || null;
-    }
-  } catch {
-    // Ignore read errors - treat as no project selected
-  }
-  return null;
-}
-
-function writeLastSelectedProject(projectPath) {
-  const dir = path.dirname(LAST_SELECTED_PROJECT_PATH);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(LAST_SELECTED_PROJECT_PATH, JSON.stringify({ projectPath }));
-}
-
-// Paths - different for development vs production
-let dashboardDir;
-let projectRoot;
-let preloadPath;
-
-if (isPackaged) {
-  // In packaged app, resources are in app.asar or app directory
-  // process.resourcesPath points to Contents/Resources
-  dashboardDir = path.join(process.resourcesPath, 'app');
-  // For packaged app, project root is the user's project (not the app bundle)
-  // We'll use an environment variable or default to null (no project)
-  projectRoot = process.env.JETTYPOD_PROJECT_PATH || null;
-  preloadPath = path.join(dashboardDir, 'electron', 'preload.js');
-} else {
-  // Development mode - use last-selected project if available, otherwise show welcome
-  dashboardDir = path.join(__dirname, '..');
-  projectRoot = readLastSelectedProject();
-  if (projectRoot) {
-    process.env.JETTYPOD_PROJECT_PATH = projectRoot;
-  }
-  preloadPath = path.join(__dirname, 'preload.js');
-}
-
-// Check if a valid JettyPod project exists at the given path
-function hasValidProject(projectPath) {
-  if (!projectPath) return false;
-  const dbPath = path.join(projectPath, '.jettypod', 'work.db');
-  return fs.existsSync(dbPath);
-}
-
-// Determine the correct start URL based on auth state, Claude Code, and project status.
-// Used both at initial window creation and after OAuth callback.
-function getStartUrl() {
-  if (isPackaged && !isAuthenticated()) {
-    const authPage = hasLoggedInBefore() ? '/login' : '/signup';
-    log(`No auth token, showing ${authPage} screen`);
-    return `http://localhost:3000${authPage}`;
-  } else if (!claudeCodeInstalled) {
-    log('Claude Code not installed, showing install screen');
-    return 'http://localhost:3000/install-claude';
-  } else if (!claudeCodeAuthenticated) {
-    log('Claude Code not authenticated, showing connect screen');
-    return 'http://localhost:3000/connect-claude';
-  } else {
-    const hasProject = hasValidProject(projectRoot);
-    log(`Project configured: ${hasProject}, loading: ${hasProject ? '/' : '/welcome'}`);
-    return hasProject ? 'http://localhost:3000' : 'http://localhost:3000/welcome';
-  }
-}
-
-// Set the project root (called when user selects a project)
-async function setProjectRoot(newPath) {
-  projectRoot = newPath;
-  process.env.JETTYPOD_PROJECT_PATH = newPath;
-  log(`Project root set to: ${projectRoot}`);
-
-  // Persist for next launch (dev mode remembers last project)
-  writeLastSelectedProject(newPath);
-
-  // Restart database and test results polling for the new project
-  restartPolling();
-
-  // In dev mode, Next.js runs as a child process with its own copy of process.env.
-  // Notify it of the project change so it can update its env and close cached DB connections.
-  if (!isPackaged && nextProcess) {
-    await syncProjectToNextServer(newPath);
-  }
-}
-
-// Notify the Next.js dev server of a project path change
-function syncProjectToNextServer(projectPath) {
-  return new Promise((resolve) => {
-    const payload = JSON.stringify({ projectPath: projectPath || '' });
-    const req = http.request({
-      hostname: 'localhost',
-      port: 3000,
-      path: '/api/internal/set-project',
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
-    }, (res) => {
-      if (res.statusCode === 200) {
-        log('Next.js dev server updated with new project path');
-      } else {
-        log(`Warning: Failed to update Next.js dev server (status ${res.statusCode})`);
-      }
-      res.resume(); // drain the response
-      resolve();
-    });
-    req.on('error', (err) => {
-      log(`Warning: Could not reach Next.js dev server to update project: ${err.message}`);
-      resolve(); // resolve anyway — don't block project switch if dev server is unreachable
-    });
-    req.write(payload);
-    req.end();
-  });
-}
-
-// Get the main window for reloading after project selection
-function getMainWindow() {
-  return mainWindow;
-}
-
-// WebSocket configuration
-const WS_PORT = 47808;
-
-// Persistent log file for diagnostics
-const LOG_DIR = path.join(app.getPath('home'), 'Library', 'Logs', 'jettypod');
-const LOG_FILE = path.join(LOG_DIR, 'main.log');
-const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
-
-let logStream = null;
-
-function initLogFile() {
-  try {
-    fs.mkdirSync(LOG_DIR, { recursive: true });
-    // Rotate if too large
-    if (fs.existsSync(LOG_FILE)) {
-      const stats = fs.statSync(LOG_FILE);
-      if (stats.size > MAX_LOG_SIZE) {
-        const rotated = `${LOG_FILE}.1`;
-        if (fs.existsSync(rotated)) fs.unlinkSync(rotated);
-        fs.renameSync(LOG_FILE, rotated);
-      }
-    }
-    logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
-  } catch {
-    // Fall back to console-only logging
-  }
-}
-
-initLogFile();
-
-function log(msg) {
-  const line = `[${new Date().toISOString()}] [Electron] ${msg}`;
-  console.log(line);
-  if (logStream) {
-    logStream.write(line + '\n');
-  }
-}
-
-/**
- * Get path to bundled Node.js in the app resources.
- * Returns null if not found (e.g., in dev mode).
- */
-function getBundledNodePath() {
-  if (process.resourcesPath) {
-    const bundledPath = path.join(process.resourcesPath, 'node', 'bin');
-    if (fs.existsSync(path.join(bundledPath, 'node'))) {
-      return bundledPath;
-    }
-  }
-  return null;
-}
-
-/**
- * Get path where Claude Code will be installed.
- * Uses app-specific directory to avoid conflicts with system installs.
- */
-function getClaudeInstallPath() {
-  const home = process.env.HOME || '';
-  return path.join(home, '.jettypod', 'node_modules', '.bin');
-}
-
-/**
- * Get shell environment with proper PATH for spawning CLI tools like npm/claude.
- * GUI apps on macOS don't inherit the user's shell PATH, so we need to construct it.
- * This includes common locations for npm, homebrew, nvm, and other tools.
- */
-function getUserShell() {
-  return process.env.SHELL || '/bin/zsh';
-}
-
-function getShellEnv() {
-  const home = process.env.HOME || '';
-
-  // Priority paths (checked first)
-  const priorityPaths = [];
-
-  // Add JettyPod's Claude install location (highest priority)
-  priorityPaths.push(getClaudeInstallPath());
-
-  // Add bundled Node.js (for running Claude)
-  const bundledNode = getBundledNodePath();
-  if (bundledNode) {
-    priorityPaths.push(bundledNode);
-  }
-
-  // Common paths where npm/node might be installed (fallback for users who have it)
-  const additionalPaths = [
-    `${home}/.claude/local`,                   // Official Claude Code install script
-    '/usr/local/bin',                          // Homebrew (Intel Mac) / common location
-    '/opt/homebrew/bin',                       // Homebrew (Apple Silicon)
-    '/opt/homebrew/sbin',
-    `${home}/.nvm/current/bin`,                // nvm with 'current' alias
-    `${home}/.volta/bin`,                      // Volta
-    `${home}/.npm-global/bin`,                 // npm global (user-configured)
-    `${home}/.local/bin`,                      // Common user bin
-    `${home}/bin`,
-    '/usr/bin',
-    '/bin',
-    '/usr/sbin',
-    '/sbin',
-  ].filter(Boolean);
-
-  // Try to get active nvm node version if nvm is installed
-  const nvmDir = process.env.NVM_DIR || `${home}/.nvm`;
-  if (fs.existsSync(nvmDir)) {
-    // Check for .nvmrc or default version
-    const defaultPath = path.join(nvmDir, 'alias', 'default');
-    if (fs.existsSync(defaultPath)) {
-      try {
-        const defaultVersion = fs.readFileSync(defaultPath, 'utf-8').trim();
-        // Handle both direct versions and aliases like 'lts/*'
-        const versionDir = path.join(nvmDir, 'versions', 'node');
-        if (fs.existsSync(versionDir)) {
-          const versions = fs.readdirSync(versionDir).filter(v => v.startsWith('v'));
-          // Find matching version or latest
-          const match = versions.find(v => v.includes(defaultVersion)) || versions.sort().pop();
-          if (match) {
-            additionalPaths.unshift(path.join(versionDir, match, 'bin'));
-          }
-        }
-      } catch {
-        // Ignore errors reading nvm config
-      }
-    }
-  }
-
-  const existingPath = process.env.PATH || '';
-  const newPath = [...priorityPaths, ...additionalPaths, existingPath].join(':');
-
-  return {
-    ...process.env,
-    PATH: newPath,
-  };
-}
-
-/**
- * Clean up stale resources before starting servers
- * This handles cases where the app was force-quit and left behind:
- * - Next.js lock files
- * - Orphaned processes on port 3000
- * - Orphaned next-router-worker processes
- */
-async function cleanupStaleResources() {
-  log('Cleaning up stale resources...');
-
-  // 1. Remove Next.js lock file if it exists
-  const lockFilePath = path.join(dashboardDir, '.next', 'dev', 'lock');
-  if (fs.existsSync(lockFilePath)) {
-    try {
-      fs.unlinkSync(lockFilePath);
-      log(`Removed stale lock file: ${lockFilePath}`);
-    } catch (err) {
-      log(`Warning: Could not remove lock file: ${err.message}`);
-    }
-  }
-
-  // Helper to kill PIDs from a shell command
-  async function killPidsFromCommand(cmd, label) {
-    try {
-      const { stdout } = await execAsync(cmd, { encoding: 'utf-8' });
-      const pids = stdout.trim().split('\n').filter(Boolean);
-      for (const pid of pids) {
-        if (parseInt(pid, 10) === process.pid) continue;
-        try {
-          process.kill(parseInt(pid, 10), 'SIGKILL');
-          log(`Killed ${label}: PID ${pid}`);
-        } catch (killErr) {
-          log(`Could not kill PID ${pid}: ${killErr.message}`);
-        }
-      }
-    } catch (err) {
-      // Command failed or no processes found - that's fine
-    }
-  }
-
-  // 2. Kill any process using port 3000 (Next.js dev server port)
-  await killPidsFromCommand('lsof -ti:3000 2>/dev/null || true', 'stale process on port 3000');
-
-  // 3. Kill orphaned next-router-worker processes
-  await killPidsFromCommand('pgrep -f "next-router-worker" 2>/dev/null || true', 'orphaned next-router-worker');
-
-  // 4. Kill any orphaned node processes running our dev script
-  await killPidsFromCommand('pgrep -f "node.*next.*dev" 2>/dev/null || true', 'orphaned Next.js dev process');
-
-  log('Stale resource cleanup complete');
-}
-
-function startNextServer() {
-  return new Promise((resolve, reject) => {
-    if (isPackaged) {
-      // Production mode - run Next.js programmatically within Electron's Node
-      // (Can't spawn process.execPath as that's the Electron binary, not Node)
-      log('Starting Next.js production server (programmatic)...');
-      log(`Dashboard dir: ${dashboardDir}`);
-
-      // Set environment before requiring Next
-      process.env.NODE_ENV = 'production';
-      process.env.JETTYPOD_IS_PACKAGED = '1';  // Signal to Next.js this is packaged app
-      process.env.JETTYPOD_RESOURCES_PATH = process.resourcesPath;  // For migrations to find bundled files
-      // Only set project path if we have one (don't set null which becomes string "null")
-      if (projectRoot) {
-        process.env.JETTYPOD_PROJECT_PATH = projectRoot;
-      }
-      // Set enhanced PATH so API routes can find claude CLI
-      process.env.PATH = getShellEnv().PATH;
-
-      // Change to dashboard dir so Next.js finds its config
-      const originalCwd = process.cwd();
-      process.chdir(dashboardDir);
-
-      try {
-        // Require Next.js from the packaged app's node_modules
-        const next = require(path.join(dashboardDir, 'node_modules', 'next'));
-
-        const nextApp = next({
-          dev: false,
-          dir: dashboardDir,
-          conf: {
-            distDir: '.next'
-          }
-        });
-
-        const handle = nextApp.getRequestHandler();
-
-        nextApp.prepare().then(() => {
-          nextServer = http.createServer((req, res) => {
-            handle(req, res);
-          });
-
-          nextServer.listen(3000, (err) => {
-            if (err) {
-              log(`Next.js server error: ${err.message}`);
-              reject(err);
-              return;
-            }
-            log('Next.js production server ready on http://localhost:3000');
-            resolve();
-          });
-        }).catch((err) => {
-          log(`Next.js prepare error: ${err.message}`);
-          process.chdir(originalCwd);
-          reject(err);
-        });
-      } catch (err) {
-        log(`Next.js require error: ${err.message}`);
-        process.chdir(originalCwd);
-        reject(err);
-      }
-    } else {
-      // Development mode - run npm run dev as child process
-      log('Starting Next.js dev server...');
-
-      nextProcess = spawn('npm', ['run', 'dev'], {
-        cwd: dashboardDir,
-        shell: true,
-        detached: true,  // Create process group for reliable cleanup
-        env: {
-          ...process.env,
-          JETTYPOD_PROJECT_PATH: projectRoot
-        }
-      });
-
-      let resolved = false;
-
-      nextProcess.stdout.on('data', (data) => {
-        const text = data.toString();
-        process.stdout.write(`[Next.js] ${text}`);
-
-        // Detect when server is ready
-        if (!resolved && (text.includes('Ready in') || text.includes('localhost:3000') || text.includes('started server'))) {
-          resolved = true;
-          log('Next.js server ready');
-          resolve();
-        }
-      });
-
-      nextProcess.stderr.on('data', (data) => {
-        process.stderr.write(`[Next.js] ${data}`);
-      });
-
-      nextProcess.on('error', (err) => {
-        log(`Next.js spawn error: ${err.message}`);
-        if (!resolved) reject(err);
-      });
-
-      nextProcess.on('exit', (code) => {
-        log(`Next.js exited with code ${code}`);
-        nextProcess = null;
-      });
-
-      // Timeout fallback - assume ready after 10 seconds
-      setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          log('Next.js server assumed ready (timeout)');
-          resolve();
-        }
-      }, 10000);
-    }
-  });
-}
-
-// ==================== Embedded WebSocket Server ====================
-// (Moved from apps/ws-server/server.js)
-
-const wsClients = new Set();
-const DB_POLL_MS = 500; // Poll database every 500ms (same as lib/db-watcher.js)
-
-function broadcastToClients(message) {
-  const payload = JSON.stringify(message);
-  for (const client of wsClients) {
-    if (client.readyState === 1) { // WebSocket.OPEN
-      client.send(payload);
-    }
-  }
-}
-
-// Watch database file for changes using polling (WAL-aware)
-// SQLite in WAL mode writes to the -wal file first, so we must watch both files
-function startDatabasePolling() {
-  if (!projectRoot) {
-    log(`[WS] No project selected, skipping database watcher`);
-    return;
-  }
-
-  const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
-
-  if (!fs.existsSync(dbPath)) {
-    log(`[WS] Database not found at ${dbPath}, waiting...`);
-    setTimeout(startDatabasePolling, 5000);
-    return;
-  }
-
-  // Initialize last modification times
-  try {
-    const dbStats = fs.statSync(dbPath);
-    lastDbMtimes.db = dbStats.mtimeMs;
-
-    // Also check WAL file (SQLite in WAL mode writes here first)
-    const walPath = dbPath + '-wal';
-    if (fs.existsSync(walPath)) {
-      const walStats = fs.statSync(walPath);
-      lastDbMtimes.wal = walStats.mtimeMs;
-    }
-  } catch (err) {
-    log(`[WS] Failed to get initial db stats: ${err.message}`);
-    return;
-  }
-
-  log(`[WS] Polling database for changes (WAL-aware)...`);
-
-  // Use polling instead of fs.watch - more reliable for SQLite WAL mode
-  dbPollInterval = setInterval(() => {
-    try {
-      let changed = false;
-
-      // Check main db file
-      const dbStats = fs.statSync(dbPath);
-      if (dbStats.mtimeMs !== lastDbMtimes.db) {
-        lastDbMtimes.db = dbStats.mtimeMs;
-        changed = true;
-      }
-
-      // Check WAL file (where SQLite writes first in WAL mode)
-      const walPath = dbPath + '-wal';
-      if (fs.existsSync(walPath)) {
-        const walStats = fs.statSync(walPath);
-        if (walStats.mtimeMs !== lastDbMtimes.wal) {
-          lastDbMtimes.wal = walStats.mtimeMs;
-          changed = true;
-        }
-      }
-
-      if (changed) {
-        log(`[WS] Database changed`);
-        broadcastToClients({
-          type: 'db_change',
-          timestamp: Date.now()
-        });
-      }
-    } catch {
-      // File might be temporarily locked during writes - ignore
-    }
-  }, DB_POLL_MS);
-}
-
-// Get active worktree paths from SQLite
-function getActiveWorktreePaths() {
-  if (!projectRoot) return [];
-  const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
-  if (!fs.existsSync(dbPath)) return [];
-  try {
-    const Database = require('better-sqlite3');
-    const db = new Database(dbPath, { readonly: true });
-    const rows = db.prepare("SELECT worktree_path FROM worktrees WHERE status = 'active'").all();
-    db.close();
-    return rows.map(r => r.worktree_path).filter(p => fs.existsSync(p));
-  } catch {
-    return [];
-  }
-}
-
-// Periodic worktree cleanup — catches orphaned worktrees from done/cancelled items
-const WORKTREE_CLEANUP_MS = 60000; // 60 seconds
-
-function startWorktreeCleanup() {
-  if (!projectRoot) {
-    log('[cleanup] No project selected, skipping worktree cleanup');
-    return;
-  }
-
-  log('[cleanup] Starting periodic worktree cleanup (every 60s)');
-
-  worktreeCleanupInterval = setInterval(() => {
-    if (!projectRoot) return;
-
-    const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
-    if (!fs.existsSync(dbPath)) return;
-
-    try {
-      const Database = require('better-sqlite3');
-      const db = new Database(dbPath, { readonly: true });
-      const orphans = db.prepare(`
-        SELECT w.id as worktree_id, w.work_item_id, w.worktree_path, wi.status as work_status
-        FROM worktrees w
-        JOIN work_items wi ON w.work_item_id = wi.id
-        WHERE w.status IN ('active', 'merged')
-        AND wi.status IN ('done', 'cancelled')
-      `).all();
-      db.close();
-
-      if (orphans.length === 0) return;
-
-      log(`[cleanup] Found ${orphans.length} orphaned worktree(s), running cleanup...`);
-
-      // Shell out to jettypod CLI for the actual cleanup (non-blocking)
-      const cliPath = getBundledCliPath();
-      execAsync(`"${cliPath}" work cleanup`, { cwd: projectRoot, timeout: 30000 })
-        .then(({ stdout }) => {
-          if (stdout && stdout.trim()) {
-            log(`[cleanup] ${stdout.trim()}`);
-          }
-        })
-        .catch((err) => {
-          log(`[cleanup] Cleanup failed: ${err.message}`);
-        });
-    } catch {
-      // Silently ignore — will retry on next interval
-    }
-  }, WORKTREE_CLEANUP_MS);
-}
-
-// Check a single cucumber-results.json path for changes, ingest + broadcast if changed
-function checkTestResultsFile(resultsPath, mtimeKey, getMtime, setMtime) {
-  if (!fs.existsSync(resultsPath)) {
-    if (getMtime() !== null) setMtime(null);
-    return;
-  }
-
-  const stats = fs.statSync(resultsPath);
-  if (stats.mtimeMs !== getMtime()) {
-    setMtime(stats.mtimeMs);
-    log(`[WS] Test results changed: ${resultsPath}`);
-
-    try {
-      const count = ingestCucumberResults(projectRoot, resultsPath);
-      if (count > 0) {
-        log(`[WS] Ingested ${count} test results into database`);
-      }
-    } catch (err) {
-      log(`[WS] Failed to ingest test results: ${err.message}`);
-    }
-
-    broadcastToClients({
-      type: 'test_change',
-      timestamp: Date.now()
-    });
-  }
-}
-
-// Watch for test results file changes (cucumber-results.json)
-// Monitors both projectRoot and all active worktrees
-function startTestResultsPolling() {
-  if (!projectRoot) {
-    log(`[WS] No project selected, skipping test results watcher`);
-    return;
-  }
-
-  const testResultsPath = path.join(projectRoot, 'cucumber-results.json');
-
-  // Initialize last modification time if file exists
-  if (fs.existsSync(testResultsPath)) {
-    try {
-      const stats = fs.statSync(testResultsPath);
-      lastTestResultsMtime = stats.mtimeMs;
-      log(`[WS] Watching test results at ${testResultsPath}`);
-    } catch (err) {
-      log(`[WS] Failed to get initial test results stats: ${err.message}`);
-    }
-  } else {
-    log(`[WS] Test results file not found at ${testResultsPath}, will watch for creation`);
-  }
-
-  // Refresh worktree list periodically (every 10s via counter)
-  let worktreePaths = getActiveWorktreePaths();
-  let tickCount = 0;
-  const WORKTREE_REFRESH_TICKS = Math.round(10000 / DB_POLL_MS); // ~10 seconds
-
-  if (worktreePaths.length > 0) {
-    log(`[WS] Also watching ${worktreePaths.length} active worktree(s) for test results`);
-  }
-
-  // Poll for test results changes
-  testResultsPollInterval = setInterval(() => {
-    try {
-      // Check main project root
-      checkTestResultsFile(
-        testResultsPath,
-        'root',
-        () => lastTestResultsMtime,
-        (v) => { lastTestResultsMtime = v; }
-      );
-
-      // Check active worktrees
-      for (const wtPath of worktreePaths) {
-        const wtResultsPath = path.join(wtPath, 'cucumber-results.json');
-        checkTestResultsFile(
-          wtResultsPath,
-          wtPath,
-          () => worktreeTestResultsMtimes.get(wtPath) ?? null,
-          (v) => {
-            if (v === null) {
-              worktreeTestResultsMtimes.delete(wtPath);
-            } else {
-              worktreeTestResultsMtimes.set(wtPath, v);
-            }
-          }
-        );
-      }
-
-      // Periodically refresh worktree list
-      tickCount++;
-      if (tickCount >= WORKTREE_REFRESH_TICKS) {
-        tickCount = 0;
-        const newPaths = getActiveWorktreePaths();
-        // Clean up mtimes for removed worktrees
-        for (const oldPath of worktreePaths) {
-          if (!newPaths.includes(oldPath)) {
-            worktreeTestResultsMtimes.delete(oldPath);
-          }
-        }
-        worktreePaths = newPaths;
-      }
-    } catch {
-      // File might be temporarily locked during writes - ignore
-    }
-  }, DB_POLL_MS);
-}
-
-// Stop and restart polling for the current projectRoot.
-// Called when the user selects/switches a project after app startup.
-function restartPolling() {
-  // Stop existing polling
-  if (dbPollInterval) {
-    clearInterval(dbPollInterval);
-    dbPollInterval = null;
-    lastDbMtimes = { db: null, wal: null };
-  }
-  if (testResultsPollInterval) {
-    clearInterval(testResultsPollInterval);
-    testResultsPollInterval = null;
-    lastTestResultsMtime = null;
-    worktreeTestResultsMtimes.clear();
-  }
-  if (worktreeCleanupInterval) {
-    clearInterval(worktreeCleanupInterval);
-    worktreeCleanupInterval = null;
-  }
-
-  // Start polling for the new project
-  startDatabasePolling();
-  startTestResultsPolling();
-  startWorktreeCleanup();
-}
-
-function isPortInUse(port) {
-  return new Promise((resolve) => {
-    const net = require('net');
-    const server = net.createServer();
-    server.once('error', (err) => {
-      resolve(err.code === 'EADDRINUSE');
-    });
-    server.once('listening', () => {
-      server.close();
-      resolve(false);
-    });
-    server.listen(port);
-  });
-}
-
-function startEmbeddedWebSocketServer() {
-  return new Promise(async (resolve, reject) => {
-    log('Starting embedded WebSocket server...');
-
-    // Skip if standalone ws-server.js is already running (e.g. npm run dev)
-    if (await isPortInUse(WS_PORT)) {
-      log(`[WS] Port ${WS_PORT} already in use — standalone WS server detected, skipping`);
-      resolve();
-      return;
-    }
-
-    try {
-      wss = new WebSocketServer({ port: WS_PORT });
-
-      wss.on('connection', (ws) => {
-        wsClients.add(ws);
-        log(`[WS] Client connected. Total clients: ${wsClients.size}`);
-
-        // Send initial connection confirmation
-        ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
-
-        ws.on('close', () => {
-          wsClients.delete(ws);
-          log(`[WS] Client disconnected. Total clients: ${wsClients.size}`);
-        });
-
-        ws.on('error', (error) => {
-          log(`[WS] WebSocket error: ${error.message}`);
-          ws.close();
-          wsClients.delete(ws);
-        });
-      });
-
-      wss.on('error', (err) => {
-        log(`[WS] Server error: ${err.message}`);
-        reject(err);
-      });
-
-      startDatabasePolling();
-      startTestResultsPolling();
-      startWorktreeCleanup();
-
-      log(`[WS] WebSocket server running on ws://localhost:${WS_PORT}`);
-      resolve();
-    } catch (err) {
-      log(`[WS] Failed to start WebSocket server: ${err.message}`);
-      reject(err);
-    }
-  });
-}
-
-function stopWebSocketServer() {
-  if (dbPollInterval) {
-    clearInterval(dbPollInterval);
-    dbPollInterval = null;
-    lastDbMtimes = { db: null, wal: null };
-    log('[WS] Database polling stopped');
-  }
-
-  if (testResultsPollInterval) {
-    clearInterval(testResultsPollInterval);
-    testResultsPollInterval = null;
-    lastTestResultsMtime = null;
-    worktreeTestResultsMtimes.clear();
-    log('[WS] Test results polling stopped');
-  }
-
-  if (worktreeCleanupInterval) {
-    clearInterval(worktreeCleanupInterval);
-    worktreeCleanupInterval = null;
-    log('[cleanup] Worktree cleanup stopped');
-  }
-
-  if (wss) {
-    // Close all client connections
-    for (const client of wsClients) {
-      client.close();
-    }
-    wsClients.clear();
-
-    wss.close(() => {
-      log('[WS] WebSocket server closed');
-    });
-    wss = null;
-  }
-}
-
-// ==================== Claude Subprocess Management ====================
-
-function spawnClaude(sessionId, cwd) {
-  // Kill existing process for this session if any
-  if (claudeProcesses.has(sessionId)) {
-    killClaude(sessionId);
-  }
-
-  log(`[Claude] Spawning for session ${sessionId} in ${cwd}`);
-
-  const claudeProcess = spawn(getUserShell(), ['-lc', 'claude'], {
-    cwd: cwd || projectRoot,
-    env: {
-      ...getShellEnv(),
-      JETTYPOD_PROJECT_PATH: projectRoot
-    }
-  });
-
-  claudeProcesses.set(sessionId, claudeProcess);
-
-  claudeProcess.stdout.on('data', (data) => {
-    const text = data.toString();
-    log(`[Claude:${sessionId}] stdout: ${text.substring(0, 100)}...`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('claude:output', {
-        sessionId,
-        type: 'stdout',
-        data: text
-      });
-    }
-  });
-
-  claudeProcess.stderr.on('data', (data) => {
-    const text = data.toString();
-    log(`[Claude:${sessionId}] stderr: ${text.substring(0, 100)}...`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('claude:output', {
-        sessionId,
-        type: 'stderr',
-        data: text
-      });
-    }
-  });
-
-  claudeProcess.on('error', (err) => {
-    log(`[Claude:${sessionId}] spawn error: ${err.message}`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('claude:output', {
-        sessionId,
-        type: 'error',
-        data: err.message
-      });
-    }
-    claudeProcesses.delete(sessionId);
-  });
-
-  claudeProcess.on('exit', (code, signal) => {
-    log(`[Claude:${sessionId}] exited with code ${code}, signal ${signal}`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('claude:output', {
-        sessionId,
-        type: 'exit',
-        code,
-        signal
-      });
-    }
-    claudeProcesses.delete(sessionId);
-  });
-
-  return { success: true, sessionId };
-}
-
-function writeToClaudeStdin(sessionId, text) {
-  const claudeProcess = claudeProcesses.get(sessionId);
-  if (!claudeProcess) {
-    log(`[Claude:${sessionId}] No process found for write`);
-    return { success: false, error: 'No process found' };
-  }
-
-  log(`[Claude:${sessionId}] Writing to stdin: ${text.substring(0, 50)}...`);
-  claudeProcess.stdin.write(text);
-  return { success: true };
-}
-
-function killClaude(sessionId) {
-  const claudeProcess = claudeProcesses.get(sessionId);
-  if (!claudeProcess) {
-    log(`[Claude:${sessionId}] No process found to kill`);
-    return { success: false, error: 'No process found' };
-  }
-
-  log(`[Claude:${sessionId}] Killing process`);
-  claudeProcess.stdin.destroy();
-  claudeProcess.kill('SIGTERM');
-  claudeProcesses.delete(sessionId);
-  return { success: true };
-}
-
-function killAllClaudeProcesses() {
-  log(`[Claude] Killing all ${claudeProcesses.size} processes`);
-  for (const [sessionId, process] of claudeProcesses) {
-    log(`[Claude] Killing session ${sessionId}`);
-    process.stdin.destroy();
-    process.kill('SIGTERM');
-  }
-  claudeProcesses.clear();
-}
-
-// ==================== Dev Server Management ====================
-
-function spawnDevServer(projectPath, command = 'npm run dev', port = 3001) {
-  // Kill existing server for this project if any
-  if (devServerProcesses.has(projectPath)) {
-    killDevServer(projectPath);
-  }
-
-  log(`[DevServer] Spawning for ${projectPath} on port ${port}`);
-  log(`[DevServer] Command: ${command}`);
-
-  // Parse command into command and args
-  const [cmd, ...args] = command.split(' ');
-
-  const devProcess = spawn(cmd, args, {
-    cwd: projectPath,
-    shell: true,
-    env: {
-      ...process.env,
-      PORT: String(port),
-      JETTYPOD_PROJECT_PATH: projectRoot
-    }
-  });
-
-  const serverInfo = {
-    process: devProcess,
-    port,
-    command,
-    status: 'starting',
-    startedAt: Date.now()
-  };
-
-  devServerProcesses.set(projectPath, serverInfo);
-
-  devProcess.stdout.on('data', (data) => {
-    const text = data.toString();
-    log(`[DevServer:${port}] stdout: ${text.substring(0, 100)}...`);
-
-    // Detect common "ready" signals
-    if (serverInfo.status === 'starting') {
-      const readySignals = ['Ready', 'Listening', 'started', 'running on', 'localhost:'];
-      if (readySignals.some(signal => text.toLowerCase().includes(signal.toLowerCase()))) {
-        serverInfo.status = 'running';
-        log(`[DevServer:${port}] Server is ready`);
-      }
-    }
-
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('devServer:output', {
-        projectPath,
-        port,
-        type: 'stdout',
-        data: text
-      });
-    }
-  });
-
-  devProcess.stderr.on('data', (data) => {
-    const text = data.toString();
-    log(`[DevServer:${port}] stderr: ${text.substring(0, 100)}...`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('devServer:output', {
-        projectPath,
-        port,
-        type: 'stderr',
-        data: text
-      });
-    }
-  });
-
-  devProcess.on('error', (err) => {
-    log(`[DevServer:${port}] spawn error: ${err.message}`);
-    serverInfo.status = 'error';
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('devServer:output', {
-        projectPath,
-        port,
-        type: 'error',
-        data: err.message
-      });
-    }
-    devServerProcesses.delete(projectPath);
-  });
-
-  devProcess.on('exit', (code, signal) => {
-    log(`[DevServer:${port}] exited with code ${code}, signal ${signal}`);
-    if (mainWindow && !mainWindow.isDestroyed()) {
-      mainWindow.webContents.send('devServer:output', {
-        projectPath,
-        port,
-        type: 'exit',
-        code,
-        signal
-      });
-    }
-    devServerProcesses.delete(projectPath);
-  });
-
-  return { success: true, projectPath, port };
-}
-
-function killDevServer(projectPath) {
-  const serverInfo = devServerProcesses.get(projectPath);
-  if (!serverInfo) {
-    log(`[DevServer] No server found for ${projectPath}`);
-    return { success: false, error: 'No server found' };
-  }
-
-  log(`[DevServer] Killing server for ${projectPath} on port ${serverInfo.port}`);
-  serverInfo.process.kill('SIGTERM');
-  devServerProcesses.delete(projectPath);
-  return { success: true };
-}
-
-function getDevServerStatus(projectPath) {
-  const serverInfo = devServerProcesses.get(projectPath);
-  if (!serverInfo) {
-    return { running: false };
-  }
-  return {
-    running: true,
-    port: serverInfo.port,
-    command: serverInfo.command,
-    status: serverInfo.status,
-    startedAt: serverInfo.startedAt
-  };
-}
-
-function listDevServers() {
-  const servers = [];
-  for (const [projectPath, serverInfo] of devServerProcesses) {
-    servers.push({
-      projectPath,
-      port: serverInfo.port,
-      command: serverInfo.command,
-      status: serverInfo.status,
-      startedAt: serverInfo.startedAt
-    });
-  }
-  return servers;
-}
-
-function killAllDevServers() {
-  log(`[DevServer] Killing all ${devServerProcesses.size} servers`);
-  for (const [projectPath, serverInfo] of devServerProcesses) {
-    log(`[DevServer] Killing server for ${projectPath}`);
-    serverInfo.process.kill('SIGTERM');
-  }
-  devServerProcesses.clear();
-}
-
-// Export for IPC handlers
-module.exports = {
-  spawnClaude,
-  writeToClaudeStdin,
-  killClaude,
-  getClaudeProcesses: () => claudeProcesses,
-  spawnDevServer,
-  killDevServer,
-  getDevServerStatus,
-  listDevServers,
-  setProjectRoot,
-  getMainWindow,
-  writeLastSelectedProject,
-  installClaudeCode,
-  updateClaudeCode,
-  getClaudeCodeInstalled,
-  getClaudeCodeAuthenticated,
-  checkClaudeCodeAuthenticated,
-  loginClaudeCode
-};
-
-// ==================== Application Menu ====================
-
-function buildApplicationMenu() {
-  const isMac = process.platform === 'darwin';
-
-  const template = [
-    // App menu (macOS only)
-    ...(isMac ? [{
-      label: app.name,
-      submenu: [
-        { role: 'about' },
-        { type: 'separator' },
-        { role: 'services' },
-        { type: 'separator' },
-        { role: 'hide' },
-        { role: 'hideOthers' },
-        { role: 'unhide' },
-        { type: 'separator' },
-        { role: 'quit' }
-      ]
-    }] : []),
-    // File menu
-    {
-      label: 'File',
-      submenu: [
-        {
-          label: 'New Window',
-          accelerator: 'CmdOrCtrl+Shift+N',
-          click: () => {
-            createNewWindow();
-          }
-        },
-        {
-          label: 'Open Folder...',
-          accelerator: 'CmdOrCtrl+O',
-          click: async () => {
-            await openFolder();
-          }
-        },
-        {
-          label: 'Switch Project...',
-          accelerator: 'CmdOrCtrl+Shift+O',
-          click: () => {
-            if (mainWindow) {
-              projectRoot = null;
-              process.env.JETTYPOD_PROJECT_PATH = '';
-              // Sync the cleared project to Next.js dev server
-              if (!isPackaged && nextProcess) {
-                syncProjectToNextServer('');
-              }
-              mainWindow.loadURL('http://localhost:3000/welcome');
-              log('Navigated to project selection screen');
-            }
-          }
-        },
-        { type: 'separator' },
-        isMac ? { role: 'close' } : { role: 'quit' }
-      ]
-    },
-    // Edit menu
-    {
-      label: 'Edit',
-      submenu: [
-        { role: 'undo' },
-        { role: 'redo' },
-        { type: 'separator' },
-        { role: 'cut' },
-        { role: 'copy' },
-        { role: 'paste' },
-        ...(isMac ? [
-          { role: 'pasteAndMatchStyle' },
-          { role: 'delete' },
-          { role: 'selectAll' },
-        ] : [
-          { role: 'delete' },
-          { type: 'separator' },
-          { role: 'selectAll' }
-        ])
-      ]
-    },
-    // View menu
-    {
-      label: 'View',
-      submenu: [
-        { role: 'reload' },
-        { role: 'forceReload' },
-        { role: 'toggleDevTools' },
-        { type: 'separator' },
-        { role: 'resetZoom' },
-        { role: 'zoomIn' },
-        { role: 'zoomOut' },
-        { type: 'separator' },
-        { role: 'togglefullscreen' }
-      ]
-    },
-    // Window menu
-    {
-      label: 'Window',
-      submenu: [
-        { role: 'minimize' },
-        { role: 'zoom' },
-        ...(isMac ? [
-          { type: 'separator' },
-          { role: 'front' },
-          { type: 'separator' },
-          { role: 'window' }
-        ] : [
-          { role: 'close' }
-        ])
-      ]
-    },
-    // Help menu
-    {
-      label: 'Help',
-      submenu: [
-        {
-          label: 'Check for Updates',
-          click: async () => {
-            const headers = sessionManager.getUpdaterHeaders();
-            if (!headers.Authorization) {
-              dialog.showMessageBox({
-                type: 'warning',
-                title: 'Update Check Unavailable',
-                message: 'Not signed in.',
-                detail: 'Please sign in to check for updates.',
-                buttons: ['OK']
-              });
-              return;
-            }
-            log('[AutoUpdate] Manual check for updates...');
-            autoUpdater.requestHeaders = headers;
-            try {
-              const result = await autoUpdater.checkForUpdates();
-              if (result && result.updateInfo) {
-                dialog.showMessageBox({
-                  type: 'info',
-                  title: 'Update Available',
-                  message: `Version ${result.updateInfo.version} is available.`,
-                  buttons: ['OK']
-                });
-              } else {
-                dialog.showMessageBox({
-                  type: 'info',
-                  title: 'No Updates',
-                  message: "You're up to date!",
-                  buttons: ['OK']
-                });
-              }
-            } catch (error) {
-              log(`[AutoUpdate] Manual check failed: ${error.message}`);
-              dialog.showMessageBox({
-                type: 'error',
-                title: 'Update Check Failed',
-                message: 'Unable to check for updates.',
-                detail: 'The update server is unavailable. Please check your internet connection and try again later.',
-                buttons: ['OK']
-              });
-            }
-          }
-        }
-      ]
-    }
-  ];
-
-  return Menu.buildFromTemplate(template);
-}
-
-// ==================== Window Management ====================
-
-function createWindow() {
-  log('Creating browser window...');
-
-  mainWindow = new BrowserWindow({
-    width: 1400,
-    height: 900,
-    title: 'JettyPod',
-    backgroundColor: '#FAF9F7',
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      preload: preloadPath
-    }
-  });
-
-  windows.add(mainWindow);
-
-  mainWindow.loadURL(getStartUrl());
-
-  // Open DevTools in development
-  if (process.env.NODE_ENV === 'development') {
-    mainWindow.webContents.openDevTools();
-  }
-
-  mainWindow.on('closed', () => {
-    windows.delete(mainWindow);
-    mainWindow = null;
-  });
-
-  log('Window created');
-}
-
-// Open a folder dialog and switch the current window to that project
-async function openFolder() {
-  const focusedWindow = BrowserWindow.getFocusedWindow();
-  if (!focusedWindow) {
-    log('[openFolder] No focused window');
-    return;
-  }
-
-  const result = await dialog.showOpenDialog(focusedWindow, {
-    properties: ['openDirectory'],
-    title: 'Open JettyPod Project'
-  });
-
-  if (result.canceled || result.filePaths.length === 0) {
-    log('[openFolder] Dialog canceled');
-    return;
-  }
-
-  const selectedPath = result.filePaths[0];
-  log(`[openFolder] Selected: ${selectedPath}`);
-
-  // Validate the folder has a .jettypod directory
-  if (!hasValidProject(selectedPath)) {
-    log('[openFolder] Invalid project - missing .jettypod directory');
-    dialog.showErrorBox('Not a JettyPod project',
-      'The selected folder does not contain a .jettypod directory.\n\nPlease select a folder that has been initialized with JettyPod.');
-    return;
-  }
-
-  // Update the project root (await ensures Next.js dev server is synced before reload)
-  await setProjectRoot(selectedPath);
-
-  // Reload the focused window to the main dashboard (not welcome)
-  focusedWindow.loadURL('http://localhost:3000');
-  log('[openFolder] Window reloaded with new project');
-}
-
-// Create a new window showing the welcome screen (for opening a second project)
-function createNewWindow() {
-  log('Creating new window...');
-
-  const newWindow = new BrowserWindow({
-    width: 1400,
-    height: 900,
-    title: 'JettyPod',
-    backgroundColor: '#FAF9F7',
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      preload: preloadPath
-    }
-  });
-
-  windows.add(newWindow);
-
-  // New windows always start at welcome screen so user can select a project
-  newWindow.loadURL('http://localhost:3000/welcome');
-
-  newWindow.on('closed', () => {
-    windows.delete(newWindow);
-    log(`Window closed. ${windows.size} windows remaining.`);
-  });
-
-  log(`New window created. Total windows: ${windows.size}`);
-  return newWindow;
-}
-
-function cleanup() {
-  log('Shutting down...');
-
-  if (nextProcess) {
-    log('Killing Next.js dev server...');
-    // Use SIGKILL and kill the entire process group to ensure all child processes are terminated
-    const pid = nextProcess.pid;
-    try {
-      // Kill the process group (negative PID) to terminate all descendants
-      process.kill(-pid, 'SIGKILL');
-      log(`Killed Next.js process group (PID: ${pid})`);
-    } catch (killErr) {
-      // Fallback to killing just the process if process group kill fails
-      try {
-        nextProcess.kill('SIGKILL');
-        log(`Killed Next.js process (PID: ${pid})`);
-      } catch (fallbackErr) {
-        log(`Warning: Could not kill Next.js process: ${fallbackErr.message}`);
-      }
-    }
-    nextProcess = null;
-  }
-
-  if (nextServer) {
-    log('Closing Next.js production server...');
-    nextServer.close();
-    nextServer = null;
-  }
-
-  killAllClaudeProcesses();
-  killAllDevServers();
-  stopWebSocketServer();
-  closeDb();
-  closeIngesterDb();
-}
-
-// ==================== Claude Code Detection ====================
-
-// Track whether Claude Code is installed and authenticated (checked on startup)
-let claudeCodeInstalled = false;
-let claudeCodeAuthenticated = false;
-let claudeCodeNeedsUpdate = false;
-
-/**
- * Check if Claude Code CLI is installed
- * Uses 'which claude' to detect installation
- * @returns {boolean} true if Claude Code is installed
- */
-async function checkClaudeCodeInstalled() {
-  const shellEnv = getShellEnv();
-  log(`[ClaudeCode] Checking with PATH: ${shellEnv.PATH}`);
-  try {
-    const { stdout } = await execFileAsync('which', ['claude'], { encoding: 'utf-8', env: shellEnv });
-    log(`[ClaudeCode] Claude Code found at: ${stdout.trim()}`);
-    return true;
-  } catch {
-    log('[ClaudeCode] Claude Code is NOT installed (not found in PATH)');
-    return false;
-  }
-}
-
-/**
- * Install Claude Code using the official Anthropic install script.
- * This is the recommended installation method that handles PATH setup automatically.
- * @returns {Promise<{success: boolean, error?: string}>}
- */
-async function installClaudeCode() {
-  log('[ClaudeCode] Starting installation via official script...');
-
-  const shellEnv = getShellEnv();
-
-  return new Promise((resolve) => {
-    // Run the official Anthropic install script
-    const installProcess = spawn(getUserShell(), ['-lc', 'curl -fsSL https://claude.ai/install.sh | bash'], {
-      env: shellEnv
-    });
-
-    let stderr = '';
-    let stdout = '';
-
-    installProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-      log(`[ClaudeCode] stdout: ${data}`);
-    });
-
-    installProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-      log(`[ClaudeCode] stderr: ${data}`);
-    });
-
-    installProcess.on('error', (err) => {
-      log(`[ClaudeCode] Install error: ${err.message}`);
-      resolve({ success: false, error: err.message });
-    });
-
-    installProcess.on('exit', (code) => {
-      if (code === 0) {
-        log('[ClaudeCode] Installation successful');
-        claudeCodeInstalled = true;
-        resolve({ success: true });
-      } else {
-        log(`[ClaudeCode] Installation failed with code ${code}`);
-        const errorMsg = stderr || stdout || `Exit code ${code}`;
-        resolve({ success: false, error: errorMsg });
-      }
-    });
-  });
-}
-
-/**
- * Update Claude Code via `claude update`
- * @returns {Promise<{success: boolean, error?: string}>}
- */
-async function updateClaudeCode() {
-  log('[ClaudeCode] Starting update...');
-
-  const shellEnv = getShellEnv();
-  log(`[ClaudeCode] Using PATH: ${shellEnv.PATH.substring(0, 200)}...`);
-
-  return new Promise((resolve) => {
-    const updateProcess = spawn(getUserShell(), ['-lc', 'claude update'], {
-      env: shellEnv
-    });
-
-    let stderr = '';
-    let stdout = '';
-
-    updateProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-      log(`[ClaudeCode] stdout: ${data}`);
-    });
-
-    updateProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-      log(`[ClaudeCode] stderr: ${data}`);
-    });
-
-    updateProcess.on('error', (err) => {
-      log(`[ClaudeCode] Update error: ${err.message}`);
-      resolve({ success: false, error: err.message });
-    });
-
-    updateProcess.on('exit', (code) => {
-      if (code === 0) {
-        log('[ClaudeCode] Update successful');
-        resolve({ success: true, output: stdout });
-      } else {
-        log(`[ClaudeCode] Update failed with code ${code}`);
-        resolve({ success: false, error: stderr || stdout || `Exit code ${code}` });
-      }
-    });
-  });
-}
-
-// Export for IPC handlers
-function getClaudeCodeInstalled() {
-  return claudeCodeInstalled;
-}
-
-function getClaudeCodeAuthenticated() {
-  return claudeCodeAuthenticated;
-}
-
-/**
- * Check if Claude Code CLI is authenticated using `claude auth status --json`.
- * This is a local check (no API call), so it returns instantly.
- * On any unexpected failure, defaults to false (shows connect screen)
- * so the user can authenticate rather than hitting a broken state.
- * @returns {boolean} true if Claude Code is authenticated
- */
-async function checkClaudeCodeAuthenticated() {
-  if (!claudeCodeInstalled) return false;
-  const shellEnv = getShellEnv();
-  try {
-    const { stdout } = await execFileAsync('claude', ['auth', 'status', '--json'], {
-      encoding: 'utf-8',
-      env: shellEnv,
-      timeout: 10000
-    });
-    const status = JSON.parse(stdout);
-    if (status.loggedIn) {
-      log('[ClaudeCode] Claude Code is authenticated');
-      return true;
-    }
-    log('[ClaudeCode] Claude Code is NOT authenticated');
-    return false;
-  } catch (err) {
-    const combined = (err.stderr || '') + (err.stdout || '') + (err.message || '');
-
-    if (combined.includes('needs an update') || combined.includes('needs_update')) {
-      log('[ClaudeCode] CLI is outdated, flagging for auto-update');
-      claudeCodeNeedsUpdate = true;
-      return false;
-    }
-
-    log(`[ClaudeCode] Auth check failed, defaulting to unauthenticated: ${combined}`);
-    return false;
-  }
-}
-
-/**
- * Spawn `claude auth login` to trigger browser-based OAuth authentication.
- * The CLI prints an auth URL to stdout/stderr. We capture it and open it
- * with shell.openExternal() since the spawned process has no TTY.
- * @returns {Promise<{success: boolean, error?: string}>}
- */
-function loginClaudeCode() {
-  return new Promise((resolve) => {
-    const shellEnv = getShellEnv();
-    log('[ClaudeCode] Starting claude auth login...');
-
-    const loginProcess = spawn(getUserShell(), ['-lc', 'claude auth login'], {
-      env: shellEnv,
-      stdio: 'pipe'
-    });
-
-    let stdout = '';
-    let stderr = '';
-    let urlOpened = false;
-
-    const tryOpenUrl = (text) => {
-      if (urlOpened) return;
-      // Match OAuth/auth URLs the CLI prints for non-TTY environments
-      const urlMatch = text.match(/https?:\/\/\S+/);
-      if (urlMatch) {
-        const url = urlMatch[0];
-        log(`[ClaudeCode] Found auth URL, opening in browser: ${url}`);
-        shell.openExternal(url);
-        urlOpened = true;
-      }
-    };
-
-    loginProcess.stdout.on('data', (data) => {
-      const chunk = data.toString();
-      stdout += chunk;
-      log(`[ClaudeCode] stdout: ${chunk.trim()}`);
-      tryOpenUrl(chunk);
-    });
-
-    loginProcess.stderr.on('data', (data) => {
-      const chunk = data.toString();
-      stderr += chunk;
-      log(`[ClaudeCode] stderr: ${chunk.trim()}`);
-      tryOpenUrl(chunk);
-    });
-
-    loginProcess.on('close', async (code) => {
-      if (code === 0) {
-        claudeCodeAuthenticated = true;
-        log('[ClaudeCode] Auth completed successfully');
-        resolve({ success: true });
-      } else if (stderr.includes('needs an update') || stderr.includes('needs_update') ||
-                 stdout.includes('needs an update') || stdout.includes('needs_update')) {
-        log('[ClaudeCode] CLI outdated during login, running auto-update...');
-        const updateResult = await updateClaudeCode();
-        if (updateResult.success) {
-          log('[ClaudeCode] Auto-update succeeded, retrying login');
-          claudeCodeNeedsUpdate = false;
-          // Retry login after update
-          const retryResult = await loginClaudeCode();
-          resolve(retryResult);
-        } else {
-          log(`[ClaudeCode] Auto-update failed: ${updateResult.error}`);
-          resolve({ success: false, error: 'Claude Code needs an update but the update failed. Please run "claude update" manually.' });
-        }
-      } else {
-        log(`[ClaudeCode] Auth failed with code ${code}: ${stderr}`);
-        resolve({ success: false, error: stderr || `Auth exited with code ${code}` });
-      }
-    });
-
-    loginProcess.on('error', (err) => {
-      log(`[ClaudeCode] Auth spawn error: ${err.message}`);
-      resolve({ success: false, error: err.message });
-    });
-  });
-}
-
-// ==================== PATH Setup ====================
-
-const SYMLINK_PATH = '/usr/local/bin/jettypod';
-
-/**
- * Get the path to the bundled jettypod CLI
- * In packaged app: Contents/Resources/bin/jettypod
- */
-function getBundledCliPath() {
-  if (isPackaged) {
-    return path.join(process.resourcesPath, 'bin', 'jettypod');
-  }
-  // Development mode - use the bin/jettypod in project root
-  return path.join(__dirname, '..', '..', '..', 'bin', 'jettypod');
-}
-
-/**
- * Setup PATH by creating symlink to /usr/local/bin
- * Uses osascript to request admin privileges
- */
-async function setupCliSymlink() {
-  // Only run on macOS
-  if (process.platform !== 'darwin') {
-    log('[PATH] Not macOS, skipping PATH setup');
-    return;
-  }
-
-  const bundledPath = getBundledCliPath();
-  log(`[PATH] Bundled CLI path: ${bundledPath}`);
-
-  // Check if bundled CLI exists
-  if (!fs.existsSync(bundledPath)) {
-    log('[PATH] Bundled CLI not found, skipping PATH setup');
-    return;
-  }
-
-  // Check if symlink already points to the correct bundled CLI
-  try {
-    const currentTarget = fs.readlinkSync(SYMLINK_PATH);
-    if (currentTarget === bundledPath) {
-      log('[PATH] Symlink already points to bundled CLI, skipping');
-      return;
-    }
-    log(`[PATH] Symlink points to ${currentTarget}, updating to bundled CLI`);
-  } catch {
-    // Symlink doesn't exist or isn't a symlink — create it
-    log('[PATH] No existing symlink, creating');
-  }
-
-  log('[PATH] Setting up PATH with admin privileges...');
-
-  // Use osascript to run ln with admin privileges.
-  // mkdir -p ensures the parent directory exists (e.g. /usr/local/bin may not
-  // exist on fresh Apple Silicon Macs which use /opt/homebrew/bin by default).
-  const symlinkDir = path.dirname(SYMLINK_PATH);
-  const script = `do shell script "mkdir -p '${symlinkDir}' && ln -sf '${bundledPath}' '${SYMLINK_PATH}'" with administrator privileges`;
-
-  try {
-    await execAsync(`osascript -e '${script}'`, { encoding: 'utf-8' });
-    log('[PATH] Symlink created successfully');
-  } catch (error) {
-    // User cancelled or error occurred
-    log(`[PATH] Setup failed or cancelled: ${error.message}`);
-  }
-}
-
-// ==================== Subscription & Access ====================
-
-/**
- * Get path to subscription.json file
- * Stored in Electron's userData directory (~/.config/JettyPod/)
- */
-function getSubscriptionPath() {
-  return path.join(app.getPath('userData'), 'subscription.json');
-}
-
-/**
- * Get the path to the auth state file.
- * Stored alongside subscription.json in Electron's userData directory.
- */
-function getAuthPath() {
-  return path.join(app.getPath('userData'), 'auth.json');
-}
-
-/**
- * Check if there's a stored auth token (JWT).
- * Does NOT validate the token — just checks if auth.json exists with a token.
- */
-function isAuthenticated() {
-  const authPath = getAuthPath();
-  if (!fs.existsSync(authPath)) {
-    log('[Auth] No auth.json found');
-    return false;
-  }
-
-  try {
-    const data = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
-    if (data.token) {
-      log('[Auth] Auth token found');
-      return true;
-    }
-  } catch (error) {
-    log(`[Auth] Error reading auth file: ${error.message}`);
-  }
-
-  return false;
-}
-
-/**
- * Check if the user has ever logged in before.
- * Uses a persistent marker file that survives logout (auth.json deletion).
- */
-function hasLoggedInBefore() {
-  try {
-    const markerPath = path.join(app.getPath('userData'), 'has-logged-in');
-    return fs.existsSync(markerPath);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Mark that the user has logged in at least once.
- * Called after successful authentication (both OAuth and OTP).
- */
-function markHasLoggedIn() {
-  try {
-    const markerPath = path.join(app.getPath('userData'), 'has-logged-in');
-    const dir = path.dirname(markerPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    if (!fs.existsSync(markerPath)) {
-      fs.writeFileSync(markerPath, new Date().toISOString());
-      log('[Auth] Marked user as having logged in before');
-    }
-  } catch (error) {
-    log(`[Auth] Failed to write login marker: ${error.message}`);
-  }
-}
-
-/**
- * Read the Stripe customer ID from subscription config.
- * Returns null if no subscription is stored.
- * Written by the Stripe checkout flow (chore #1000535).
- */
-function getSubscriptionCustomerId() {
-  const subPath = getSubscriptionPath();
-  if (!fs.existsSync(subPath)) return null;
-  try {
-    const data = JSON.parse(fs.readFileSync(subPath, 'utf-8'));
-    return data.customerId || null;
-  } catch (error) {
-    log(`[Subscription] Error reading subscription file: ${error.message}`);
-    return null;
-  }
-}
-
-/**
- * Check if there's an active subscription stored locally.
- * Full validation against Stripe happens on update check / app refresh.
- */
-function isSubscriptionActive() {
-  const subPath = getSubscriptionPath();
-  if (!fs.existsSync(subPath)) {
-    log('[Subscription] No subscription.json found');
-    return false;
-  }
-
-  try {
-    const data = JSON.parse(fs.readFileSync(subPath, 'utf-8'));
-    if (data.customerId) {
-      log('[Subscription] Active subscription found');
-      return true;
-    }
-  } catch (error) {
-    log(`[Subscription] Error reading subscription file: ${error.message}`);
-  }
-
-  return false;
-}
-
-// ==================== Skills Auto-Sync ====================
-
-/**
- * Get the path to bundled skills
- * In packaged app: Contents/Resources/skills
- * In dev mode: ~/.claude/skills (the user's existing skills)
- */
-function getBundledSkillsPath() {
-  if (isPackaged) {
-    return path.join(process.resourcesPath, 'skills');
-  }
-  // Development mode - use the user's existing skills directory
-  return path.join(require('os').homedir(), '.claude', 'skills');
-}
-
-/**
- * Get the user's skills directory path
- * @returns {string} Path to ~/.claude/skills/
- */
-function getUserSkillsPath() {
-  return path.join(require('os').homedir(), '.claude', 'skills');
-}
-
-/**
- * Recursively copy a directory
- * @param {string} src - Source directory
- * @param {string} dest - Destination directory
- */
-function copyDirSync(src, dest) {
-  // Create destination directory if it doesn't exist
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true });
-  }
-
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      copyDirSync(srcPath, destPath);
-    } else {
-      // Skip copy if dest exists and has same or newer mtime + same size
-      try {
-        const srcStat = fs.statSync(srcPath);
-        const destStat = fs.statSync(destPath);
-        if (destStat.mtimeMs >= srcStat.mtimeMs && destStat.size === srcStat.size) {
-          continue;
-        }
-      } catch {
-        // dest doesn't exist — copy it
-      }
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Sync bundled skills to user's ~/.claude/skills/ directory
- * Called on every app launch to ensure skills are up to date
- *
- * Error handling: All errors are caught and logged - sync failures
- * should never prevent the app from launching.
- */
-function syncSkills() {
-  try {
-    const bundledPath = getBundledSkillsPath();
-    const userPath = getUserSkillsPath();
-
-    log(`[Skills] Syncing skills from ${bundledPath} to ${userPath}`);
-
-    // Check if bundled skills exist
-    if (!fs.existsSync(bundledPath)) {
-      log('[Skills] No bundled skills found, skipping sync');
-      return;
-    }
-
-    // Create user skills directory if it doesn't exist
-    if (!fs.existsSync(userPath)) {
-      log('[Skills] Creating user skills directory');
-      try {
-        fs.mkdirSync(userPath, { recursive: true });
-      } catch (dirError) {
-        log(`[Skills] Warning: Failed to create skills directory: ${dirError.message}`);
-        // Cannot proceed without directory - exit gracefully
-        return;
-      }
-    }
-
-    // Get list of bundled skills (directories)
-    let bundledSkills;
-    try {
-      bundledSkills = fs.readdirSync(bundledPath, { withFileTypes: true })
-        .filter(entry => entry.isDirectory())
-        .map(entry => entry.name);
-    } catch (readError) {
-      log(`[Skills] Warning: Failed to read bundled skills: ${readError.message}`);
-      return;
-    }
-
-    log(`[Skills] Found ${bundledSkills.length} bundled skills to sync`);
-
-    // Copy each skill directory (overwrites existing)
-    for (const skillName of bundledSkills) {
-      const srcSkillPath = path.join(bundledPath, skillName);
-      const destSkillPath = path.join(userPath, skillName);
-
-      try {
-        log(`[Skills] Syncing skill: ${skillName}`);
-        copyDirSync(srcSkillPath, destSkillPath);
-      } catch (copyError) {
-        // Log error but continue with other skills
-        log(`[Skills] Warning: Failed to sync skill ${skillName}: ${copyError.message}`);
-      }
-    }
-
-    log('[Skills] Sync complete');
-  } catch (error) {
-    // Catch-all for any unexpected errors
-    log(`[Skills] Warning: Skills sync failed: ${error.message}`);
-    // Don't throw - app should continue launching
-  }
-}
-
-// ==================== Auto-Update Event Handlers ====================
-
-// Track download state to detect download failures
-let isDownloading = false;
-
-// Handle auto-updater errors (network failures, server unavailable, etc.)
-autoUpdater.on('error', (error) => {
-  log(`[AutoUpdate] Error: ${error.message}`);
-
-  // If download was in progress, show user-friendly error with retry option
-  if (isDownloading) {
-    isDownloading = false;
-    dialog.showMessageBox({
-      type: 'error',
-      title: 'Download Failed',
-      message: 'Failed to download the update.',
-      detail: 'Please check your internet connection and try again.',
-      buttons: ['Retry', 'Cancel'],
-      defaultId: 0
-    }).then((result) => {
-      if (result.response === 0) {
-        log('[AutoUpdate] User chose to retry download');
-        autoUpdater.downloadUpdate();
-      } else {
-        log('[AutoUpdate] User cancelled retry');
-      }
-    });
-  }
-  // Otherwise, this is a background check failure - just log it
-  // App continues functioning normally
-});
-
-autoUpdater.on('update-available', (info) => {
-  isDownloading = true; // Mark download as starting
-  log(`[AutoUpdate] Update available: ${info.version}`);
-  dialog.showMessageBox({
-    type: 'info',
-    title: 'Update Available',
-    message: `A new version (${info.version}) is available.`,
-    detail: 'The update will be downloaded in the background.',
-    buttons: ['OK']
-  });
-});
-
-autoUpdater.on('download-progress', (progressObj) => {
-  log(`[AutoUpdate] Download progress: ${progressObj.percent.toFixed(1)}%`);
-});
-
-autoUpdater.on('update-downloaded', (info) => {
-  isDownloading = false; // Download complete
-  log(`[AutoUpdate] Update downloaded: ${info.version}`);
-  dialog.showMessageBox({
-    type: 'info',
-    title: 'Restart to Update',
-    message: `Version ${info.version} has been downloaded.`,
-    detail: 'Restart now to install the update?',
-    buttons: ['Restart Now', 'Later'],
-    defaultId: 0
-  }).then((result) => {
-    if (result.response === 0) {
-      log('[AutoUpdate] User chose to restart');
-      autoUpdater.quitAndInstall();
-    } else {
-      log('[AutoUpdate] User chose to restart later');
-    }
-  });
-});
-
-// ==================== App Lifecycle ====================
-
-// Register jettypod:// protocol for OAuth callback
-if (!isPackaged) {
-  // Dev mode: pass app path so macOS can route the URL to this Electron instance
-  app.setAsDefaultProtocolClient('jettypod', process.execPath, [path.resolve(process.argv[1])]);
-} else {
-  app.setAsDefaultProtocolClient('jettypod');
-}
-
-/**
- * Decode a JWT payload without verifying the signature.
- * Used to extract user info (email, plan) from the token before saving.
- */
-function decodeJWTPayload(token) {
-  try {
-    const parts = token.split('.');
-    if (parts.length !== 3) return null;
-    const payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-    return JSON.parse(Buffer.from(payload, 'base64').toString('utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Handle a jettypod:// protocol URL (OAuth callback).
- * Saves the token + decoded user info to auth.json and navigates to the dashboard.
- */
-function handleProtocolUrl(url) {
-  log(`[Auth] Protocol handler received: ${url}`);
-
-  try {
-    const parsed = new URL(url);
-    // jettypod://auth/callback parses as hostname='auth', pathname='/callback'
-    const isAuthCallback =
-      (parsed.hostname === 'auth' && parsed.pathname === '/callback') ||
-      parsed.pathname === '//auth/callback' ||
-      parsed.pathname === '/auth/callback';
-    if (isAuthCallback) {
-      const token = parsed.searchParams.get('token');
-      if (token && mainWindow) {
-        // Decode JWT to extract user info (sub, email, plan)
-        const payload = decodeJWTPayload(token);
-        const user = payload ? { id: payload.sub, email: payload.email, plan: payload.plan } : undefined;
-
-        // Save auth.json with token AND user data
-        const authPath = path.join(app.getPath('userData'), 'auth.json');
-        const dir = path.dirname(authPath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(authPath, JSON.stringify({ token, user, savedAt: new Date().toISOString() }, null, 2));
-        markHasLoggedIn();
-        log('[Auth] Token + user data saved from OAuth callback');
-
-        // Navigate to the appropriate onboarding/dashboard page
-        mainWindow.loadURL(getStartUrl());
-        mainWindow.focus();
-      }
-    } else if (parsed.hostname === 'subscription' && parsed.pathname === '/activated') {
-      log('[Auth] Subscription activated deep link received');
-      if (mainWindow) {
-        mainWindow.loadURL(getStartUrl());
-        mainWindow.focus();
-      }
-    }
-  } catch (error) {
-    log(`[Auth] Error handling protocol URL: ${error.message}`);
-  }
-}
-
-// Single-instance lock: ensure deep links are routed to the existing instance
-const gotTheLock = app.requestSingleInstanceLock();
-
-if (!gotTheLock) {
-  // Another instance is already running — quit this one.
-  // The URL (if any) will be forwarded to the existing instance via 'second-instance'.
-  app.quit();
-} else {
-  // On macOS, protocol URLs for a running app arrive via 'open-url'.
-  app.on('open-url', (event, url) => {
-    event.preventDefault();
-    handleProtocolUrl(url);
-  });
-
-  // On Windows/Linux (and macOS second-instance fallback), the URL arrives here.
-  app.on('second-instance', (_event, commandLine) => {
-    // The protocol URL is typically the last argument
-    const url = commandLine.find(arg => arg.startsWith('jettypod://'));
-    if (url) {
-      handleProtocolUrl(url);
-    }
-    // Focus the main window
-    if (mainWindow) {
-      if (mainWindow.isMinimized()) mainWindow.restore();
-      mainWindow.focus();
-    }
-  });
-}
-
-app.whenReady().then(async () => {
-  log('Electron app ready');
-
-  // Start session manager (handles auth heartbeat + auto-updater token)
-  sessionManager.setLogger(log);
-  if (isAuthenticated()) {
-    sessionManager.start();
-  }
-
-  // Check for updates in the background (only in packaged app)
-  if (isPackaged && isAuthenticated()) {
-    const headers = sessionManager.getUpdaterHeaders();
-    if (headers.Authorization) {
-      autoUpdater.requestHeaders = headers;
-      log('[AutoUpdate] Checking for updates with JWT...');
-      try {
-        await autoUpdater.checkForUpdatesAndNotify();
-      } catch (error) {
-        log(`[AutoUpdate] Update check failed: ${error.message}`);
-      }
-    } else {
-      log('[AutoUpdate] Skipping update check - no auth token');
-    }
-  }
-
-  // Check if Claude Code is installed (for dependency flow)
-  // Updates the global claudeCodeInstalled variable
-  claudeCodeInstalled = await checkClaudeCodeInstalled();
-  log(`Claude Code installed: ${claudeCodeInstalled}`);
-
-  // Check if Claude Code is authenticated (only if installed)
-  // Wrapped in try/catch so a catastrophic failure here doesn't crash startup
-  if (claudeCodeInstalled) {
-    try {
-      claudeCodeAuthenticated = await checkClaudeCodeAuthenticated();
-    } catch (err) {
-      log(`[ClaudeCode] Auth check crashed unexpectedly: ${err.message}`);
-      claudeCodeAuthenticated = false;
-    }
-
-    // Auto-update if CLI is outdated, then retry auth check
-    if (!claudeCodeAuthenticated && claudeCodeNeedsUpdate) {
-      log('[ClaudeCode] CLI outdated, running auto-update...');
-      const updateResult = await updateClaudeCode();
-      if (updateResult.success) {
-        log('[ClaudeCode] Auto-update succeeded, retrying auth check');
-        claudeCodeNeedsUpdate = false;
-        try {
-          claudeCodeAuthenticated = await checkClaudeCodeAuthenticated();
-        } catch (err) {
-          log(`[ClaudeCode] Auth re-check crashed: ${err.message}`);
-          claudeCodeAuthenticated = false;
-        }
-      } else {
-        log(`[ClaudeCode] Auto-update failed: ${updateResult.error}`);
-      }
-    }
-
-    log(`Claude Code authenticated: ${claudeCodeAuthenticated}`);
-  }
-
-  // Setup PATH on first launch (creates symlink to /usr/local/bin)
-  await setupCliSymlink();
-
-  // Sync bundled skills to ~/.claude/skills/
-  syncSkills();
-
-  // Set up application menu
-  const menu = buildApplicationMenu();
-  Menu.setApplicationMenu(menu);
-  log('Application menu set');
-
-  // Register IPC handlers for database operations
-  registerIpcHandlers();
-
-  // Post-login navigation: returns the correct path based on Claude Code state
-  ipcMain.handle('auth:getPostLoginPath', () => {
-    const url = getStartUrl();
-    // Extract just the path from the full URL
-    try {
-      return new URL(url).pathname;
-    } catch {
-      return '/';
-    }
-  });
-
-  // Clean up stale resources from previous runs (lock files, orphaned processes)
-  await cleanupStaleResources();
-
-  try {
-    // Start servers in parallel
-    await Promise.all([
-      startNextServer(),
-      startEmbeddedWebSocketServer()
-    ]);
-
-    // Small delay to ensure servers are fully ready
-    await new Promise(r => setTimeout(r, 1000));
-
-    createWindow();
-  } catch (err) {
-    log(`Failed to start servers: ${err.message}`);
-    app.quit();
-  }
-});
-
-app.on('window-all-closed', () => {
-  log('All windows closed');
-  cleanup();
-  app.quit();
-});
-
-app.on('before-quit', () => {
-  log('App quitting...');
-  cleanup();
-});
-
-// Handle Ctrl+C in terminal
-process.on('SIGINT', () => {
-  log('Received SIGINT');
-  cleanup();
-  app.quit();
-});
-
-process.on('SIGTERM', () => {
-  log('Received SIGTERM');
-  cleanup();
-  app.quit();
-});
-
-// Handle uncaught exceptions - ensure cleanup runs even on crashes
-process.on('uncaughtException', (err) => {
-  log(`Uncaught exception: ${err.message}`);
-  log(err.stack);
-  cleanup();
-  app.quit();
-});
-
-// Handle unhandled promise rejections
-process.on('unhandledRejection', (reason, promise) => {
-  log(`Unhandled rejection at: ${promise}, reason: ${reason}`);
-  cleanup();
-  app.quit();
-});