claude-nonstop 0.3.0

package/lib/service.js

@@ -0,0 +1,196 @@
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { isMacOS } from './platform.js';
+import { CONFIG_DIR } from './config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '..');
+
+const SERVICE_LABEL = 'claude-nonstop-slack';
+const PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+const LOG_DIR = join(CONFIG_DIR, 'logs');
+const LOG_PATH = join(LOG_DIR, 'webhook.log');
+
+/**
+ * Generate the launchd plist XML for the webhook service.
+ */
+function generatePlist() {
+  const webhookScript = join(PROJECT_ROOT, 'remote', 'start-webhook.cjs');
+  const nodePath = process.execPath;
+  const nodeBinDir = dirname(nodePath);
+
+  // Build PATH including the directory containing tmux, which may be in
+  // /opt/homebrew/bin (Apple Silicon) or elsewhere not in launchd's default PATH.
+  const pathDirs = new Set([nodeBinDir, '/usr/local/bin', '/usr/bin', '/bin']);
+  try {
+    const tmuxPath = execFileSync('which', ['tmux'], { encoding: 'utf8', timeout: 3000 }).trim();
+    if (tmuxPath) pathDirs.add(dirname(tmuxPath));
+  } catch {
+    // tmux not found — include /opt/homebrew/bin as a common fallback
+    pathDirs.add('/opt/homebrew/bin');
+  }
+  const envPath = [...pathDirs].join(':');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${SERVICE_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${webhookScript}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${envPath}</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Install and start the launchd service.
+ */
+function installService() {
+  if (!isMacOS()) {
+    throw new Error('Service management is only supported on macOS (launchd)');
+  }
+
+  // Ensure log directory exists (user-only permissions)
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+  }
+
+  // Ensure LaunchAgents directory exists
+  const launchAgentsDir = dirname(PLIST_PATH);
+  if (!existsSync(launchAgentsDir)) {
+    mkdirSync(launchAgentsDir, { recursive: true });
+  }
+
+  const uid = process.getuid();
+  const domain = `gui/${uid}`;
+
+  // Bootout first if already loaded (so bootstrap picks up the new plist)
+  try {
+    execFileSync('launchctl', ['bootout', `${domain}/${SERVICE_LABEL}`], { stdio: 'pipe' });
+  } catch {
+    // Ignore — service may not be loaded
+  }
+
+  // Write plist (after bootout, before bootstrap) with restrictive permissions
+  const plist = generatePlist();
+  writeFileSync(PLIST_PATH, plist, { mode: 0o600 });
+
+  // Bootstrap the service (load + start)
+  try {
+    execFileSync('launchctl', ['bootstrap', domain, PLIST_PATH], { stdio: 'pipe' });
+  } catch (err) {
+    throw new Error(`Failed to bootstrap service: ${err.stderr?.toString().trim() || err.message}`);
+  }
+}
+
+/**
+ * Stop and remove the launchd service.
+ */
+function uninstallService() {
+  if (!isMacOS()) {
+    throw new Error('Service management is only supported on macOS (launchd)');
+  }
+
+  const uid = process.getuid();
+  const domain = `gui/${uid}`;
+
+  // Bootout (stop + unload)
+  try {
+    execFileSync('launchctl', ['bootout', `${domain}/${SERVICE_LABEL}`], { stdio: 'pipe' });
+  } catch {
+    // Ignore — service may not be loaded
+  }
+
+  // Delete plist
+  if (existsSync(PLIST_PATH)) {
+    unlinkSync(PLIST_PATH);
+  }
+}
+
+/**
+ * Restart the launchd service (also refreshes the plist).
+ */
+function restartService() {
+  if (!isMacOS()) {
+    throw new Error('Service management is only supported on macOS (launchd)');
+  }
+
+  // Full cycle: bootout, write fresh plist, bootstrap
+  // This ensures path changes (node upgrade, project move) are picked up
+  installService();
+}
+
+/**
+ * Get service status including PID.
+ * Returns { installed, running, pid }.
+ */
+function getServiceStatus() {
+  if (!isMacOS()) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  const installed = existsSync(PLIST_PATH);
+  if (!installed) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  const uid = process.getuid();
+  const domain = `gui/${uid}`;
+
+  try {
+    const output = execFileSync('launchctl', ['print', `${domain}/${SERVICE_LABEL}`], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf8',
+    });
+
+    // Parse PID from output (line like "pid = 12345" or "pid = (not running)")
+    const pidMatch = output.match(/pid\s*=\s*(\d+)/);
+    const pid = pidMatch ? parseInt(pidMatch[1], 10) : null;
+    const running = pid !== null;
+
+    return { installed: true, running, pid };
+  } catch {
+    // Service not loaded
+    return { installed: true, running: false, pid: null };
+  }
+}
+
+/**
+ * Check if the service plist is installed.
+ */
+function isServiceInstalled() {
+  return isMacOS() && existsSync(PLIST_PATH);
+}
+
+export {
+  SERVICE_LABEL,
+  PLIST_PATH,
+  LOG_PATH,
+  LOG_DIR,
+  generatePlist,
+  installService,
+  uninstallService,
+  restartService,
+  getServiceStatus,
+  isServiceInstalled,
+};

