git-watchtower 2.2.2 → 2.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "Terminal-based Git branch monitor with activity sparklines and optional dev server with live reload",
   "main": "bin/git-watchtower.js",
   "bin": {

package/src/cli/args.js

@@ -169,6 +169,19 @@ function parseArgs(argv, options = {}) {
       result.errors.push(`Unknown option: ${args[i]}`);
     }
   }
+
+  // Cross-validation: if both --port and --web-port are explicit on the
+  // CLI, they must differ. The web dashboard's EADDRINUSE-retry loop
+  // would silently bump the web port to the next free slot, hiding the
+  // misconfiguration — and the user thinks they're hitting :4000 when
+  // it's actually :4001. Surface the conflict at parse time instead.
+  if (result.port !== null && result.webPort !== null && result.port === result.webPort) {
+    result.errors.push(
+      `--port and --web-port cannot share the same value (${result.port}). ` +
+      `Pick a different value for one of them.`,
+    );
+  }
+
   return result;
 }
 

package/src/git/branch.js

@@ -198,81 +198,6 @@ async function getAllBranches(options = {}) {
   }
 }
 
-/**
- * Detect changes between two branch lists
- * @param {Branch[]} oldBranches - Previous branch list
- * @param {Branch[]} newBranches - Current branch list
- * @returns {{added: Branch[], removed: Branch[], updated: Branch[]}}
- */
-function detectBranchChanges(oldBranches, newBranches) {
-  const oldNames = new Map(oldBranches.map((b) => [b.name, b]));
-  const newNames = new Map(newBranches.map((b) => [b.name, b]));
-
-  const added = newBranches.filter((b) => !oldNames.has(b.name));
-  const removed = oldBranches.filter((b) => !newNames.has(b.name));
-  const updated = newBranches.filter((b) => {
-    const old = oldNames.get(b.name);
-    return old && old.commit !== b.commit;
-  });
-
-  return { added, removed, updated };
-}
-
-/**
- * Check out a branch
- * @param {string} branchName - Branch to check out
- * @param {Object} [options] - Options
- * @param {string} [options.remoteName='origin'] - Remote name
- * @param {boolean} [options.force=false] - Force checkout (discard changes)
- * @param {string} [options.cwd] - Working directory
- * @returns {Promise<{success: boolean, error?: GitError}>}
- */
-async function checkout(branchName, options = {}) {
-  const { remoteName = 'origin', force = false, cwd } = options;
-
-  try {
-    // Validate branch name
-    const safeName = sanitizeBranchName(branchName);
-
-    // Check for uncommitted changes (unless force)
-    if (!force && (await hasUncommittedChanges(cwd))) {
-      return {
-        success: false,
-        error: new GitError(
-          'Cannot switch: uncommitted changes in working directory',
-          'GIT_DIRTY_WORKDIR'
-        ),
-      };
-    }
-
-    // Check if local branch exists
-    const { stdout: localBranches } = await execGit(['branch', '--list'], { cwd });
-    const hasLocal = localBranches
-      .split('\n')
-      .some((b) => b.trim().replace(/^\* /, '') === safeName);
-
-    if (hasLocal) {
-      // Local branch exists - just check out
-      if (force) {
-        await execGit(['checkout', '--', '.'], { cwd });
-        await execGit(['checkout', safeName], { cwd });
-      } else {
-        await execGit(['checkout', safeName], { cwd });
-      }
-    } else {
-      // Create local branch from remote
-      await execGit(['checkout', '-b', safeName, `${remoteName}/${safeName}`], { cwd });
-    }
-
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof GitError ? error : GitError.fromExecError(error, 'checkout'),
-    };
-  }
-}
-
 /**
  * Get preview data for a branch
  * @param {string} branchName - Branch name
@@ -449,8 +374,6 @@ module.exports = {
   sanitizeBranchName,
   getCurrentBranch,
   getAllBranches,
-  detectBranchChanges,
-  checkout,
   getPreviewData,
   generateSparkline,
   getLocalBranches,

package/src/index.js

@@ -123,8 +123,6 @@ module.exports = {
   sanitizeBranchName: gitBranch.sanitizeBranchName,
   getCurrentBranch: gitBranch.getCurrentBranch,
   getAllBranches: gitBranch.getAllBranches,
-  detectBranchChanges: gitBranch.detectBranchChanges,
-  checkout: gitBranch.checkout,
   getPreviewData: gitBranch.getPreviewData,
   generateSparkline: gitBranch.generateSparkline,
   getLocalBranches: gitBranch.getLocalBranches,
@@ -153,7 +151,6 @@ module.exports = {
   deleteConfig: configLoader.deleteConfig,
 
   // Server process management
-  ProcessManager: serverProcess.ProcessManager,
   parseCommand: serverProcess.parseCommand,
 
   // Web dashboard server

package/src/polling/engine.js

@@ -1,154 +1,14 @@
 /**
- * Polling engine — pure logic for branch change detection and sorting
+ * Polling engine — pure logic for branch tracking-set maintenance.
+ *
+ * Note: this module previously also exported helpers like detectNewBranches,
+ * detectDeletedBranches, sortBranches, calculateAdaptiveInterval, etc., but
+ * the bin reimplements those flows inline. Only pruneStaleEntries is wired
+ * up in production, so that's all that lives here now.
+ *
  * @module polling/engine
  */
 
