cc-caffeine 0.2.0

package/src/session.js

@@ -0,0 +1,227 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const lockfile = require('proper-lockfile');
+
+const CONFIG_DIR = path.join(os.homedir(), '.claude', 'plugins', 'cc-caffeine');
+const SESSIONS_FILE = path.join(CONFIG_DIR, 'sessions.json');
+const SESSION_TIMEOUT = 15 * 60 * 1000; // 15 minutes
+const MAX_RETRIES = 10;
+
+const initSessionsFile = async () => {
+  if (!fs.existsSync(SESSIONS_FILE)) {
+    const initialData = {
+      sessions: {},
+      last_updated: new Date().toISOString()
+    };
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(initialData, null, 2));
+  }
+};
+
+const readSessionsWithLock = async (retryCount = 0) => {
+  try {
+    await initSessionsFile();
+
+    const release = await lockfile.lock(SESSIONS_FILE, {
+      retries: MAX_RETRIES,
+      stale: 30000 // 30 seconds
+    });
+
+    try {
+      const data = fs.readFileSync(SESSIONS_FILE, 'utf8');
+      return JSON.parse(data);
+    } finally {
+      await release();
+    }
+  } catch (error) {
+    if (retryCount < MAX_RETRIES) {
+      console.warn(`Retry ${retryCount + 1}/${MAX_RETRIES} for readSessionsWithLock`);
+      await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, retryCount)));
+      return readSessionsWithLock(retryCount + 1);
+    }
+    throw error;
+  }
+};
+
+// Note: Individual write operations should use addSession/removeSession for atomicity
+
+const addSessionWithLock = async sessionId => {
+  await initSessionsFile();
+
+  const release = await lockfile.lock(SESSIONS_FILE, {
+    retries: MAX_RETRIES,
+    stale: 30000 // 30 seconds
+  });
+
+  try {
+    // Read data while holding the lock
+    const data = JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf8'));
+    const now = new Date().toISOString();
+
+    // Clean up expired sessions first
+    const nowDate = new Date();
+    let removedCount = 0;
+
+    for (const [existingSessionId, sessionData] of Object.entries(data.sessions)) {
+      const lastActivity = new Date(sessionData.last_activity);
+      const timeDiff = nowDate - lastActivity;
+
+      if (timeDiff >= SESSION_TIMEOUT) {
+        delete data.sessions[existingSessionId];
+        removedCount++;
+      }
+    }
+
+    // Add or update the session
+    if (data.sessions[sessionId]) {
+      // Update existing session's last_activity only
+      data.sessions[sessionId].last_activity = now;
+    } else {
+      // Create new session
+      data.sessions[sessionId] = {
+        created_at: now,
+        last_activity: now,
+        project_dir: process.env.CLAUDE_PROJECT_DIR
+      };
+    }
+
+    // Write updated data while still holding the lock
+    data.last_updated = now;
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+
+    const isNewSession =
+      !data.sessions[sessionId] ||
+      (data.sessions[sessionId].created_at === now &&
+        data.sessions[sessionId].last_activity === now);
+    const action = isNewSession ? 'added' : 'updated';
+
+    // console.error(`Cleaned up ${removedCount} expired sessions and ${action} session: ${sessionId}`);
+    return { id: sessionId, cleaned_sessions: removedCount, action };
+  } finally {
+    await release();
+  }
+};
+
+const removeSessionWithLock = async sessionId => {
+  await initSessionsFile();
+
+  const release = await lockfile.lock(SESSIONS_FILE, {
+    retries: MAX_RETRIES,
+    stale: 30000 // 30 seconds
+  });
+
+  try {
+    // Read data while holding the lock
+    const data = JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf8'));
+    const now = new Date().toISOString();
+    let changes = 0;
+
+    // Clean up expired sessions first
+    const nowDate = new Date();
+    let cleanedCount = 0;
+
+    for (const [existingSessionId, sessionData] of Object.entries(data.sessions)) {
+      const lastActivity = new Date(sessionData.last_activity);
+      const timeDiff = nowDate - lastActivity;
+
+      if (timeDiff >= SESSION_TIMEOUT) {
+        delete data.sessions[existingSessionId];
+        cleanedCount++;
+      }
+    }
+
+    // Remove the specific session if it exists
+    if (data.sessions[sessionId]) {
+      delete data.sessions[sessionId];
+      changes = 1;
+    }
+
+    // Write updated data while still holding the lock
+    if (changes > 0 || cleanedCount > 0) {
+      data.last_updated = now;
+      fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+    }
+
+    if (cleanedCount > 0) {
+      // console.error(`Cleaned up ${cleanedCount} expired sessions`);
+    }
+
+    return { changes, cleaned_sessions: cleanedCount };
+  } finally {
+    await release();
+  }
+};
+
+const getActiveSessionsWithLock = async () => {
+  await initSessionsFile();
+
+  const release = await lockfile.lock(SESSIONS_FILE, {
+    retries: MAX_RETRIES,
+    stale: 30000 // 30 seconds
+  });
+
+  try {
+    const data = JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf8'));
+    const now = new Date();
+    const activeSessions = [];
+
+    for (const [sessionId, sessionData] of Object.entries(data.sessions)) {
+      const lastActivity = new Date(sessionData.last_activity);
+      const timeDiff = now - lastActivity;
+
+      if (timeDiff < SESSION_TIMEOUT) {
+        activeSessions.push({
+          id: sessionId,
+          ...sessionData
+        });
+      }
+    }
+
+    return activeSessions;
+  } finally {
+    await release();
+  }
+};
+
+const cleanupExpiredSessionsWithLock = async () => {
+  await initSessionsFile();
+
+  const release = await lockfile.lock(SESSIONS_FILE, {
+    retries: MAX_RETRIES,
+    stale: 30000 // 30 seconds
+  });
+
+  try {
+    const data = JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf8'));
+    const now = new Date();
+    let removedCount = 0;
+
+    for (const [sessionId, sessionData] of Object.entries(data.sessions)) {
+      const lastActivity = new Date(sessionData.last_activity);
+      const timeDiff = now - lastActivity;
+
+      if (timeDiff >= SESSION_TIMEOUT) {
+        delete data.sessions[sessionId];
+        removedCount++;
+      }
+    }
+
+    if (removedCount > 0) {
+      data.last_updated = new Date().toISOString();
+      fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+    }
+
+    return { changes: removedCount };
+  } finally {
+    await release();
+  }
+};
+
+module.exports = {
+  initSessionsFile,
+  readSessionsWithLock,
+  addSessionWithLock,
+  removeSessionWithLock,
+  getActiveSessionsWithLock,
+  cleanupExpiredSessionsWithLock
+};

