cc-caffeine 0.2.0

package/src/electron.js

@@ -0,0 +1,139 @@
+/**
+ * Electron module - Handles all Electron-specific functionality
+ */
+
+let electron, Tray, Menu, powerSaveBlocker, nativeImage, app, shell;
+let isElectron = false;
+
+/**
+ * Load Electron modules only when needed
+ */
+const loadElectron = () => {
+  if (isElectron) {
+    return;
+  }
+
+  try {
+    electron = require('electron');
+    Tray = electron.Tray;
+    Menu = electron.Menu;
+    powerSaveBlocker = electron.powerSaveBlocker;
+    nativeImage = electron.nativeImage;
+    app = electron.app;
+    shell = electron.shell;
+    isElectron = true;
+  } catch (error) {
+    console.error('Failed to load Electron:', error.message);
+    console.error('Make sure to use Electron: npx electron caffeine.js server');
+    process.exit(1);
+  }
+};
+
+/**
+ * Get Electron modules
+ */
+const getElectron = () => {
+  if (!isElectron) {
+    loadElectron();
+  }
+  return {
+    electron,
+    Tray,
+    Menu,
+    powerSaveBlocker,
+    nativeImage,
+    app,
+    shell
+  };
+};
+
+/**
+ * Check if running inside Electron
+ */
+const isRunningInElectron = () => {
+  return !!process.versions.electron;
+};
+
+/**
+ * Prevent any window from being created
+ */
+const preventWindowCreation = () => {
+  const { app } = getElectron();
+
+  if (app.dock && typeof app.dock.hide === 'function') {
+    try {
+      app.dock.hide();
+    } catch (error) {
+      // Silently ignore if not macOS or other error
+    }
+  }
+
+  app.on('browser-window-created', (event, window) => {
+    window.hide();
+  });
+};
+
+/**
+ * Setup Electron app event handlers
+ */
+const setupAppEventHandlers = shutdownCallback => {
+  const { app } = getElectron();
+
+  app.on('window-all-closed', () => {
+    // Don't quit on window close since we're running in background
+  });
+
+  app.on('before-quit', () => {
+    // Cleanup handled by shutdown callback
+  });
+
+  app.on('activate', () => {
+    // No window to restore, we're system tray only
+  });
+
+  process.on('SIGINT', () => {
+    if (shutdownCallback) {
+      shutdownCallback();
+    } else {
+      process.exit(0);
+    }
+  });
+
+  process.on('SIGTERM', () => {
+    if (shutdownCallback) {
+      shutdownCallback();
+    } else {
+      process.exit(0);
+    }
+  });
+};
+
+/**
+ * Wait for Electron app to be ready
+ */
+const whenReady = () => {
+  const { app } = getElectron();
+  return app.whenReady();
+};
+
+/**
+ * Quit Electron app
+ */
+const quit = () => {
+  const { app } = getElectron();
+  if (app && typeof app.quit === 'function') {
+    app.quit();
+  } else {
+    process.exit(0);
+  }
+};
+
+module.exports = {
+  loadElectron,
+  getElectron,
+  isRunningInElectron,
+  preventWindowCreation,
+  setupAppEventHandlers,
+  whenReady,
+  quit
+};

