git-watchtower 2.3.0 → 2.3.2

package/bin/git-watchtower.js

@@ -3340,6 +3340,84 @@ async function handleWebAction(action, payload) {
           });
         }
         break;
+      case 'stash': {
+        // If a switch/pull is queued behind a dirty working tree, run the
+        // existing stash-and-retry flow so the original operation completes
+        // after the stash. Otherwise just stash standalone.
+        if (pendingDirtyOperation) {
+          const op = pendingDirtyOperation;
+          await stashAndRetry();
+          const label = op.type === 'switch' ? `stashed and switched to ${op.branch}` : 'stashed and pulled';
+          sendResult(true, label);
+        } else {
+          const stashResult = await gitStash({ message: 'git-watchtower: stashed from web dashboard' });
+          if (stashResult.success) {
+            addLog('Changes stashed (from web)', 'success');
+            telemetry.capture('stash_performed');
+            await pollGitChanges();
+            sendResult(true, 'Changes stashed');
+          } else {
+            const msg = stashResult.error ? stashResult.error.message : 'Could not stash';
+            addLog(`Stash failed (from web): ${msg}`, 'error');
+            sendResult(false, msg);
+          }
+          render();
+        }
+        break;
+      }
+      case 'stashPop': {
+        const popResult = await gitStashPop();
+        if (popResult.success) {
+          addLog('Stash popped (from web)', 'success');
+          await pollGitChanges();
+          sendResult(true, 'Stash popped');
+        } else {
+          const msg = popResult.error ? popResult.error.message : 'Could not pop stash';
+          addLog(`Stash pop failed (from web): ${msg}`, 'error');
+          sendResult(false, msg);
+        }
+        render();
+        break;
+      }
+      case 'deleteBranches': {
+        const branches = Array.isArray(payload.branches) ? payload.branches : [];
+        const force = payload.force === true;
+        if (branches.length === 0) {
+          sendResult(false, 'No branches specified');
+          break;
+        }
+        addLog(
+          `Cleaning up ${branches.length} branch${branches.length === 1 ? '' : 'es'}${force ? ' (force)' : ''} (from web)...`,
+          'update'
+        );
+        render();
+        const cleanupResult = await deleteGoneBranches(branches, { force });
+        for (const name of cleanupResult.deleted) {
+          addLog(`Deleted branch: ${name}`, 'success');
+        }
+        for (const f of cleanupResult.failed) {
+          addLog(`Failed to delete ${f.name}: ${f.error}`, 'error');
+        }
+        if (cleanupResult.deleted.length > 0) {
+          telemetry.capture('cleanup_branches_deleted', { count: cleanupResult.deleted.length });
+          await pollGitChanges();
+        }
+        if (cleanupResult.failed.length === 0 && cleanupResult.deleted.length > 0) {
+          sendResult(true, `Deleted ${cleanupResult.deleted.length} branch${cleanupResult.deleted.length === 1 ? '' : 'es'}`);
+        } else if (cleanupResult.deleted.length > 0) {
+          sendResult(
+            false,
+            `Deleted ${cleanupResult.deleted.length}, failed ${cleanupResult.failed.length}`
+          );
+        } else {
+          sendResult(
+            false,
+            `Failed to delete ${cleanupResult.failed.length} branch${cleanupResult.failed.length === 1 ? '' : 'es'}`
+          );
+        }
+        render();
+        break;
+      }
     }
   } catch (err) {
     addLog(`Web action error: ${err.message}`, 'error');
@@ -3407,6 +3485,13 @@ async function startWebDashboard(openBrowser) {
       sessionStats: sessionStats.getStats(),
     }),
     onAction: handleWebAction,
+    // Route actions for non-local project tabs through the coordinator so
+    // the targeted worker handles them in its own process. Without this,
+    // every action runs against the coordinator's repo regardless of which
+    // tab the user clicked.
+    sendCommand: (pId, action, payload) => {
+      if (coordinator) coordinator.sendCommand(pId, action, payload);
+    },
   });
   webDashboard.setLocalProjectId(projectId);
 

package/package.json

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

package/src/server/web.js

@@ -36,11 +36,29 @@ const MAX_PORT_RETRIES = 20;
  */
 const SSE_KEEPALIVE_INTERVAL = 15000;
 
+/**
+ * Actions the web dashboard is allowed to POST to /api/action. Every entry
+ * here MUST be matched by a `case` in `handleWebAction` in bin/git-watchtower.js
+ * — `tests/unit/server/web.test.js` enforces that link so a future addition
+ * to the whitelist can't silently no-op the way `stash` / `stashPop` /
+ * `deleteBranches` did before they were implemented.
+ */
+const ALLOWED_ACTIONS = Object.freeze([
+  'switchBranch', 'pull', 'fetch', 'undo',
+  'toggleSound', 'preview',
+  'restartServer', 'reloadBrowsers', 'toggleCasino',
+  'openBrowser',
+  'stash', 'stashPop', 'deleteBranches', 'checkUpdate',
+]);
+
 /**
  * @typedef {Object} WebDashboardOptions
  * @property {number} [port=4000] - Port to listen on
  * @property {import('../state/store').Store} store - State store instance
- * @property {function} [onAction] - Callback for web UI actions
+ * @property {function} [onAction] - Callback for actions targeting the local project
+ * @property {function} [sendCommand] - Routes (projectId, action, payload) to a remote
+ *   project's worker. When omitted, every action is dispatched locally — preserves
+ *   single-project behaviour for callers (and tests) that don't run a coordinator.
  * @property {function} [getExtraState] - Returns additional state to merge
  */
 
@@ -56,6 +74,7 @@ class WebDashboardServer {
     this.port = options.port || DEFAULT_WEB_PORT;
     this.store = options.store;
     this.onAction = options.onAction || (() => {});
+    this.sendCommand = options.sendCommand || null;
     this.getExtraState = options.getExtraState || (() => ({}));
 
     /** @type {Set<import('http').ServerResponse>} */
@@ -511,27 +530,29 @@ class WebDashboardServer {
           return;
         }
 
-        // Whitelist allowed actions
-        const allowedActions = [
-          'switchBranch', 'pull', 'fetch', 'undo',
-          'toggleSound', 'preview',
-          'restartServer', 'reloadBrowsers', 'toggleCasino',
-          'openBrowser',
-          'stash', 'stashPop', 'deleteBranches', 'checkUpdate',
-        ];
-
-        if (!allowedActions.includes(action)) {
+        if (!ALLOWED_ACTIONS.includes(action)) {
           res.writeHead(400, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Unknown action: ' + action }));
           return;
         }
 
-        // Include projectId if provided (for multi-project routing)
+        // Multi-project routing: when the request targets a project that is
+        // not the coordinator's own (the user is on a different tab in the
+        // dashboard), forward to that project's worker via sendCommand
+        // instead of running the action against the coordinator's repo.
         const projectId = data.projectId || this.localProjectId;
         payload._projectId = projectId;
 
-        // Dispatch to the main process
-        this.onAction(action, payload);
+        if (
+          projectId &&
+          this.localProjectId &&
+          projectId !== this.localProjectId &&
+          typeof this.sendCommand === 'function'
+        ) {
+          this.sendCommand(projectId, action, payload);
+        } else {
+          this.onAction(action, payload);
+        }
 
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ ok: true }));
@@ -581,4 +602,5 @@ module.exports = {
   WebDashboardServer,
   DEFAULT_WEB_PORT,
   STATE_PUSH_INTERVAL,
+  ALLOWED_ACTIONS,
 };