package/src/system-tray.js

@@ -0,0 +1,247 @@
+/**
+ * System Tray module - Handles all system tray functionality
+ */
+
+const path = require('path');
+
+const { getActiveSessionsWithLock, cleanupExpiredSessionsWithLock } = require('./session');
+const { getElectron } = require('./electron');
+const { removePidFileWithLock } = require('./pid');
+const package = require('../package.json');
+
+let trayState = null;
+
+/**
+ * Create icon for system tray
+ */
+const createIcon = isActive => {
+  const icon = isActive ? '../assets/icon-coffee-full.png' : '../assets/icon-coffee-empty.png';
+  const iconPath = path.join(__dirname, icon);
+  const { nativeImage } = getElectron();
+  return nativeImage.createFromPath(iconPath);
+};
+
+/**
+ * Create system tray
+ */
+const createSystemTray = () => {
+  const { Tray, Menu } = getElectron();
+
+  if (!Tray) {
+    throw new Error('Electron Tray is not available');
+  }
+
+  try {
+    const tray = new Tray(createIcon(false));
+    tray.setToolTip('CC-Caffeine: Normal');
+
+    trayState = {
+      tray,
+      isCaffeinated: false,
+      pollInterval: null,
+      powerSaveBlockerId: null
+    };
+
+    if (!Menu) {
+      throw new Error('Electron Menu is not available');
+    }
+
+    const contextMenu = Menu.buildFromTemplate([
+      {
+        label: `Version: ${package.version}`,
+        enabled: false
+      },
+      {
+        label: 'Github',
+        click: () => {
+          getElectron().shell.openExternal('https://github.com/samber/cc-caffeine')
+        }
+      },
+      {
+        label: '💖 Sponsor',
+        click: () => {
+          getElectron().shell.openExternal('https://github.com/sponsors/samber')
+        }
+      },
+      {
+        type: 'separator'
+      },
+      {
+        label: 'Exit',
+        click: async () => {
+          await shutdownServer(trayState);
+          process.exit(0);
+        }
+      }
+    ]);
+
+    tray.setContextMenu(contextMenu);
+    return trayState;
+  } catch (error) {
+    console.error('Error creating Electron system tray:', error);
+    throw error;
+  }
+};
+
+/**
+ * Get current system tray state
+ */
+const getSystemTrayState = () => {
+  return trayState;
+};
+
+/**
+ * Get system tray instance
+ */
+const getSystemTray = () => {
+  if (!trayState) {
+    return createSystemTray();
+  }
+  return trayState;
+};
+
+/**
+ * Update tray icon based on caffeine state
+ */
+const updateTrayIcon = state => {
+  if (!state || !state.tray) {
+    return;
+  }
+
+  const icon = createIcon(state.isCaffeinated);
+  state.tray.setImage(icon);
+  state.tray.setToolTip(`CC-Caffeine: ${state.isCaffeinated ? 'Caffeinated' : 'Normal'}`);
+};
+
+/**
+ * Enable caffeine (prevent sleep)
+ */
+const enableCaffeine = state => {
+  if (!state.isCaffeinated) {
+    const { powerSaveBlocker } = getElectron();
+    state.isCaffeinated = true;
+    state.powerSaveBlockerId = powerSaveBlocker.start('prevent-app-suspension');
+  }
+};
+
+/**
+ * Disable caffeine (allow sleep)
+ */
+const disableCaffeine = state => {
+  if (state.isCaffeinated) {
+    const { powerSaveBlocker } = getElectron();
+    state.isCaffeinated = false;
+    if (state.powerSaveBlockerId !== null) {
+      powerSaveBlocker.stop(state.powerSaveBlockerId);
+      state.powerSaveBlockerId = null;
+    }
+  }
+};
+
+/**
+ * Update caffeine status based on active sessions
+ */
+const updateCaffeineStatus = async state => {
+  if (!state) {
+    return;
+  }
+
+  try {
+    await cleanupExpiredSessionsWithLock();
+    const activeSessions = await getActiveSessionsWithLock();
+    const shouldCaffeinate = activeSessions.length > 0;
+
+    if (shouldCaffeinate && !state.isCaffeinated) {
+      enableCaffeine(state);
+    } else if (!shouldCaffeinate && state.isCaffeinated) {
+      disableCaffeine(state);
+    }
+
+    updateTrayIcon(state);
+  } catch (error) {
+    console.error('Error updating caffeine status:', error);
+  }
+};
+
+/**
+ * Start polling for session changes
+ */
+const startPolling = (state, interval = 10000) => {
+  // Initial check
+  updateCaffeineStatus(state);
+
+  // Set up periodic polling
+  state.pollInterval = setInterval(() => {
+    updateCaffeineStatus(state);
+  }, interval);
+};
+
+/**
+ * Stop polling
+ */
+const stopPolling = state => {
+  if (state && state.pollInterval) {
+    try {
+      clearInterval(state.pollInterval);
+      state.pollInterval = null;
+    } catch (error) {
+      console.error('Error clearing interval:', error.message);
+    }
+  }
+};
+
+/**
+ * Shutdown server and clean up resources
+ */
+const shutdownServer = async state => {
+  console.error('Shutting down caffeine server...');
+
+  if (!state) {
+    console.error('No state provided, exiting...');
+    return;
+  }
+
+  // Stop polling
+  stopPolling(state);
+
+  // Always disable caffeine before shutting down
+  try {
+    disableCaffeine(state);
+  } catch (error) {
+    console.error('Error disabling caffeine:', error.message);
+  }
+
+  // Clean up Electron system tray
+  try {
+    if (state.tray) {
+      state.tray.destroy();
+      state.tray = null;
+    }
+  } catch (error) {
+    console.error('Error destroying Electron system tray:', error.message);
+  }
+
+  // Remove PID file
+  try {
+    await removePidFileWithLock();
+  } catch (error) {
+    console.error('Error removing PID file:', error.message);
+  }
+
+  // Reset global state
+  trayState = null;
+};
+
+module.exports = {
+  createIcon,
+  createSystemTray,
+  getSystemTray,
+  getSystemTrayState,
+  updateTrayIcon,
+  enableCaffeine,
+  disableCaffeine,
+  updateCaffeineStatus,
+  startPolling,
+  stopPolling,
+  shutdownServer
+};