package/lib/session.js

@@ -0,0 +1,294 @@
+/**
+ * Session migration between Claude Code config directories.
+ *
+ * Claude Code stores sessions at:
+ *   <CLAUDE_CONFIG_DIR>/projects/<cwdHash>/<sessionId>.jsonl
+ *
+ * The cwdHash is the absolute CWD path with '/' replaced by '-'.
+ * Example: /Users/rc/code/myproject -> -Users-rc-code-myproject
+ *
+ * When switching accounts mid-session, we copy the session files
+ * to the new account's config dir so `claude --resume` can find them.
+ */
+
+import { existsSync, mkdirSync, cpSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+// UUID v4 pattern — Claude Code session IDs are always UUIDs
+const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * Validate a session ID to prevent path traversal.
+ * Session IDs must be valid UUID v4 strings.
+ *
+ * @param {string} sessionId
+ * @throws {Error} if the session ID is invalid
+ */
+export function validateSessionId(sessionId) {
+  if (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId)) {
+    throw new Error('Invalid session ID: must be a valid UUID');
+  }
+}
+
+/**
+ * Compute the project directory hash for a CWD.
+ * Claude Code uses the absolute path with '/' replaced by '-'.
+ *
+ * @param {string} cwd - The working directory
+ * @returns {string} The hashed directory name
+ */
+export function getCwdHash(cwd) {
+  const resolved = cwd.startsWith('~')
+    ? cwd.replace(/^~/, homedir())
+    : cwd;
+  // Replace all path separators with '-'
+  return resolved.replace(/\//g, '-');
+}
+
+/**
+ * Get the projects directory for a config dir and CWD.
+ *
+ * @param {string} configDir - The CLAUDE_CONFIG_DIR
+ * @param {string} cwd - The working directory
+ * @returns {string} Full path to the project's session directory
+ */
+export function getProjectDir(configDir, cwd) {
+  const expanded = configDir.startsWith('~')
+    ? configDir.replace(/^~/, homedir())
+    : configDir;
+  return join(expanded, 'projects', getCwdHash(cwd));
+}
+
+/**
+ * Find the most recently modified session in a project directory.
+ *
+ * @param {string} configDir - The CLAUDE_CONFIG_DIR
+ * @param {string} cwd - The working directory
+ * @returns {{ sessionId: string, path: string } | null}
+ */
+export function findLatestSession(configDir, cwd) {
+  const projectDir = getProjectDir(configDir, cwd);
+
+  if (!existsSync(projectDir)) return null;
+
+  let latest = null;
+  let latestMtime = 0;
+
+  try {
+    const entries = readdirSync(projectDir);
+    for (const entry of entries) {
+      if (!entry.endsWith('.jsonl')) continue;
+
+      const fullPath = join(projectDir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.mtimeMs > latestMtime) {
+          latestMtime = stat.mtimeMs;
+          latest = {
+            sessionId: basename(entry, '.jsonl'),
+            path: fullPath,
+          };
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  return latest;
+}
+
+/**
+ * Search all accounts' project directories for a specific session ID.
+ *
+ * @param {Array<{name: string, configDir: string}>} accounts
+ * @param {string} sessionId - The session ID to find
+ * @returns {{ account: object, cwdHash: string, path: string, mtime: number } | null}
+ */
+export function findSessionAcrossProfiles(accounts, sessionId) {
+  validateSessionId(sessionId);
+  const filename = `${sessionId}.jsonl`;
+  let best = null;
+
+  for (const account of accounts) {
+    const expanded = account.configDir.startsWith('~')
+      ? account.configDir.replace(/^~/, homedir())
+      : account.configDir;
+    const projectsDir = join(expanded, 'projects');
+
+    if (!existsSync(projectsDir)) continue;
+
+    let cwdHashes;
+    try {
+      cwdHashes = readdirSync(projectsDir);
+    } catch {
+      continue;
+    }
+
+    for (const cwdHash of cwdHashes) {
+      const sessionPath = join(projectsDir, cwdHash, filename);
+      try {
+        const stat = statSync(sessionPath);
+        if (!best || stat.mtimeMs > best.mtime) {
+          best = { account, cwdHash, path: sessionPath, mtime: stat.mtimeMs };
+        }
+      } catch {
+        // File doesn't exist in this cwdHash — skip
+      }
+    }
+  }
+
+  return best;
+}
+
+/**
+ * Find the most recently modified session across all accounts for the current project.
+ *
+ * @param {Array<{name: string, configDir: string}>} accounts
+ * @param {string} cwd - The working directory to scope the search to
+ * @returns {{ account: object, cwdHash: string, sessionId: string, path: string, mtime: number } | null}
+ */
+export function findLatestSessionAcrossProfiles(accounts, cwd) {
+  const cwdHash = getCwdHash(cwd);
+  let best = null;
+
+  for (const account of accounts) {
+    const expanded = account.configDir.startsWith('~')
+      ? account.configDir.replace(/^~/, homedir())
+      : account.configDir;
+    const cwdDir = join(expanded, 'projects', cwdHash);
+
+    if (!existsSync(cwdDir)) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(cwdDir);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.endsWith('.jsonl')) continue;
+      const fullPath = join(cwdDir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (!best || stat.mtimeMs > best.mtime) {
+          best = {
+            account,
+            cwdHash,
+            sessionId: basename(entry, '.jsonl'),
+            path: fullPath,
+            mtime: stat.mtimeMs,
+          };
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+  }
+
+  return best;
+}
+
+/**
+ * Migrate a session using a cwdHash directly (instead of computing from CWD).
+ * Used by the resume command when the original CWD is unknown.
+ *
+ * @param {string} fromConfigDir - Source config directory
+ * @param {string} toConfigDir - Destination config directory
+ * @param {string} cwdHash - The project directory hash
+ * @param {string} sessionId - The session ID to migrate
+ * @returns {{ success: boolean, error?: string }}
+ */
+export function migrateSessionByHash(fromConfigDir, toConfigDir, cwdHash, sessionId) {
+  validateSessionId(sessionId);
+  try {
+    const expandFrom = fromConfigDir.startsWith('~')
+      ? fromConfigDir.replace(/^~/, homedir())
+      : fromConfigDir;
+    const expandTo = toConfigDir.startsWith('~')
+      ? toConfigDir.replace(/^~/, homedir())
+      : toConfigDir;
+
+    const fromProjectDir = join(expandFrom, 'projects', cwdHash);
+    const toProjectDir = join(expandTo, 'projects', cwdHash);
+
+    if (!existsSync(toProjectDir)) {
+      mkdirSync(toProjectDir, { recursive: true });
+    }
+
+    const sessionFile = `${sessionId}.jsonl`;
+    const fromSession = join(fromProjectDir, sessionFile);
+    const toSession = join(toProjectDir, sessionFile);
+
+    if (!existsSync(fromSession)) {
+      return { success: false, error: `Session file not found: ${fromSession}` };
+    }
+
+    cpSync(fromSession, toSession, { force: true });
+
+    // Copy tool-results directory if it exists
+    const fromToolResults = join(fromProjectDir, sessionId);
+    const toToolResults = join(toProjectDir, sessionId);
+
+    if (existsSync(fromToolResults)) {
+      cpSync(fromToolResults, toToolResults, { recursive: true, force: true });
+    }
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Migrate a session from one config dir to another.
+ *
+ * Copies:
+ * - The session .jsonl file
+ * - The associated tool-results directory (if it exists)
+ *
+ * @param {string} fromConfigDir - Source config directory
+ * @param {string} toConfigDir - Destination config directory
+ * @param {string} cwd - The working directory
+ * @param {string} sessionId - The session ID to migrate
+ * @returns {{ success: boolean, error?: string }}
+ */
+export function migrateSession(fromConfigDir, toConfigDir, cwd, sessionId) {
+  validateSessionId(sessionId);
+  try {
+    const fromProjectDir = getProjectDir(fromConfigDir, cwd);
+    const toProjectDir = getProjectDir(toConfigDir, cwd);
+
+    // Ensure destination project directory exists
+    if (!existsSync(toProjectDir)) {
+      mkdirSync(toProjectDir, { recursive: true });
+    }
+
+    // Copy session file
+    const sessionFile = `${sessionId}.jsonl`;
+    const fromSession = join(fromProjectDir, sessionFile);
+    const toSession = join(toProjectDir, sessionFile);
+
+    if (!existsSync(fromSession)) {
+      return { success: false, error: `Session file not found: ${fromSession}` };
+    }
+
+    cpSync(fromSession, toSession, { force: true });
+
+    // Copy tool-results directory if it exists
+    const fromToolResults = join(fromProjectDir, sessionId);
+    const toToolResults = join(toProjectDir, sessionId);
+
+    if (existsSync(fromToolResults)) {
+      cpSync(fromToolResults, toToolResults, { recursive: true, force: true });
+    }
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}

package/lib/tmux.js

@@ -0,0 +1,95 @@
+/**
+ * tmux session management for --remote-access mode.
+ *
+ * Handles detecting if we're inside tmux, generating session names,
+ * and re-executing the current process inside a new tmux session.
+ */
+
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+import { createHash } from 'crypto';
+
+/**
+ * Check if currently running inside a tmux session.
+ * @returns {boolean}
+ */
+export function isInsideTmux() {
+  return !!process.env.TMUX;
+}
+
+/**
+ * Generate a tmux session name from the current working directory.
+ * Uses basename + short hash of full path to avoid collisions when
+ * multiple projects share the same directory name.
+ * Example: /Users/rc/code/myproject -> "myproject-a1b2c3"
+ * @returns {string}
+ */
+export function generateSessionName() {
+  const cwd = process.cwd();
+  const hash = createHash('sha256').update(cwd).digest('hex').slice(0, 6);
+  const base = `${basename(cwd)}-${hash}`;
+  if (!tmuxSessionExists(base)) return base;
+  let counter = 2;
+  while (tmuxSessionExists(`${base}-${counter}`)) counter++;
+  return `${base}-${counter}`;
+}
+
+/**
+ * Get the name of the current tmux session (must be called from inside tmux).
+ * @returns {string|null} Session name, or null if not inside tmux.
+ */
+export function getCurrentTmuxSession() {
+  try {
+    return execFileSync('tmux', ['display-message', '-p', '#S'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a tmux session with the given name exists.
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function tmuxSessionExists(name) {
+  try {
+    execFileSync('tmux', ['has-session', '-t', name], {
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Re-exec the current process inside a new or existing tmux session.
+ *
+ * If a tmux session with the given name exists, attaches to it.
+ * If not, creates a new session running the same command.
+ *
+ * Uses execSync with stdio: 'inherit' so the terminal stays connected
+ * to the tmux session. When the user detaches (Ctrl-B D), execSync
+ * returns and we exit cleanly.
+ *
+ * @param {string} sessionName - The tmux session name
+ * @param {string[]} argv - The full process.argv to re-invoke
+ */
+export function reexecInTmux(sessionName, argv) {
+  if (tmuxSessionExists(sessionName)) {
+    // Session exists — just attach
+    execFileSync('tmux', ['attach-session', '-t', sessionName], {
+      stdio: 'inherit',
+    });
+  } else {
+    // Create new session running the same command
+    execFileSync('tmux', ['new-session', '-s', sessionName, ...argv], {
+      stdio: 'inherit',
+    });
+  }
+
+  process.exit(0);
+}