-const { isBaseBranch } = require('../git/pr');
-
-/**
- * Detect new branches not previously known.
- * @param {Array<{name: string, isNew?: boolean, newAt?: number}>} allBranches - All currently fetched branches
- * @param {Set<string>} knownBranchNames - Previously known branch names
- * @returns {Array<{name: string, isNew?: boolean, newAt?: number}>} Branches with isNew flag
- */
-function detectNewBranches(allBranches, knownBranchNames) {
-  const now = Date.now();
-  const newBranches = [];
-  for (const branch of allBranches) {
-    if (!knownBranchNames.has(branch.name)) {
-      branch.isNew = true;
-      branch.newAt = now;
-      newBranches.push(branch);
-    }
-  }
-  return newBranches;
-}
-
-/**
- * Detect deleted branches (were known but no longer exist in fetched set).
- * @param {Set<string>} knownBranchNames - Previously known branch names
- * @param {Set<string>} fetchedBranchNames - Currently fetched branch names
- * @param {Array<{name: string, isDeleted?: boolean, deletedAt?: number}>} existingBranches - Previous branch list
- * @returns {Array<{name: string, isDeleted?: boolean, deletedAt?: number}>} Deleted branches
- */
-function detectDeletedBranches(knownBranchNames, fetchedBranchNames, existingBranches) {
-  const now = Date.now();
-  const deleted = [];
-  for (const knownName of knownBranchNames) {
-    if (!fetchedBranchNames.has(knownName)) {
-      const existing = existingBranches.find(b => b.name === knownName);
-      if (existing && !existing.isDeleted) {
-        existing.isDeleted = true;
-        existing.deletedAt = now;
-        deleted.push(existing);
-      }
-    }
-  }
-  return deleted;
-}
-
-/**
- * Detect branches that have been updated (commit changed) since last poll.
- * @param {Array<{name: string, commit: string, isDeleted?: boolean, justUpdated?: boolean}>} branches - Current branch list
- * @param {Map<string, string>} previousStates - Map of branch name -> previous commit hash
- * @param {string} currentBranch - Name of current branch (excluded from updates)
- * @returns {Array<{name: string, commit: string, isDeleted?: boolean, justUpdated?: boolean}>} Updated branches
- */
-function detectUpdatedBranches(branches, previousStates, currentBranch) {
-  const updated = [];
-  for (const branch of branches) {
-    // Clear previous cycle's flag so only freshly-updated branches are highlighted
-    branch.justUpdated = false;
-    if (branch.isDeleted) continue;
-    const prevCommit = previousStates.get(branch.name);
-    if (prevCommit && prevCommit !== branch.commit && branch.name !== currentBranch) {
-      branch.justUpdated = true;
-      updated.push(branch);
-    }
-  }
-  return updated;
-}
-
-/**
- * Sort branches: new first, then by date, merged near bottom, deleted at bottom.
- * @param {Array} branches - Branch list to sort
- * @param {Map} prStatusMap - Map of branch name -> PR status
- * @returns {Array} Sorted branches (mutates and returns input)
- */
-function sortBranches(branches, prStatusMap) {
-  return branches.sort((a, b) => {
-    const aIsBase = isBaseBranch(a.name);
-    const bIsBase = isBaseBranch(b.name);
-    const aMerged = !aIsBase && prStatusMap.has(a.name) && prStatusMap.get(a.name).state === 'MERGED';
-    const bMerged = !bIsBase && prStatusMap.has(b.name) && prStatusMap.get(b.name).state === 'MERGED';
-    if (a.isDeleted && !b.isDeleted) return 1;
-    if (!a.isDeleted && b.isDeleted) return -1;
-    if (aMerged && !bMerged && !b.isDeleted) return 1;
-    if (!aMerged && bMerged && !a.isDeleted) return -1;
-    if (a.isNew && !b.isNew) return -1;
-    if (!a.isNew && b.isNew) return 1;
-    return (b.date || 0) - (a.date || 0);
-  });
-}
-
-/**
- * Calculate adaptive polling interval based on fetch duration.
- * @param {number} fetchDuration - How long the fetch took (ms)
- * @param {number} currentInterval - Current polling interval (ms)
- * @param {number} baseInterval - Base/default polling interval (ms)
- * @returns {{ interval: number, warning: string|null }}
- */
-function calculateAdaptiveInterval(fetchDuration, currentInterval, baseInterval) {
-  if (fetchDuration > 30000) {
-    return {
-      interval: Math.min(currentInterval * 2, 60000),
-      warning: 'very_slow',
-    };
-  }
-  if (fetchDuration > 15000) {
-    return {
-      interval: currentInterval,
-      warning: 'slow',
-    };
-  }
-  if (fetchDuration < 5000 && currentInterval > baseInterval) {
-    return {
-      interval: baseInterval,
-      warning: 'restored',
-    };
-  }
-  return {
-    interval: currentInterval,
-    warning: null,
-  };
-}
-
-/**
- * Restore selection index after branch list reorder.
- * @param {Array<{name: string}>} branches - New branch list
- * @param {string|null} previousName - Previously selected branch name
- * @param {number} previousIndex - Previously selected index
- * @returns {{ selectedIndex: number, selectedBranchName: string|null }}
- */
-function restoreSelection(branches, previousName, previousIndex) {
-  if (previousName) {
-    const newIndex = branches.findIndex(b => b.name === previousName);
-    if (newIndex >= 0) {
-      return { selectedIndex: newIndex, selectedBranchName: previousName };
-    }
-    const clampedIndex = Math.min(previousIndex, Math.max(0, branches.length - 1));
-    return {
-      selectedIndex: clampedIndex,
-      selectedBranchName: branches[clampedIndex] ? branches[clampedIndex].name : null,
-    };
-  }
-  if (previousIndex >= branches.length) {
-    const idx = Math.max(0, branches.length - 1);
-    return { selectedIndex: idx, selectedBranchName: branches[idx] ? branches[idx].name : null };
-  }
-  return { selectedIndex: previousIndex, selectedBranchName: previousName };
-}
-
 /**
  * Prune stale entries from tracking sets and caches for branches
  * that no longer exist in git.
@@ -182,11 +42,5 @@ function pruneStaleEntries({ knownBranchNames, fetchedBranchNames, allBranches,
 }
 
 module.exports = {
-  detectNewBranches,
-  detectDeletedBranches,
-  detectUpdatedBranches,
-  sortBranches,
-  calculateAdaptiveInterval,
-  restoreSelection,
   pruneStaleEntries,
 };

package/src/server/process.js

@@ -1,34 +1,10 @@
 /**
- * Server process management for command mode
- * Manages spawning, stopping, and monitoring of user's dev server
- */
-
-const { spawn } = require('child_process');
-const { ServerError } = require('../utils/errors');
-const { Mutex } = require('../utils/async');
-
-/**
- * @typedef {Object} ServerProcessState
- * @property {import('child_process').ChildProcess|null} process - The server process
- * @property {boolean} running - Is the server running
- * @property {boolean} crashed - Did the server crash
- * @property {Array<{timestamp: string, line: string, isError: boolean}>} logs - Server logs
- */
-
-/**
- * Maximum log lines to keep in buffer
- */
-const MAX_LOG_LINES = 500;
-
-/**
- * Grace period before force kill (ms)
- */
-const KILL_GRACE_PERIOD = 3000;
-
-/**
- * Restart delay after stop (ms)
+ * Server process management — command parsing for command mode
+ *
+ * Note: the bin's `startServerProcess` / `stopServerProcess` /
+ * `restartServerProcess` implement the actual lifecycle inline; this
+ * file only exports the parseCommand helper they use.
  */