package/src/pid.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+/**
+ * PID management module - Handles atomic PID file operations and validation
+ *
+ * This module provides functions to:
+ * - Atomically read/write PID files
+ * - Validate if a PID belongs to a caffeine server process
+ * - Clean up stale PID files
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const lockfile = require('proper-lockfile');
+
+const CONFIG_DIR = path.join(os.homedir(), '.claude', 'plugins', 'cc-caffeine');
+const PID_FILE = path.join(CONFIG_DIR, 'server.pid');
+
+const withPidLock = async (fn) => {
+  // create if not exists
+  try {
+    const fd = fs.openSync(PID_FILE, 'wx');
+    fs.closeSync(fd);
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+    // If EEXIST, file already exists, nothing to do
+  }
+
+  let output = null;
+
+  const release = await lockfile.lock(PID_FILE, {
+    retries: 3,
+    stale: 10000 // 10 seconds
+  });
+  try {
+    output = await fn();
+  } finally {
+    await release();
+  }
+
+  return output;
+};
+
+/**
+ * Write PID to file
+ * @param {number} pid - Process ID to write
+ */
+const writePidFile = async pid => {
+  try {
+    await fs.promises.writeFile(PID_FILE, pid.toString(), 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      // File doesn't exist, create it without locking
+      await fs.promises.writeFile(PID_FILE, pid.toString(), 'utf8');
+    } else {
+      throw error;
+    }
+  }
+};
+
+/**
+ * Read PID from file
+ * @returns {number|null} PID if found and valid, null otherwise
+ */
+const readPidFile = async () => {
+  try {
+    const pidStr = await fs.promises.readFile(PID_FILE, 'utf8');
+    const pid = parseInt(pidStr.trim(), 10);
+
+    if (isNaN(pid) || pid <= 0) {
+      return null;
+    }
+
+    return pid;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null; // File doesn't exist
+    }
+    throw error;
+  }
+};
+
+/**
+ * Remove PID file
+ */
+const removePidFileWithLock = async () => {
+  try {
+    const release = await lockfile.lock(PID_FILE, {
+      retries: 3,
+      stale: 10000 // 10 seconds
+    });
+
+    try {
+      await removePidFile();
+    } finally {
+      await release();
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      // File already doesn't exist, that's fine
+      return;
+    }
+    throw error;
+  }
+};
+
+const removePidFile = async () => {
+  const pid = await readPidFile();
+  if (pid === process.pid) {
+    await fs.promises.unlink(PID_FILE);
+  }
+};
+
+/**
+ * Check if a process with given PID exists and is a caffeine server
+ * @param {number} pid - Process ID to check
+ * @returns {Promise<boolean>} True if process exists and is caffeine server
+ */
+const validatePid = async pid => {
+  return new Promise(resolve => {
+    // First check if process exists
+    try {
+      process.kill(pid, 0); // Signal 0 just checks if process exists
+    } catch (error) {
+      if (error.code === 'ESRCH') {
+        // Process doesn't exist
+        resolve(false);
+        return;
+      }
+      // Other errors (like EPERM) mean process exists but we can't signal it
+    }
+
+    // Process exists, now check if it's a caffeine server
+    const isWindows = os.platform() === 'win32';
+    const psCommand = isWindows
+      ? spawn('wmic', ['process', 'where', `processid=${pid}`, 'get', 'commandline'], {
+        stdio: 'pipe'
+      })
+      : spawn('ps', ['-p', pid, '-o', 'command='], { stdio: 'pipe' });
+
+    let output = '';
+
+    psCommand.stdout.on('data', data => {
+      output += data.toString();
+    });
+
+    psCommand.on('close', code => {
+      if (code !== 0) {
+        resolve(false);
+        return;
+      }
+
+      const commandLine = output.trim().toLowerCase();
+      for (const line of commandLine.split('\n')) {
+        // Check if command line contains both "caffeine" and "server"
+        const isCaffeineServer = line.includes('caffeine server') || line.includes('caffeine.js server');
+        const isElectron = line.includes('electron');
+
+        if (isCaffeineServer && isElectron) {
+          resolve(true);
+          return;
+        }
+      }
+
+      resolve(false);
+    });
+
+    psCommand.on('error', () => {
+      resolve(false);
+    });
+  });
+};
+
+/**
+ * Check if caffeine server is running using PID file
+ * @returns {Promise<boolean>} True if server is running
+ */
+const isServerRunningWithLock = async () => {
+  return await withPidLock(async () => {
+    return await isServerRunning();
+  });
+};
+
+/**
+ * Check if caffeine server is running using PID file
+ * @returns {Promise<boolean>} True if server is running
+ */
+const isServerRunning = async () => {
+  try {
+    const pid = await readPidFile();
+
+    if (!pid) {
+      return false;
+    }
+
+    const isValid = await validatePid(pid);
+
+    if (!isValid) {
+      // PID is stale, clean it up
+      await removePidFile();
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    console.error('Error checking if server is running:', error);
+    return false;
+  }
+};
+
+module.exports = {
+  writePidFile,
+  readPidFile,
+  removePidFileWithLock,
+  removePidFile,
+  validatePid,
+  isServerRunningWithLock,
+  isServerRunning,
+  withPidLock
+};

package/src/server.js

@@ -0,0 +1,182 @@
+/**
+ * Server module - Handles server process management and startup
+ */
+
+const path = require('path');
+const { spawn } = require('child_process');
+
+const { initSessionsFile } = require('./session');
+const { getSystemTray, startPolling, shutdownServer } = require('./system-tray');
+const {
+  isRunningInElectron,
+  preventWindowCreation,
+  setupAppEventHandlers,
+  whenReady,
+  quit
+} = require('./electron');
+const { isServerRunning, writePidFile, withPidLock, isServerRunningWithLock } = require('./pid');
+
+const CHECK_INTERVAL = 5 * 1000; // 10 seconds
+
+/**
+ * Ensure server is running, start if needed
+ */
+const runServerProcessIfNotStarted = async () => {
+  const isRunning = await isServerRunningWithLock();
+  if (isRunning) {
+    console.error('Server is already running');
+    return;
+  }
+
+  console.error('Server not running, starting...');
+  await startServerProcess();
+};
+
+/**
+ * Start server process using npm
+ */
+const startServerProcess = async () => {
+  console.error('Starting caffeine server...');
+
+  const cwd = path.join(__dirname, '..');
+
+  const serverProcess = spawn('npm', ['run', 'server'], {
+    detached: true,
+    stdio: 'ignore',
+    cwd // is needed to find the correct caffeine.js
+  });
+
+  serverProcess.unref();
+
+  // Wait for server to start
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  return true;
+};
+
+/**
+ * Handle server command - start Electron server or delegate with atomic file locking
+ */
+const handleServer = async () => {
+  let mustStartServer = false;
+  let mustStartElectron = false;
+
+  await withPidLock(async () => {
+    try {
+      // Inside the lock, check if server is already running
+      const alreadyRunning = await isServerRunning();
+      if (alreadyRunning) {
+        console.error('Caffeine server is already running');
+        return;
+      }
+
+      if (isRunningInElectron()) {
+        mustStartServer = true;
+        console.error('Already running inside Electron, starting server...');
+        await writePidFile(process.pid);
+      } else {
+        mustStartElectron = true;
+        console.error('Not running inside Electron, spawning Electron process...');
+      }
+    } catch (error) {
+      if (error.code === 'ELOCKED' || error.code === 'EEXIST') {
+        // Another process has the lock, server is likely starting up
+        console.error('Server startup is in progress by another process');
+      } else {
+        console.error('Failed to acquire server startup lock:', error);
+        throw error;
+      }
+    }
+  });
+
+  if (mustStartElectron) {
+    await spawnElectronProcess();
+  } else if (mustStartServer) {
+    await startServer();
+  } else if (isRunningInElectron()) {
+    await shutdownServer();
+    process.exit(0);
+  }
+};
+
+/**
+ * Start server when already inside Electron
+ */
+const startServer = async () => {
+  console.error('Loading Electron...');
+
+  // Prevent any window from being created
+  preventWindowCreation();
+
+  // Setup event handlers with shutdown callback
+  setupAppEventHandlers(() => {
+    // We'll handle shutdown in the main process
+    process.exit(0);
+  });
+
+  // Wait for app to be ready before starting system tray
+  await whenReady();
+
+  // Start the actual server
+  try {
+    await initSessionsFile();
+    const state = getSystemTray();
+    startPolling(state, CHECK_INTERVAL);
+    console.error('Caffeine server started successfully with system tray');
+
+    // Only setup signal handlers if server actually started
+    if (state) {
+      // Handle process termination for Electron process
+      process.on('SIGINT', async () => {
+        console.error('Received SIGINT, shutting down server...');
+        await shutdownServer(state);
+        quit();
+      });
+
+      process.on('SIGTERM', async () => {
+        console.error('Received SIGTERM, shutting down server...');
+        await shutdownServer(state);
+        quit();
+      });
+    }
+
+    return state;
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+};
+
+/**
+ * Spawn new Electron process for server
+ */
+const spawnElectronProcess = () => {
+  const cwd = path.join(__dirname, '..');
+
+  const electronProcess = spawn('npx', ['electron', 'caffeine.js', 'server'], {
+    stdio: 'inherit',
+    shell: true,
+    detached: false,
+    cwd // is needed to find caffeine.js
+  });
+
+  electronProcess.on('exit', code => {
+    process.exit(code || 0);
+  });
+
+  electronProcess.on('error', error => {
+    console.error('Failed to spawn Electron process:', error);
+    process.exit(1);
+  });
+
+  electronProcess.on('close', code => {
+    process.exit(code || 0);
+  });
+
+  return electronProcess.pid;
+};
+
+module.exports = {
+  handleServer,
+  runServerProcessIfNotStarted
+};