git-watchtower 1.8.1 → 1.8.3

package/bin/git-watchtower.js

@@ -56,7 +56,7 @@
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
-const { exec, execSync, spawn } = require('child_process');
+const { execFile, execSync, spawn } = require('child_process');
 const readline = require('readline');
 
 // Casino mode - Vegas-style feedback effects
@@ -74,7 +74,7 @@ const { formatTimeAgo } = require('../src/utils/time');
 const { openInBrowser: openUrl } = require('../src/utils/browser');
 const { playSound: playSoundEffect } = require('../src/utils/sound');
 const { parseArgs: parseCliArgs, applyCliArgsToConfig: mergeCliArgs, getHelpText, PACKAGE_VERSION } = require('../src/cli/args');
-const { checkForUpdate } = require('../src/utils/version-check');
+const { checkForUpdate, startPeriodicUpdateCheck } = require('../src/utils/version-check');
 const { parseRemoteUrl, buildBranchUrl, detectPlatform, buildWebUrl, extractSessionUrl } = require('../src/git/remote');
 const { parseGitHubPr, parseGitLabMr, parseGitHubPrList, parseGitLabMrList, isBaseBranch } = require('../src/git/pr');
 
@@ -82,7 +82,7 @@ const { parseGitHubPr, parseGitLabMr, parseGitHubPrList, parseGitLabMrList, isBa
 // Security & Validation (imported from src/git/branch.js and src/git/commands.js)
 // ============================================================================
 const { isValidBranchName, sanitizeBranchName, getGoneBranches, deleteGoneBranches } = require('../src/git/branch');
-const { isGitAvailable: checkGitAvailable } = require('../src/git/commands');
+const { isGitAvailable: checkGitAvailable, execGit, execGitSilent, getDiffStats: getDiffStatsSafe } = require('../src/git/commands');
 
 // ============================================================================
 // Configuration (imports from src/config/, inline wizard kept here)
@@ -436,7 +436,7 @@ function openInBrowser(url) {
 
 async function getRemoteWebUrl(branchName) {
   try {
-    const { stdout } = await execAsync(`git remote get-url "${REMOTE_NAME}"`);
+    const { stdout } = await execGit(['remote', 'get-url', REMOTE_NAME], { cwd: PROJECT_ROOT });
     const parsed = parseRemoteUrl(stdout);
     return buildWebUrl(parsed, branchName);
   } catch (e) {
@@ -446,20 +446,21 @@ async function getRemoteWebUrl(branchName) {
 
 // Extract Claude Code session URL from the most recent commit on a branch
 async function getSessionUrl(branchName) {
-  try {
-    const { stdout } = await execAsync(
-      `git log "${REMOTE_NAME}/${branchName}" -1 --format=%B 2>/dev/null || git log "${branchName}" -1 --format=%B 2>/dev/null`
-    );
-    return extractSessionUrl(stdout);
-  } catch (e) {
-    return null;
-  }
+  // Try remote branch first, fall back to local
+  const result = await execGitSilent(
+    ['log', `${REMOTE_NAME}/${branchName}`, '-1', '--format=%B'],
+    { cwd: PROJECT_ROOT }
+  ) || await execGitSilent(
+    ['log', branchName, '-1', '--format=%B'],
+    { cwd: PROJECT_ROOT }
+  );
+  return result ? extractSessionUrl(result.stdout) : null;
 }
 
 // Check if a CLI tool is available
 async function hasCommand(cmd) {
   try {
-    await execAsync(`which ${cmd} 2>/dev/null`);
+    await execCli('which', [cmd]);
     return true;
   } catch (e) {
     return false;
@@ -472,17 +473,18 @@ async function hasCommand(cmd) {
 async function getPrInfo(branchName, platform, hasGh, hasGlab) {
   if (platform === 'github' && hasGh) {
     try {
-      const { stdout } = await execAsync(
-        `gh pr list --head "${branchName}" --state all --json number,title,state,reviewDecision,statusCheckRollup --limit 1`
-      );
+      const { stdout } = await execCli('gh', [
+        'pr', 'list', '--head', branchName, '--state', 'all',
+        '--json', 'number,title,state,reviewDecision,statusCheckRollup', '--limit', '1',
+      ]);
       return parseGitHubPr(JSON.parse(stdout));
     } catch (e) { /* gh not authed or other error */ }
   }
   if (platform === 'gitlab' && hasGlab) {
     try {
-      const { stdout } = await execAsync(
-        `glab mr list --source-branch="${branchName}" --state all --output json 2>/dev/null`
-      );
+      const { stdout } = await execCli('glab', [
+        'mr', 'list', `--source-branch=${branchName}`, '--state', 'all', '--output', 'json',
+      ]);
       return parseGitLabMr(JSON.parse(stdout));
     } catch (e) { /* glab not authed or other error */ }
   }
@@ -492,11 +494,7 @@ async function getPrInfo(branchName, platform, hasGh, hasGlab) {
 // Check if gh/glab CLI is authenticated
 async function checkCliAuth(cmd) {
   try {
-    if (cmd === 'gh') {
-      await execAsync('gh auth status 2>&1');
-    } else if (cmd === 'glab') {
-      await execAsync('glab auth status 2>&1');
-    }
+    await execCli(cmd, ['auth', 'status']);
     return true;
   } catch (e) {
     return false;
@@ -510,18 +508,19 @@ async function fetchAllPrStatuses() {
 
   if (platform === 'github' && hasGh && ghAuthed) {
     try {
-      const { stdout } = await execAsync(
-        'gh pr list --state all --json headRefName,number,title,state --limit 200'
-      );
+      const { stdout } = await execCli('gh', [
+        'pr', 'list', '--state', 'all',
+        '--json', 'headRefName,number,title,state', '--limit', '200',
+      ]);
       return parseGitHubPrList(JSON.parse(stdout));
     } catch (e) { /* gh error */ }
   }
 
   if (platform === 'gitlab' && hasGlab && glabAuthed) {
     try {
-      const { stdout } = await execAsync(
-        'glab mr list --state all --output json 2>/dev/null'
-      );
+      const { stdout } = await execCli('glab', [
+        'mr', 'list', '--state', 'all', '--output', 'json',
+      ]);
       return parseGitLabMrList(JSON.parse(stdout));
     } catch (e) { /* glab error */ }
   }
@@ -815,22 +814,30 @@ const LIVE_RELOAD_SCRIPT = `
 // Utility Functions
 // ============================================================================
 
-// Default timeout for execAsync (30 seconds) — prevents hung git/CLI commands
+// Default timeout for CLI commands (30 seconds) — prevents hung commands
 // from permanently blocking the polling loop
-const EXEC_ASYNC_TIMEOUT = 30000;
+const CLI_TIMEOUT = 30000;
 
-function execAsync(command, options = {}) {
-  const { timeout = EXEC_ASYNC_TIMEOUT, ...restOptions } = options;
+/**
+ * Execute a non-git CLI command safely using execFile (no shell interpolation).
+ * For git commands, use execGit/execGitSilent from src/git/commands.js instead.
+ * @param {string} cmd - The executable (e.g. 'gh', 'glab', 'which')
+ * @param {string[]} args - Arguments array (no shell interpolation)
+ * @param {Object} [options] - Execution options
+ * @param {number} [options.timeout] - Command timeout in ms
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function execCli(cmd, args = [], options = {}) {
+  const { timeout = CLI_TIMEOUT, ...restOptions } = options;
   return new Promise((resolve, reject) => {
-    const child = exec(command, { cwd: PROJECT_ROOT, timeout, ...restOptions }, (error, stdout, stderr) => {
+    const child = execFile(cmd, args, { cwd: PROJECT_ROOT, timeout, ...restOptions }, (error, stdout, stderr) => {
       if (error) {
         reject({ error, stdout, stderr });
       } else {
         resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
       }
     });
-    // Also kill the child if the timeout fires (exec timeout sends SIGTERM
-    // but doesn't guarantee cleanup of process trees)
+    // Force-kill if process outlives timeout grace period
     if (timeout > 0) {
       const killTimer = setTimeout(() => {
         try { child.kill('SIGKILL'); } catch (e) { /* already dead */ }
@@ -841,18 +848,13 @@ function execAsync(command, options = {}) {
 }
 
 /**
- * Get diff stats between two commits
+ * Get diff stats between two commits (delegates to src/git/commands.js)
  * @param {string} fromCommit - Starting commit
  * @param {string} toCommit - Ending commit (default HEAD)
  * @returns {Promise<{added: number, deleted: number}>}
  */
 async function getDiffStats(fromCommit, toCommit = 'HEAD') {
-  try {
-    const { stdout } = await execAsync(`git diff --stat ${fromCommit}..${toCommit}`);
-    return parseDiffStats(stdout);
-  } catch (e) {
-    return { added: 0, deleted: 0 };
-  }
+  return getDiffStatsSafe(fromCommit, toCommit, { cwd: PROJECT_ROOT });
 }
 
 // formatTimeAgo imported from src/utils/time.js
@@ -945,10 +947,15 @@ async function refreshAllSparklines() {
     for (const branch of currentBranches.slice(0, 20)) { // Limit to top 20
       if (branch.isDeleted) continue;
 
-      // Get commit counts for last 7 days
-      const { stdout } = await execAsync(
-        `git log origin/${branch.name} --since="7 days ago" --format="%ad" --date=format:"%Y-%m-%d" 2>/dev/null || git log ${branch.name} --since="7 days ago" --format="%ad" --date=format:"%Y-%m-%d" 2>/dev/null`
-      ).catch(() => ({ stdout: '' }));
+      // Get commit counts for last 7 days (try remote, fall back to local)
+      const sparkResult = await execGitSilent(
+        ['log', `origin/${branch.name}`, '--since=7 days ago', '--format=%ad', '--date=format:%Y-%m-%d'],
+        { cwd: PROJECT_ROOT }
+      ) || await execGitSilent(
+        ['log', branch.name, '--since=7 days ago', '--format=%ad', '--date=format:%Y-%m-%d'],
+        { cwd: PROJECT_ROOT }
+      );
+      const stdout = sparkResult ? sparkResult.stdout : '';
 
       // Count commits per day
       const dayCounts = new Map();
@@ -978,10 +985,15 @@ async function refreshAllSparklines() {
 
 async function getPreviewData(branchName) {
   try {
-    // Get last 5 commits
-    const { stdout: logOutput } = await execAsync(
-      `git log origin/${branchName} -5 --oneline 2>/dev/null || git log ${branchName} -5 --oneline 2>/dev/null`
-    ).catch(() => ({ stdout: '' }));
+    // Get last 5 commits (try remote, fall back to local)
+    const logResult = await execGitSilent(
+      ['log', `origin/${branchName}`, '-5', '--oneline'],
+      { cwd: PROJECT_ROOT }
+    ) || await execGitSilent(
+      ['log', branchName, '-5', '--oneline'],
+      { cwd: PROJECT_ROOT }
+    );
+    const logOutput = logResult ? logResult.stdout : '';
 
     const commits = logOutput.split('\n').filter(Boolean).map(line => {
       const [hash, ...msgParts] = line.split(' ');
@@ -990,13 +1002,15 @@ async function getPreviewData(branchName) {
 
     // Get files changed (comparing to current branch)
     let filesChanged = [];
-    try {
-      const { stdout: diffOutput } = await execAsync(
-        `git diff --stat --name-only HEAD...origin/${branchName} 2>/dev/null || git diff --stat --name-only HEAD...${branchName} 2>/dev/null`
-      );
-      filesChanged = diffOutput.split('\n').filter(Boolean).slice(0, 8);
-    } catch (e) {
-      // No diff available
+    const diffResult = await execGitSilent(
+      ['diff', '--stat', '--name-only', `HEAD...origin/${branchName}`],
+      { cwd: PROJECT_ROOT }
+    ) || await execGitSilent(
+      ['diff', '--stat', '--name-only', `HEAD...${branchName}`],
+      { cwd: PROJECT_ROOT }
+    );
+    if (diffResult) {
+      filesChanged = diffResult.stdout.split('\n').filter(Boolean).slice(0, 8);
     }
 
     return { commits, filesChanged };
@@ -1232,6 +1246,11 @@ function render() {
   if (state.stashConfirmMode) {
     renderer.renderStashConfirm(state, write);
   }
+
+  // Update notification modal renders on top of everything
+  if (state.updateModalVisible) {
+    renderer.renderUpdateModal(state, write);
+  }
 }
 
 function showFlash(message) {
@@ -1307,12 +1326,12 @@ function hideStashConfirm() {
 
 async function getCurrentBranch() {
   try {
-    const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD');
+    const { stdout } = await execGit(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: PROJECT_ROOT });
     // Check for detached HEAD state
     if (stdout === 'HEAD') {
       store.setState({ isDetachedHead: true });
       // Get the short commit hash instead
-      const { stdout: commitHash } = await execAsync('git rev-parse --short HEAD');
+      const { stdout: commitHash } = await execGit(['rev-parse', '--short', 'HEAD'], { cwd: PROJECT_ROOT });
       return `HEAD@${commitHash}`;
     }
     store.setState({ isDetachedHead: false });
@@ -1324,7 +1343,7 @@ async function getCurrentBranch() {
 
 async function checkRemoteExists() {
   try {
-    const { stdout } = await execAsync('git remote');
+    const { stdout } = await execGit(['remote'], { cwd: PROJECT_ROOT });
     const remotes = stdout.split('\n').filter(Boolean);
     return remotes.length > 0;
   } catch (e) {
@@ -1334,7 +1353,7 @@ async function checkRemoteExists() {
 
 async function hasUncommittedChanges() {
   try {
-    const { stdout } = await execAsync('git status --porcelain');
+    const { stdout } = await execGit(['status', '--porcelain'], { cwd: PROJECT_ROOT, timeout: 5000 });
     return stdout.length > 0;
   } catch (e) {
     return false;
@@ -1345,14 +1364,15 @@ async function hasUncommittedChanges() {
 
 async function getAllBranches() {
   try {
-    await execAsync('git fetch --all --prune 2>/dev/null').catch(() => {});
+    await execGitSilent(['fetch', '--all', '--prune'], { cwd: PROJECT_ROOT, timeout: 60000 });
 
     const branchList = [];
     const seenBranches = new Set();
 
     // Get local branches
-    const { stdout: localOutput } = await execAsync(
-      'git for-each-ref --sort=-committerdate --format="%(refname:short)|%(committerdate:iso8601)|%(objectname:short)|%(subject)" refs/heads/'
+    const { stdout: localOutput } = await execGit(
+      ['for-each-ref', '--sort=-committerdate', '--format=%(refname:short)|%(committerdate:iso8601)|%(objectname:short)|%(subject)', 'refs/heads/'],
+      { cwd: PROJECT_ROOT }
     );
 
     for (const line of localOutput.split('\n').filter(Boolean)) {
@@ -1372,9 +1392,11 @@ async function getAllBranches() {
     }
 
     // Get remote branches (using configured remote name)
-    const { stdout: remoteOutput } = await execAsync(
-      `git for-each-ref --sort=-committerdate --format="%(refname:short)|%(committerdate:iso8601)|%(objectname:short)|%(subject)" refs/remotes/${REMOTE_NAME}/`
-    ).catch(() => ({ stdout: '' }));
+    const remoteResult = await execGitSilent(
+      ['for-each-ref', '--sort=-committerdate', '--format=%(refname:short)|%(committerdate:iso8601)|%(objectname:short)|%(subject)', `refs/remotes/${REMOTE_NAME}/`],
+      { cwd: PROJECT_ROOT }
+    );
+    const remoteOutput = remoteResult ? remoteResult.stdout : '';
 
     const remotePrefix = `${REMOTE_NAME}/`;
     for (const line of remoteOutput.split('\n').filter(Boolean)) {
@@ -1437,13 +1459,14 @@ async function switchToBranch(branchName, recordHistory = true) {
     addLog(`Switching to ${safeBranchName}...`, 'update');
     render();
 
-    const { stdout: localBranches } = await execAsync('git branch --list');
-    const hasLocal = localBranches.split('\n').some(b => b.trim().replace('* ', '') === safeBranchName);
+    const { stdout: localBranches } = await execGit(['branch', '--list'], { cwd: PROJECT_ROOT });
+    const hasLocal = localBranches.split('\n').some(b => b.trim().replace(/^\* /, '') === safeBranchName);
 
     if (hasLocal) {
-      await execAsync(`git checkout -- . 2>/dev/null; git checkout "${safeBranchName}"`);
+      await execGitSilent(['checkout', '--', '.'], { cwd: PROJECT_ROOT });
+      await execGit(['checkout', safeBranchName], { cwd: PROJECT_ROOT });
     } else {
-      await execAsync(`git checkout -b "${safeBranchName}" "${REMOTE_NAME}/${safeBranchName}"`);
+      await execGit(['checkout', '-b', safeBranchName, `${REMOTE_NAME}/${safeBranchName}`], { cwd: PROJECT_ROOT });
     }
 
     store.setState({ currentBranch: safeBranchName, isDetachedHead: false });
@@ -1535,7 +1558,7 @@ async function pullCurrentBranch() {
     addLog(`Pulling from ${REMOTE_NAME}/${branch}...`, 'update');
     render();
 
-    await execAsync(`git pull "${REMOTE_NAME}" "${branch}"`);
+    await execGit(['pull', REMOTE_NAME, branch], { cwd: PROJECT_ROOT, timeout: 60000 });
     addLog('Pulled successfully', 'success');
     pendingDirtyOperation = null;
     notifyClients();
@@ -1862,12 +1885,12 @@ async function pollGitChanges() {
       const oldCommit = currentInfo.commit;
 
       try {
-        await execAsync(`git pull "${REMOTE_NAME}" "${autoPullBranchName}"`);
+        await execGit(['pull', REMOTE_NAME, autoPullBranchName], { cwd: PROJECT_ROOT, timeout: 60000 });
         addLog(`Pulled successfully from ${autoPullBranchName}`, 'success');
         currentInfo.hasUpdates = false;
         store.setState({ hasMergeConflict: false });
         // Update the stored commit to the new one
-        const newCommit = await execAsync('git rev-parse --short HEAD');
+        const newCommit = await execGit(['rev-parse', '--short', 'HEAD'], { cwd: PROJECT_ROOT });
         currentInfo.commit = newCommit.stdout.trim();
         previousBranchStates.set(autoPullBranchName, newCommit.stdout.trim());
         // Reload browsers
@@ -2268,9 +2291,9 @@ function setupKeyboardInput() {
           try {
             let result;
             if (platform === 'gitlab') {
-              result = await execAsync(`glab mr create --source-branch="${aBranch.name}" --fill --yes 2>&1`);
+              result = await execCli('glab', ['mr', 'create', `--source-branch=${aBranch.name}`, '--fill', '--yes']);
             } else {
-              result = await execAsync(`gh pr create --head "${aBranch.name}" --fill 2>&1`);
+              result = await execCli('gh', ['pr', 'create', '--head', aBranch.name, '--fill']);
             }
             addLog(`${prLabel} created: ${(result.stdout || '').trim().split('\n').pop()}`, 'success');
             // Invalidate cache and refresh modal data
@@ -2309,9 +2332,9 @@ function setupKeyboardInput() {
         render();
         try {
           if (platform === 'gitlab') {
-            await execAsync(`glab mr approve ${prInfo.number} 2>&1`);
+            await execCli('glab', ['mr', 'approve', String(prInfo.number)]);
           } else {
-            await execAsync(`gh pr review ${prInfo.number} --approve 2>&1`);
+            await execCli('gh', ['pr', 'review', String(prInfo.number), '--approve']);
           }
           addLog(`${prLabel} #${prInfo.number} approved`, 'success');
           // Refresh PR info to show updated status
@@ -2329,9 +2352,9 @@ function setupKeyboardInput() {
         render();
         try {
           if (platform === 'gitlab') {
-            await execAsync(`glab mr merge ${prInfo.number} --squash --remove-source-branch --yes 2>&1`);
+            await execCli('glab', ['mr', 'merge', String(prInfo.number), '--squash', '--remove-source-branch', '--yes']);
           } else {
-            await execAsync(`gh pr merge ${prInfo.number} --squash --delete-branch 2>&1`);
+            await execCli('gh', ['pr', 'merge', String(prInfo.number), '--squash', '--delete-branch']);
           }
           addLog(`${prLabel} #${prInfo.number} merged`, 'success');
           store.setState({ actionMode: false, actionData: null, actionLoading: false });
@@ -2351,13 +2374,13 @@ function setupKeyboardInput() {
         render();
         try {
           if (platform === 'gitlab') {
-            const result = await execAsync(`glab ci status --branch "${aBranch.name}" 2>&1`);
+            const result = await execCli('glab', ['ci', 'status', '--branch', aBranch.name]);
             const lines = (result.stdout || '').trim().split('\n');
             for (const line of lines.slice(0, 3)) {
               addLog(line.trim(), 'info');
             }
           } else if (prInfo) {
-            const result = await execAsync(`gh pr checks ${prInfo.number} 2>&1`);
+            const result = await execCli('gh', ['pr', 'checks', String(prInfo.number)]);
             const lines = (result.stdout || '').trim().split('\n');
             for (const line of lines.slice(0, 5)) {
               addLog(line.trim(), 'info');
@@ -2438,6 +2461,71 @@ function setupKeyboardInput() {
       return; // Ignore other keys in cleanup mode
     }
 
+    // Handle update notification modal
+    if (store.get('updateModalVisible')) {
+      if (store.get('updateInProgress')) {
+        return; // Block all keys while update is running
+      }
+      if (key === '\u001b') {
+        store.setState({ updateModalVisible: false, updateModalSelectedIndex: 0 });
+        render();
+        return;
+      }
+      if (key === '\u001b[A' || key === 'k') { // Up
+        const idx = store.get('updateModalSelectedIndex');
+        if (idx > 0) {
+          store.setState({ updateModalSelectedIndex: idx - 1 });
+          render();
+        }
+        return;
+      }
+      if (key === '\u001b[B' || key === 'j') { // Down
+        const idx = store.get('updateModalSelectedIndex');
+        if (idx < 1) {
+          store.setState({ updateModalSelectedIndex: idx + 1 });
+          render();
+        }
+        return;
+      }
+      if (key === '\r' || key === '\n') {
+        const selectedIdx = store.get('updateModalSelectedIndex') || 0;
+        if (selectedIdx === 0) {
+          // Update now — run npm i -g git-watchtower
+          store.setState({ updateInProgress: true });
+          render();
+          const { spawn } = require('child_process');
+          const child = spawn('npm', ['i', '-g', 'git-watchtower'], {
+            stdio: 'ignore',
+            detached: false,
+          });
+          child.on('close', (code) => {
+            store.setState({ updateInProgress: false, updateModalVisible: false, updateModalSelectedIndex: 0 });
+            if (code === 0) {
+              store.setState({ updateAvailable: null });
+              addLog('Successfully updated git-watchtower! Restart to use new version.', 'update');
+              showFlash('Updated! Restart to use new version.');
+            } else {
+              addLog(`Update failed (exit code ${code}). Run manually: npm i -g git-watchtower`, 'error');
+              showFlash('Update failed. Try manually: npm i -g git-watchtower');
+            }
+            render();
+          });
+          child.on('error', (err) => {
+            store.setState({ updateInProgress: false, updateModalVisible: false, updateModalSelectedIndex: 0 });
+            addLog(`Update failed: ${err.message}. Run manually: npm i -g git-watchtower`, 'error');
+            showFlash('Update failed. Try manually: npm i -g git-watchtower');
+            render();
+          });
+        } else {
+          // Show update command — dismiss modal with flash showing the command
+          store.setState({ updateModalVisible: false, updateModalSelectedIndex: 0 });
+          showFlash('Run: npm i -g git-watchtower');
+        }
+        return;
+      }
+      return; // Block all other keys while modal is shown
+    }
+
     // Handle stash confirmation dialog
     if (store.get('stashConfirmMode')) {
       if (key === '\u001b[A' || key === 'k') { // Up
@@ -2958,11 +3046,26 @@ async function start() {
   // Check for newer version on npm (non-blocking, silent on failure)
   checkForUpdate().then((latestVersion) => {
     if (latestVersion) {
-      store.setState({ updateAvailable: latestVersion });
+      store.setState({ updateAvailable: latestVersion, updateModalVisible: true });
       addLog(`New version available: ${latestVersion} \u2192 npm i -g git-watchtower`, 'update');
       render();
     }
   }).catch(() => {});
+
+  // Re-check for updates periodically (every 4 hours) while running
+  const periodicCheck = startPeriodicUpdateCheck((latestVersion) => {
+    const alreadyKnown = store.get('updateAvailable');
+    store.setState({ updateAvailable: latestVersion });
+    if (!alreadyKnown) {
+      // First time discovering an update during this session — show modal
+      store.setState({ updateModalVisible: true });
+      addLog(`New version available: ${latestVersion} \u2192 npm i -g git-watchtower`, 'update');
+    }
+    render();
+  });
+
+  // Clean up periodic check on exit
+  process.on('exit', () => periodicCheck.stop());
 }
 
 start().catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.8.1",
+  "version": "1.8.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/state/store.js

@@ -102,6 +102,9 @@
  * @property {string} projectName - Project name
  * @property {number} clientCount - Connected SSE clients
  * @property {string|null} updateAvailable - Latest version if update available, or null
+ * @property {boolean} updateModalVisible - Whether the update notification modal is shown
+ * @property {number} updateModalSelectedIndex - Selected option index in the update modal
+ * @property {boolean} updateInProgress - Whether an update is currently being installed
  */
 
 /**
@@ -184,6 +187,9 @@ function getInitialState() {
 
     // Version check
     updateAvailable: null,
+    updateModalVisible: false,
+    updateModalSelectedIndex: 0,
+    updateInProgress: false,
   };
 }
 

package/src/ui/renderer.js

@@ -1311,6 +1311,111 @@ function renderCleanupConfirm(state, write) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// renderUpdateModal
+// ---------------------------------------------------------------------------
+
+/**
+ * Render a prominent update-available notification modal.
+ *
+ * @param {object} state
+ * @param {function} write
+ */
+function renderUpdateModal(state, write) {
+  if (!state.updateModalVisible || !state.updateAvailable) return;
+
+  const latestVersion = state.updateAvailable;
+  const currentVer = PACKAGE_VERSION;
+  const updateCmd = 'npm i -g git-watchtower';
+
+  const options = [
+    'Update now',
+    'Show update command',
+  ];
+  const selectedIdx = state.updateModalSelectedIndex || 0;
+
+  const width = Math.min(52, state.terminalWidth - 4);
+  const col = Math.floor((state.terminalWidth - width) / 2);
+  const row = Math.max(2, Math.floor((state.terminalHeight - 14) / 2));
+
+  const lines = [];
+  lines.push('Update Available');
+  lines.push('');
+  lines.push(`Current version:  v${currentVer}`);
+  lines.push(`Latest version:   v${latestVersion}`);
+  lines.push('');
+
+  if (state.updateInProgress) {
+    lines.push('Updating...');
+    lines.push('');
+    lines.push(`  ${updateCmd}`);
+    lines.push('');
+    lines.push('Please wait...');
+  } else {
+    // Option lines
+    const optionStartIdx = lines.length;
+    for (const opt of options) {
+      lines.push(opt);
+    }
+    lines.push('');
+    lines.push('[Enter] Select  [Esc] Dismiss');
+  }
+
+  const optionStartIdx = state.updateInProgress ? -1 : 5;
+  const height = lines.length + 2;
+
+  // Draw magenta double-border box
+  write(ansi.moveTo(row, col));
+  write(ansi.magenta + ansi.bold);
+  write(box.dTopLeft + box.dHorizontal.repeat(width - 2) + box.dTopRight);
+
+  for (let i = 1; i < height - 1; i++) {
+    write(ansi.moveTo(row + i, col));
+    write(ansi.magenta + box.dVertical + ansi.reset + '  ' + ' '.repeat(width - 6) + '  ' + ansi.magenta + box.dVertical + ansi.reset);
+  }
+
+  write(ansi.moveTo(row + height - 1, col));
+  write(ansi.magenta + box.dBottomLeft + box.dHorizontal.repeat(width - 2) + box.dBottomRight);
+  write(ansi.reset);
+
+  // Render content
+  let contentRow = row + 1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    write(ansi.moveTo(contentRow, col + 3));
+
+    if (i === 0) {
+      // Title — centered, bold magenta
+      const titlePadding = Math.floor((width - 6 - line.length) / 2);
+      write(' '.repeat(titlePadding) + ansi.magenta + ansi.bold + line + ansi.reset + ' '.repeat(Math.max(0, width - 6 - titlePadding - line.length)));
+    } else if (i >= optionStartIdx && optionStartIdx >= 0 && i < optionStartIdx + options.length) {
+      // Selectable option
+      const optIdx = i - optionStartIdx;
+      const isSelected = optIdx === selectedIdx;
+      const prefix = isSelected ? '\u25b8 ' : '  ';
+      const optText = prefix + line;
+      if (isSelected) {
+        write(ansi.bold + ansi.cyan + padRight(optText, width - 6) + ansi.reset);
+      } else {
+        write(ansi.gray + padRight(optText, width - 6) + ansi.reset);
+      }
+    } else if (line === '[Enter] Select  [Esc] Dismiss') {
+      // Keyboard hints — centered, dim
+      const lPadding = Math.floor((width - 6 - line.length) / 2);
+      write(ansi.dim + ' '.repeat(Math.max(0, lPadding)) + line + ' '.repeat(Math.max(0, width - 6 - lPadding - line.length)) + ansi.reset);
+    } else if (line === 'Updating...') {
+      write(ansi.bold + ansi.yellow + padRight(line, width - 6) + ansi.reset);
+    } else if (line === 'Please wait...') {
+      const lPadding = Math.floor((width - 6 - line.length) / 2);
+      write(ansi.dim + ' '.repeat(Math.max(0, lPadding)) + line + ' '.repeat(Math.max(0, width - 6 - lPadding - line.length)) + ansi.reset);
+    } else {
+      // Regular content
+      write(padRight(line, width - 6));
+    }
+    contentRow++;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Exports
 // ---------------------------------------------------------------------------
@@ -1330,4 +1435,5 @@ module.exports = {
   renderActionModal,
   renderStashConfirm,
   renderCleanupConfirm,
+  renderUpdateModal,
 };

package/src/utils/version-check.js

@@ -54,4 +54,25 @@ function checkForUpdate() {
   });
 }
 
-module.exports = { checkForUpdate, compareVersions };
+/** Default interval between periodic update checks (4 hours in ms) */
+const UPDATE_CHECK_INTERVAL = 4 * 60 * 60 * 1000;
+
+/**
+ * Create a periodic update checker that re-checks npm at a fixed interval.
+ * @param {(latestVersion: string) => void} onUpdateFound - Called when a new version is detected
+ * @param {number} [interval] - Check interval in ms (default: 4 hours)
+ * @returns {{ stop: () => void }} Controller with stop() to clear the timer
+ */
+function startPeriodicUpdateCheck(onUpdateFound, interval = UPDATE_CHECK_INTERVAL) {
+  const timerId = setInterval(() => {
+    checkForUpdate()
+      .then((latestVersion) => {
+        if (latestVersion) onUpdateFound(latestVersion);
+      })
+      .catch(() => {});
+  }, interval);
+
+  return { stop: () => clearInterval(timerId) };
+}
+
+module.exports = { checkForUpdate, compareVersions, startPeriodicUpdateCheck, UPDATE_CHECK_INTERVAL };