-const RESTART_DELAY = 500;
 
 /**
  * Parse a command string into command and arguments.
@@ -96,333 +72,6 @@ function parseCommand(commandString) {
   };
 }
 
-/**
- * Server process manager
- */
-class ProcessManager {
-  /**
-   * @param {Object} [options]
-   * @param {string} [options.cwd] - Working directory
-   * @param {Function} [options.onLog] - Log callback (line, isError)
-   * @param {Function} [options.onStateChange] - State change callback (state)
-   */
-  constructor(options = {}) {
-    this.cwd = options.cwd || process.cwd();
-    this.onLog = options.onLog || (() => {});
-    this.onStateChange = options.onStateChange || (() => {});
-
-    this.process = null;
-    this.running = false;
-    this.crashed = false;
-    this.logs = [];
-    this.command = '';
-    this._restartMutex = new Mutex();
-  }
-
-  /**
-   * Get current state
-   * @returns {ServerProcessState}
-   */
-  getState() {
-    return {
-      process: this.process,
-      running: this.running,
-      crashed: this.crashed,
-      logs: [...this.logs],
-    };
-  }
-
-  /**
-   * Add a log entry
-   * @param {string} line - Log line
-   * @param {boolean} [isError=false] - Is error output
-   */
-  addLog(line, isError = false) {
-    const entry = {
-      timestamp: new Date().toLocaleTimeString(),
-      line,
-      isError,
-    };
-    this.logs.push(entry);
-    if (this.logs.length > MAX_LOG_LINES) {
-      this.logs.shift();
-    }
-    this.onLog(line, isError);
-  }
-
-  /**
-   * Clear log buffer
-   */
-  clearLogs() {
-    this.logs = [];
-  }
-
-  /**
-   * Start the server process
-   * @param {string} commandString - Command to run
-   * @returns {{success: boolean, error?: Error, pid?: number}}
-   */
-  start(commandString) {
-    if (!commandString) {
-      return {
-        success: false,
-        error: ServerError.startFailed(commandString, 'No command specified'),
-      };
-    }
-
-    // Stop existing process first
-    if (this.process) {
-      this.stop();
-    }
-
-    this.clearLogs();
-    this.crashed = false;
-    this.running = false;
-    this.command = commandString;
-
-    this.addLog(`$ ${commandString}`);
-
-    // Parse command
-    const { command, args } = parseCommand(commandString);
-
-    if (!command) {
-      const error = ServerError.startFailed(commandString, 'Invalid command');
-      this.crashed = true;
-      this.addLog(`Failed to start: Invalid command`, true);
-      this.notifyStateChange();
-      return { success: false, error };
-    }
-
-    // Spawn options
-    const isWindows = process.platform === 'win32';
-    /** @type {import('child_process').SpawnOptions} */
-    const spawnOptions = {
-      cwd: this.cwd,
-      env: { ...process.env, FORCE_COLOR: '1' },
-      shell: isWindows,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      // On Unix, create a new process group so we can kill the entire tree
-      // (e.g. npm -> node -> next). On Windows, taskkill /t handles this.
-      detached: !isWindows,
-    };
-
-    try {
-      this.process = spawn(command, args, spawnOptions);
-      this.running = true;
-
-      // Handle stdout
-      this.process.stdout?.on('data', (data) => {
-        const lines = data.toString().split('\n').filter(Boolean);
-        lines.forEach((line) => this.addLog(line));
-      });
-
-      // Handle stderr
-      this.process.stderr?.on('data', (data) => {
-        const lines = data.toString().split('\n').filter(Boolean);
-        lines.forEach((line) => this.addLog(line, true));
-      });
-
-      // Handle error
-      this.process.on('error', (err) => {
-        this.running = false;
-        this.crashed = true;
-        this.addLog(`Error: ${err.message}`, true);
-        this.notifyStateChange();
-      });
-
-      // Handle close
-      this.process.on('close', (code) => {
-        this.running = false;
-        if (code !== 0 && code !== null) {
-          this.crashed = true;
-          this.addLog(`Process exited with code ${code}`, true);
-        } else {
-          this.addLog('Process stopped');
-        }
-        this.process = null;
-        this.notifyStateChange();
-      });
-
-      this.notifyStateChange();
-      return { success: true, pid: this.process.pid };
-    } catch (err) {
-      this.crashed = true;
-      this.addLog(`Failed to start: ${err.message}`, true);
-      this.notifyStateChange();
-      return {
-        success: false,
-        error: ServerError.startFailed(commandString, err.message),
-      };
-    }
-  }
-
-  /**
-   * Stop the server process
-   * @returns {boolean} - True if a process was stopped
-   */
-  stop() {
-    if (!this.process) {
-      return false;
-    }
-
-    // Capture reference before nulling — needed for deferred force-kill
-    const proc = this.process;
-
-    if (process.platform === 'win32') {
-      this._stopWindows(proc);
-    } else {
-      this._stopUnix(proc);
-    }
-
-    this.process = null;
-    this.running = false;
-    this.notifyStateChange();
-    return true;
-  }
-
-  /**
-   * Unix stop: SIGTERM the process group, then SIGKILL after a grace period.
-   * The grace timer is unref'd so it doesn't keep the event loop alive when
-   * the main process wants to exit.
-   * @param {import('child_process').ChildProcess} proc
-   * @private
-   */
-  _stopUnix(proc) {
-    // If the process has already exited, there's nothing to signal.
-    if (proc.exitCode !== null || proc.signalCode !== null) return;
-
-    try {
-      process.kill(-proc.pid, 'SIGTERM');
-    } catch (e) {
-      // Process group may already be dead
-      return;
-    }
-
-    const forceKillTimeout = setTimeout(() => {
-      // Re-check: process may have exited during the grace period.
-      if (proc.exitCode !== null || proc.signalCode !== null) return;
-      try {
-        process.kill(-proc.pid, 'SIGKILL');
-      } catch (e) {
-        // Process group may already be dead
-      }
-    }, KILL_GRACE_PERIOD);
-
-    // Don't let this timer keep the event loop alive on shutdown.
-    forceKillTimeout.unref();
-
-    // Clear early if the process exits before the grace period.
-    proc.once('close', () => {
-      clearTimeout(forceKillTimeout);
-    });
-  }
-
-  /**
-   * Windows stop: taskkill /t (tree kill). If the process doesn't exit
-   * within the grace period, retry with /f (force).
-   * @param {import('child_process').ChildProcess} proc
-   * @private
-   */
-  _stopWindows(proc) {
-    if (proc.exitCode !== null || proc.signalCode !== null) return;
-
-    try {
-      spawn('taskkill', ['/pid', proc.pid.toString(), '/t']);
-    } catch (e) {
-      // Ignore spawn errors (PID already gone, etc.)
-      return;
-    }
-
-    // Fallback: force-kill if the process is still alive after the
-    // grace period. This mirrors the Unix SIGTERM → SIGKILL pattern.
-    const forceKillTimeout = setTimeout(() => {
-      if (proc.exitCode !== null || proc.signalCode !== null) return;
-      try {
-        spawn('taskkill', ['/pid', proc.pid.toString(), '/f', '/t']);
-      } catch (e) {
-        // Ignore — process may already be dead
-      }
-    }, KILL_GRACE_PERIOD);
-
-    forceKillTimeout.unref();
-
-    proc.once('close', () => {
-      clearTimeout(forceKillTimeout);
-    });
-  }
-
-  /**
-   * Restart the server process.
-   *
-   * Waits for the old process to fully exit (so it releases its port)
-   * rather than sleeping a static RESTART_DELAY that is shorter than
-   * the SIGKILL grace period. Bounded by KILL_GRACE_PERIOD + a small
-   * margin so we never hang indefinitely if 'close' doesn't fire.
-   *
-   * @returns {Promise<{success: boolean, error?: Error, pid?: number}>}
-   */
-  async restart() {
-    return this._restartMutex.withLock(async () => {
-      const command = this.command;
-      // Capture before stop() nulls this.process.
-      const oldProc = this.process;
-
-      this.stop();
-
-      if (oldProc && oldProc.exitCode === null && oldProc.signalCode === null) {
-        // Old process hasn't exited yet — wait for 'close' with a bounded
-        // timeout so we don't hang if the process ignores all signals.
-        await new Promise((resolve) => {
-          const timeout = setTimeout(resolve, KILL_GRACE_PERIOD + RESTART_DELAY);
-          timeout.unref();
-          oldProc.once('close', () => {
-            clearTimeout(timeout);
-            resolve();
-          });
-        });
-      }
-
-      return this.start(command);
-    });
-  }
-
-  /**
-   * Check if server is running
-   * @returns {boolean}
-   */
-  isRunning() {
-    return this.running;
-  }
-
-  /**
-   * Check if server crashed
-   * @returns {boolean}
-   */
-  hasCrashed() {
-    return this.crashed;
-  }
-
-  /**
-   * Get server PID
-   * @returns {number|null}
-   */
-  getPid() {
-    return this.process ? this.process.pid : null;
-  }
-
-  /**
-   * Notify state change
-   * @private
-   */
-  notifyStateChange() {
-    this.onStateChange(this.getState());
-  }
-}
-
 module.exports = {
-  ProcessManager,
   parseCommand,
-  MAX_LOG_LINES,
-  KILL_GRACE_PERIOD,
-  RESTART_DELAY,
 };

