git-watchtower 1.9.20 → 1.10.1

package/bin/git-watchtower.js

@@ -48,6 +48,7 @@
  *   s       - Toggle sound notifications
  *   c       - Toggle casino mode (Vegas-style feedback)
  *   i       - Show server info (port, connections)
+ *   W       - Toggle web dashboard (starts server + opens browser)
  *   1-0     - Set visible branch count (1-10)
  *   +/-     - Increase/decrease visible branches
  *   q/Esc   - Quit (Esc also clears search)
@@ -98,6 +99,10 @@ const { getConfigPath, loadConfig: loadConfigFile, saveConfig: saveConfigFile, C
 const { Store } = require('../src/state/store');
 const store = new Store();
 
+// Web dashboard server
+const { WebDashboardServer } = require('../src/server/web');
+const { Coordinator, Worker, generateProjectId, getActiveCoordinator, writeLock, removeLock } = require('../src/server/coordinator');
+
 const PROJECT_ROOT = process.cwd();
 
 function loadConfig() {
@@ -383,6 +388,15 @@ let sessionStartTime = null;
 // Server process management (for command mode)
 let serverProcess = null;
 
+// Web dashboard
+let WEB_ENABLED = false;
+let WEB_PORT = 4000;
+let webDashboard = null;
+let coordinator = null;
+let worker = null;
+let projectId = null;
+let webStateInterval = null;
+
 function applyConfig(config) {
   // Server settings
   SERVER_MODE = config.server?.mode || 'static';
@@ -415,6 +429,12 @@ function applyConfig(config) {
   if (casinoEnabled) {
     casino.enable();
   }
+
+  // Web dashboard
+  if (config.web) {
+    WEB_ENABLED = config.web.enabled === true;
+    WEB_PORT = config.web.port || 4000;
+  }
 }
 
 // Server log management
@@ -2775,6 +2795,20 @@ function setupKeyboardInput() {
         break;
       }
 
+      case 'W': { // Toggle web dashboard
+        if (webDashboard || worker) {
+          const wasPort = stopWebDashboard();
+          addLog(`Web dashboard stopped (was on :${wasPort})`, 'info');
+          showFlash('Web dashboard stopped');
+          render();
+        } else {
+          startWebDashboard(true).then(() => {
+            showFlash(`Web dashboard on :${WEB_PORT}`);
+          }).catch(() => {});
+        }
+        break;
+      }
+
       // Number keys to set visible branch count
       case '1': case '2': case '3': case '4': case '5':
       case '6': case '7': case '8': case '9':
@@ -2830,6 +2864,237 @@ function setupKeyboardInput() {
   });
 }
 
+// ============================================================================
+// Web Dashboard
+// ============================================================================
+
+/**
+ * Handle an action from the web dashboard.
+ */
+async function handleWebAction(action, payload) {
+  const sendResult = (success, message) => {
+    if (webDashboard) webDashboard.sendActionResult({ action, success, message });
+  };
+
+  try {
+    switch (action) {
+      case 'switchBranch':
+        if (payload.branch && payload.branch !== store.get('currentBranch')) {
+          await switchToBranch(payload.branch);
+          await pollGitChanges();
+          sendResult(true, `Switched to ${payload.branch}`);
+        }
+        break;
+      case 'pull':
+        addLog('Force pulling (from web)...', 'update');
+        render();
+        await pullCurrentBranch();
+        await pollGitChanges();
+        sendResult(true, 'Pull complete');
+        break;
+      case 'fetch':
+        addLog('Fetching all branches (from web)...', 'info');
+        render();
+        await pollGitChanges();
+        await refreshAllSparklines();
+        render();
+        sendResult(true, 'Fetch complete');
+        break;
+      case 'undo': {
+        const last = store.getLastSwitch();
+        if (last) {
+          await switchToBranch(last.from);
+          store.popHistory();
+          await pollGitChanges();
+          sendResult(true, `Switched back to ${last.from}`);
+        } else {
+          sendResult(false, 'No switch to undo');
+        }
+        break;
+      }
+      case 'toggleSound': {
+        const current = store.get('soundEnabled');
+        store.setState({ soundEnabled: !current });
+        render();
+        sendResult(true, current ? 'Sound off' : 'Sound on');
+        break;
+      }
+      case 'toggleCasino': {
+        const casinoOn = store.get('casinoModeEnabled');
+        store.setState({ casinoModeEnabled: !casinoOn });
+        if (!casinoOn) casino.enable(); else casino.disable();
+        render();
+        sendResult(true, casinoOn ? 'Casino mode off' : 'Casino mode on');
+        break;
+      }
+      case 'restartServer':
+        if (SERVER_MODE === 'command') {
+          addLog('Restarting server (from web)...', 'update');
+          restartServerProcess();
+          render();
+          sendResult(true, 'Server restarting');
+        } else {
+          sendResult(false, 'Not in command mode');
+        }
+        break;
+      case 'reloadBrowsers':
+        if (SERVER_MODE === 'static') {
+          addLog('Force reloading browsers (from web)...', 'update');
+          notifyClients();
+          render();
+          sendResult(true, 'Browsers reloaded');
+        } else {
+          sendResult(false, 'Not in static mode');
+        }
+        break;
+      case 'openBrowser':
+        if (!NO_SERVER) {
+          openInBrowser(`http://localhost:${PORT}`);
+          sendResult(true, 'Opened in browser');
+        }
+        break;
+      case 'preview':
+        if (payload.branch) {
+          const pvData = await getPreviewData(payload.branch);
+          if (webDashboard) {
+            webDashboard.sendPreview({ branch: payload.branch, ...pvData });
+          }
+        }
+        break;
+    }
+  } catch (err) {
+    addLog(`Web action error: ${err.message}`, 'error');
+    sendResult(false, err.message);
+    render();
+  }
+}
+
+/**
+ * Create and start the web dashboard, with coordinator support.
+ * @param {boolean} openBrowser - Whether to auto-open the browser
+ */
+async function startWebDashboard(openBrowser) {
+  projectId = generateProjectId(PROJECT_ROOT);
+
+  webDashboard = new WebDashboardServer({
+    port: WEB_PORT,
+    store,
+    getExtraState: () => ({
+      clientCount: clients.size,
+      sessionStats: sessionStats.getStats(),
+    }),
+    onAction: handleWebAction,
+  });
+  webDashboard.setLocalProjectId(projectId);
+
+  // Resolve and cache the repo web URL for link building in the web UI
+  getRemoteWebUrl(null).then((url) => {
+    if (url) webDashboard.setRepoWebUrl(url);
+  }).catch(() => {});
+
+  // Check if a coordinator is already running
+  const existing = getActiveCoordinator();
+
+  if (existing) {
+    // Connect as a worker to the existing coordinator
+    try {
+      worker = new Worker({
+        id: projectId,
+        projectPath: PROJECT_ROOT,
+        projectName: path.basename(PROJECT_ROOT),
+        socketPath: existing.socketPath,
+      });
+      worker.onCommand = (action, payload) => handleWebAction(action, payload);
+      await worker.connect();
+      addLog(`Joined web dashboard at http://localhost:${existing.port} (tab)`, 'success');
+
+      // Push state periodically
+      webStateInterval = setInterval(() => {
+        if (worker && worker.isConnected()) {
+          worker.pushState(webDashboard.getSerializableState());
+        } else {
+          clearInterval(webStateInterval);
+          webStateInterval = null;
+        }
+      }, 500);
+
+      // Don't start our own server — piggyback on the coordinator's.
+      // Don't open browser either — the existing tab will show this project automatically.
+      WEB_PORT = existing.port;
+      render();
+      return;
+    } catch (err) {
+      // Couldn't connect — become coordinator instead
+      worker = null;
+    }
+  }
+
+  // We are the coordinator
+  try {
+    coordinator = new Coordinator();
+    coordinator.onProjectsChanged = (projects) => {
+      if (webDashboard) webDashboard.setProjects(projects);
+    };
+    coordinator.onActionRequest = (pId, action, payload) => {
+      if (pId === projectId) {
+        handleWebAction(action, payload);
+      }
+    };
+    await coordinator.start();
+    coordinator.registerLocal(projectId, PROJECT_ROOT, path.basename(PROJECT_ROOT), webDashboard.getSerializableState());
+
+    // Update coordinator with our latest state periodically
+    webStateInterval = setInterval(() => {
+      if (coordinator && webDashboard) {
+        coordinator.updateLocal(projectId, webDashboard.getSerializableState());
+      } else {
+        clearInterval(webStateInterval);
+        webStateInterval = null;
+      }
+    }, 500);
+
+    const { port } = await webDashboard.start();
+    WEB_PORT = port;
+    writeLock(process.pid, port, coordinator.socketPath);
+
+    addLog(`Web dashboard: http://localhost:${port}`, 'success');
+    if (openBrowser) openInBrowser(`http://localhost:${port}`);
+    render();
+  } catch (err) {
+    addLog(`Web dashboard failed: ${err.message}`, 'error');
+    webDashboard = null;
+    coordinator = null;
+    render();
+  }
+}
+
+/**
+ * Stop the web dashboard and coordinator/worker.
+ */
+function stopWebDashboard() {
+  const wasPort = webDashboard ? webDashboard.port : WEB_PORT;
+
+  if (webStateInterval) {
+    clearInterval(webStateInterval);
+    webStateInterval = null;
+  }
+  if (worker) {
+    worker.disconnect();
+    worker = null;
+  }
+  if (coordinator) {
+    coordinator.stop();
+    coordinator = null;
+  }
+  if (webDashboard) {
+    webDashboard.stop();
+    webDashboard = null;
+  }
+  projectId = null;
+
+  return wasPort;
+}
+
 // ============================================================================
 // Shutdown
 // ============================================================================
@@ -2864,6 +3129,9 @@ async function shutdown() {
     await Promise.race([serverClosePromise, timeoutPromise]);
   }
 
+  // Stop web dashboard and coordinator
+  stopWebDashboard();
+
   // Flush telemetry
   telemetry.capture('session_ended', {
     duration_seconds: sessionStartTime ? Math.round((Date.now() - sessionStartTime) / 1000) : 0,
@@ -3032,6 +3300,11 @@ async function start() {
     setupFileWatcher();
   }
 
+  // Start web dashboard if enabled
+  if (WEB_ENABLED) {
+    await startWebDashboard(true);
+  }
+
   // Setup keyboard input
   setupKeyboardInput();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-watchtower",
-  "version": "1.9.20",
+  "version": "1.10.1",
   "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

@@ -20,6 +20,8 @@ const { version: PACKAGE_VERSION } = require('../../package.json');
  * @property {number|null} visibleBranches - Visible branches override
  * @property {boolean} init - Run configuration wizard
  * @property {boolean} casino - Enable casino mode
+ * @property {boolean} web - Enable web dashboard mode
+ * @property {number|null} webPort - Web dashboard port override
  */
 
 /**
@@ -47,6 +49,9 @@ function parseArgs(argv, options = {}) {
     // UI settings
     sound: null,
     visibleBranches: null,
+    // Web dashboard
+    web: false,
+    webPort: null,
     // Actions
     init: false,
     casino: false,
@@ -108,6 +113,16 @@ function parseArgs(argv, options = {}) {
     } else if (args[i] === '--casino') {
       result.casino = true;
     }
+    // Web dashboard
+    else if (args[i] === '--web' || args[i] === '-w') {
+      result.web = true;
+    } else if (args[i] === '--web-port') {
+      const webPortValue = parseInt(args[i + 1], 10);
+      if (!isNaN(webPortValue) && webPortValue > 0 && webPortValue < 65536) {
+        result.webPort = webPortValue;
+      }
+      i++;
+    }
     // Actions and info
     else if (args[i] === '--init') {
       result.init = true;
@@ -175,6 +190,14 @@ function applyCliArgsToConfig(config, cliArgs) {
     merged.casinoMode = true;
   }
 
+  // Web dashboard
+  if (cliArgs.web) {
+    merged.web = { ...merged.web, enabled: true };
+  }
+  if (cliArgs.webPort !== null) {
+    merged.web = { ...merged.web, port: cliArgs.webPort };
+  }
+
   return merged;
 }
 
@@ -211,6 +234,10 @@ UI Options:
   --visible-branches <n>  Number of branches to display (default: 7)
   --casino                Enable casino mode
 
+Web Dashboard:
+  -w, --web               Launch web dashboard alongside TUI
+  --web-port <port>       Web dashboard port (default: 4000)
+
 General:
   --init                  Run the configuration wizard
   -v, --version           Show version number
@@ -232,6 +259,8 @@ Examples:
   git-watchtower --no-server                  # Branch monitoring only
   git-watchtower -p 8080                      # Override port
   git-watchtower -m command -c "npm run dev"  # Use custom dev server
+  git-watchtower --web                             # TUI + web dashboard on :4000
+  git-watchtower --web --web-port 8080              # Web dashboard on custom port
   git-watchtower --no-sound --poll-interval 10000
 `;
 }

package/src/config/loader.js

@@ -147,6 +147,14 @@ function applyCliArgs(config, cliArgs) {
     result.server.restartOnSwitch = cliArgs.restartOnSwitch;
   }
 
+  // Web dashboard
+  if (cliArgs.web) {
+    result.web = { ...result.web, enabled: true };
+  }
+  if (cliArgs.webPort !== undefined && cliArgs.webPort !== null) {
+    result.web = { ...result.web, port: cliArgs.webPort };
+  }
+
   // Git settings
   if (cliArgs.remote !== undefined && cliArgs.remote !== null) {
     result.remoteName = cliArgs.remote;

package/src/config/schema.js

@@ -19,9 +19,16 @@ const { ConfigError, ValidationError } = require('../utils/errors');
  * @property {boolean} restartOnSwitch - Restart on branch switch
  */
 
+/**
+ * @typedef {Object} WebConfig
+ * @property {boolean} enabled - Web dashboard enabled
+ * @property {number} port - Web dashboard port
+ */
+
 /**
  * @typedef {Object} Config
  * @property {ServerConfig} server - Server configuration
+ * @property {WebConfig} web - Web dashboard configuration
  * @property {string} remoteName - Git remote name
  * @property {boolean} autoPull - Auto-pull enabled
  * @property {number} gitPollInterval - Polling interval in ms
@@ -47,6 +54,10 @@ const DEFAULTS = {
     port: 3000,
     restartOnSwitch: true,
   },
+  web: {
+    enabled: false,
+    port: 4000,
+  },
   remoteName: 'origin',
   autoPull: true,
   gitPollInterval: 5000,
@@ -71,6 +82,7 @@ const LIMITS = {
 function getDefaultConfig() {
   return {
     server: { ...DEFAULTS.server },
+    web: { ...DEFAULTS.web },
     remoteName: DEFAULTS.remoteName,
     autoPull: DEFAULTS.autoPull,
     gitPollInterval: DEFAULTS.gitPollInterval,
@@ -223,6 +235,19 @@ function validateConfig(config) {
     }
   }
 
+  // Validate web dashboard config
+  if (config.web) {
+    if (typeof config.web !== 'object') {
+      throw ConfigError.invalid('web must be an object');
+    }
+    if (config.web.enabled !== undefined) {
+      result.web.enabled = Boolean(config.web.enabled);
+    }
+    if (config.web.port !== undefined) {
+      result.web.port = validatePort(config.web.port);
+    }
+  }
+
   // Validate Git settings
   if (config.remoteName !== undefined) {
     if (typeof config.remoteName !== 'string' || !config.remoteName.trim()) {

package/src/index.js

@@ -33,6 +33,9 @@ const configLoader = require('./config/loader');
 
 // Server management
 const serverProcess = require('./server/process');
+const serverWeb = require('./server/web');
+const serverWebUi = require('./server/web-ui');
+const serverCoordinator = require('./server/coordinator');
 
 // Telemetry
 const telemetryModule = require('./telemetry');
@@ -156,6 +159,17 @@ module.exports = {
   ProcessManager: serverProcess.ProcessManager,
   parseCommand: serverProcess.parseCommand,
 
+  // Web dashboard server
+  WebDashboardServer: serverWeb.WebDashboardServer,
+  DEFAULT_WEB_PORT: serverWeb.DEFAULT_WEB_PORT,
+  getWebDashboardHtml: serverWebUi.getWebDashboardHtml,
+
+  // Multi-instance coordinator
+  Coordinator: serverCoordinator.Coordinator,
+  Worker: serverCoordinator.Worker,
+  generateProjectId: serverCoordinator.generateProjectId,
+  getActiveCoordinator: serverCoordinator.getActiveCoordinator,
+
   // CLI argument parsing
   parseArgs: cliArgs.parseArgs,
   applyCliArgsToConfig: cliArgs.applyCliArgsToConfig,