package/src/utils/sound.js

@@ -3,30 +3,57 @@
  * @module utils/sound
  */
 
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
+
+const noop = () => {};
+
+const playBell = () => {
+  process.stdout.write('\x07');
+};
+
+// Linux audio-tool cascade. Each entry is [command, args]; we try them in
+// order and fall through on non-zero exit, ending in a terminal bell.
+// Mirrors the previous shell `||` chain without spawning a shell.
+const LINUX_ATTEMPTS = [
+  ['paplay', ['/usr/share/sounds/freedesktop/stereo/message-new-instant.oga']],
+  ['paplay', ['/usr/share/sounds/freedesktop/stereo/complete.oga']],
+  ['aplay', ['-q', '/usr/share/sounds/sound-icons/prompt.wav']],
+];
+
+function cascade(attempts, onAllFailed, options) {
+  if (attempts.length === 0) {
+    onAllFailed();
+    return;
+  }
+  const [cmd, args] = attempts[0];
+  execFile(cmd, args, options, (err) => {
+    if (err) cascade(attempts.slice(1), onAllFailed, options);
+  });
+}
 
 /**
  * Play a system notification sound (non-blocking).
- * Cross-platform: macOS (afplay), Linux (paplay/aplay), Windows (terminal bell).
+ *
+ * Cross-platform: macOS (afplay), Linux (paplay/aplay cascade), Windows
+ * (terminal bell). Uses execFile (no shell) to match the pattern in
+ * casino/sounds.js — the previous exec calls passed fixed strings so
+ * there was no injection surface either way, but dropping the shell
+ * removes the per-call /bin/sh fork and makes the two sound modules
+ * consistent.
+ *
  * @param {object} [options]
- * @param {string} [options.cwd] - Working directory for exec
+ * @param {string} [options.cwd] - Working directory
  */
 function playSound(options = {}) {
   const { platform } = process;
   const cwd = options.cwd || process.cwd();
 
   if (platform === 'darwin') {
-    exec('afplay /System/Library/Sounds/Pop.aiff 2>/dev/null', { cwd });
+    execFile('afplay', ['/System/Library/Sounds/Pop.aiff'], { cwd }, noop);
   } else if (platform === 'linux') {
-    exec(
-      'paplay /usr/share/sounds/freedesktop/stereo/message-new-instant.oga 2>/dev/null || ' +
-      'paplay /usr/share/sounds/freedesktop/stereo/complete.oga 2>/dev/null || ' +
-      'aplay /usr/share/sounds/sound-icons/prompt.wav 2>/dev/null || ' +
-      'printf "\\a"',
-      { cwd }
-    );
+    cascade(LINUX_ATTEMPTS, playBell, { cwd });
   } else {
-    process.stdout.write('\x07');
+    playBell();
   }
 }