jettypod 4.4.65 → 4.4.66

package/jettypod.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const config = require('./lib/config');
+const wsServer = require('./lib/ws-server');
 // getModeBehaviorContent removed - skills now provide all mode guidance
 
 // CRITICAL: Calculate and cache the REAL git root BEFORE any worktree operations
@@ -2125,6 +2126,16 @@ switch (command) {
           }
         }
 
+        // Start WebSocket server for real-time updates
+        const WS_PORT = 8080;
+        const { getDbPath } = require('./lib/database');
+        try {
+          await wsServer.start(WS_PORT, { dbPath: getDbPath() });
+        } catch (err) {
+          // WebSocket server failed to start (port in use?) - continue without it
+          console.log('⚠️  WebSocket server unavailable (real-time updates disabled)');
+        }
+
         // Start dashboard in background with project path
         console.log('🚀 Starting dashboard...');
         const dashboardProcess = spawn('npm', ['run', 'start', '--', '-p', String(availablePort)], {
@@ -2133,7 +2144,8 @@ switch (command) {
           stdio: 'ignore',
           env: {
             ...process.env,
-            JETTYPOD_PROJECT_PATH: process.cwd()
+            JETTYPOD_PROJECT_PATH: process.cwd(),
+            JETTYPOD_WS_PORT: String(WS_PORT)
           }
         });
         dashboardProcess.unref();

package/lib/db-watcher.js

@@ -0,0 +1,116 @@
+/**
+ * Database change watcher for triggering WebSocket broadcasts.
+ *
+ * Watches the .jettypod/work.db file and its WAL file for modifications
+ * and calls a callback when changes are detected.
+ *
+ * Usage:
+ *   const dbWatcher = require('./lib/db-watcher');
+ *   dbWatcher.start((changeType) => {
+ *     wsServer.broadcast({ type: 'db_change' });
+ *   });
+ *   dbWatcher.stop();
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let lastMtimes = { db: null, wal: null };
+let pollInterval = null;
+let onChange = null;
+let watchedPath = null;
+
+// Polling interval in milliseconds
+const POLL_MS = 50;
+
+/**
+ * Start watching the database file for changes
+ * @param {Function} callback - Called when database changes detected
+ * @param {string} dbPath - Path to database file (default: .jettypod/work.db)
+ */
+function start(callback, dbPath = null) {
+  if (pollInterval) {
+    return; // Already watching
+  }
+
+  onChange = callback;
+  watchedPath = dbPath || path.join(process.cwd(), '.jettypod', 'work.db');
+
+  // Check if file exists
+  if (!fs.existsSync(watchedPath)) {
+    return;
+  }
+
+  // Get initial mtimes for both db and WAL file
+  try {
+    const dbStats = fs.statSync(watchedPath);
+    lastMtimes.db = dbStats.mtimeMs;
+
+    // Also check WAL file (SQLite in WAL mode writes here first)
+    const walPath = watchedPath + '-wal';
+    if (fs.existsSync(walPath)) {
+      const walStats = fs.statSync(walPath);
+      lastMtimes.wal = walStats.mtimeMs;
+    }
+  } catch {
+    return;
+  }
+
+  // Use polling - most reliable for SQLite files across platforms
+  pollInterval = setInterval(() => {
+    try {
+      let changed = false;
+
+      // Check main db file
+      const dbStats = fs.statSync(watchedPath);
+      if (dbStats.mtimeMs !== lastMtimes.db) {
+        lastMtimes.db = dbStats.mtimeMs;
+        changed = true;
+      }
+
+      // Check WAL file (where SQLite writes first in WAL mode)
+      const walPath = watchedPath + '-wal';
+      if (fs.existsSync(walPath)) {
+        const walStats = fs.statSync(walPath);
+        if (walStats.mtimeMs !== lastMtimes.wal) {
+          lastMtimes.wal = walStats.mtimeMs;
+          changed = true;
+        }
+      }
+
+      if (changed && onChange) {
+        onChange('change');
+      }
+    } catch {
+      // File might be temporarily locked during writes
+    }
+  }, POLL_MS);
+}
+
+/**
+ * Stop watching the database file
+ */
+function stop() {
+  if (pollInterval) {
+    clearInterval(pollInterval);
+    pollInterval = null;
+  }
+
+  onChange = null;
+  lastMtimes = { db: null, wal: null };
+  watchedPath = null;
+}
+
+/**
+ * Check if currently watching
+ * @returns {boolean}
+ */
+function isWatching() {
+  return pollInterval !== null;
+}
+
+module.exports = {
+  start,
+  stop,
+  isWatching,
+};

package/lib/work-commands/index.js

@@ -1592,6 +1592,11 @@ async function mergeWork(options = {}) {
 
     // Clean up worktree if it exists
     if (worktree && worktree.worktree_path && fs.existsSync(worktree.worktree_path)) {
+      // Check if shell CWD is inside the worktree being deleted
+      const shellCwd = process.cwd();
+      const worktreePath = path.resolve(worktree.worktree_path);
+      const cwdWillBeInvalid = shellCwd.startsWith(worktreePath);
+
       console.log('Cleaning up worktree...');
       try {
         // Remove the git worktree
@@ -1613,6 +1618,13 @@ async function mergeWork(options = {}) {
         });
 
         console.log('✅ Worktree cleaned up');
+
+        // Warn if shell CWD was inside deleted worktree
+        if (cwdWillBeInvalid) {
+          console.log('');
+          console.log('⚠️  Your shell was inside the deleted worktree.');
+          console.log(`   Run this to fix: cd ${gitRoot}`);
+        }
       } catch (worktreeErr) {
         console.warn(`Warning: Failed to clean up worktree: ${worktreeErr.message}`);
         // Non-fatal - continue with merge success
@@ -1886,6 +1898,11 @@ async function testsMerge(featureId) {
   }
 
   // Clean up the worktree
+  // Check if shell CWD is inside the worktree being deleted
+  const shellCwd = process.cwd();
+  const resolvedWorktreePath = path.resolve(worktreePath);
+  const cwdWillBeInvalid = shellCwd.startsWith(resolvedWorktreePath);
+
   try {
     execSync(`git worktree remove "${worktreePath}" --force`, {
       cwd: gitRoot,
@@ -1893,6 +1910,13 @@ async function testsMerge(featureId) {
       stdio: 'pipe'
     });
     console.log('✅ Removed worktree directory');
+
+    // Warn if shell CWD was inside deleted worktree
+    if (cwdWillBeInvalid) {
+      console.log('');
+      console.log('⚠️  Your shell was inside the deleted worktree.');
+      console.log(`   Run this to fix: cd ${gitRoot}`);
+    }
   } catch (err) {
     console.log('⚠️  Failed to remove worktree (non-fatal):', err.message);
   }

package/lib/ws-server.js

@@ -0,0 +1,126 @@
+/**
+ * WebSocket server for broadcasting database changes to connected dashboard clients.
+ *
+ * Usage:
+ *   const wsServer = require('./lib/ws-server');
+ *   await wsServer.start();  // Start on port 8080 and watch for db changes
+ *   wsServer.broadcast({ type: 'db_change' });  // Manual broadcast to all clients
+ *   await wsServer.stop();  // Graceful shutdown
+ */
+
+const { WebSocketServer } = require('ws');
+const dbWatcher = require('./db-watcher');
+
+const DEFAULT_PORT = 8080;
+
+let wss = null;
+const clients = new Set();
+
+/**
+ * Start the WebSocket server
+ * @param {number} port - Port to listen on (default: 8080)
+ * @param {object} options - Options { dbPath: string }
+ * @returns {Promise<void>}
+ */
+async function start(port = DEFAULT_PORT, options = {}) {
+  if (wss) {
+    return; // Already running
+  }
+
+  return new Promise((resolve, reject) => {
+    wss = new WebSocketServer({ port });
+
+    wss.on('listening', () => {
+      // Start watching database for changes
+      dbWatcher.start(() => {
+        broadcast({ type: 'db_change', timestamp: Date.now() });
+      }, options.dbPath);
+      resolve();
+    });
+
+    wss.on('error', (error) => {
+      wss = null;
+      reject(error);
+    });
+
+    wss.on('connection', (ws) => {
+      clients.add(ws);
+
+      // Send connected confirmation
+      ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+
+      ws.on('close', () => {
+        clients.delete(ws);
+      });
+
+      ws.on('error', () => {
+        clients.delete(ws);
+      });
+    });
+  });
+}
+
+/**
+ * Stop the WebSocket server
+ * @returns {Promise<void>}
+ */
+async function stop() {
+  // Stop database watcher
+  dbWatcher.stop();
+
+  if (!wss) {
+    return;
+  }
+
+  return new Promise((resolve) => {
+    // Close all client connections
+    for (const client of clients) {
+      client.close();
+    }
+    clients.clear();
+
+    // Close the server
+    wss.close(() => {
+      wss = null;
+      resolve();
+    });
+  });
+}
+
+/**
+ * Broadcast a message to all connected clients
+ * @param {object} message - Message to broadcast (will be JSON stringified)
+ */
+function broadcast(message) {
+  const data = JSON.stringify(message);
+  for (const client of clients) {
+    if (client.readyState === 1) { // WebSocket.OPEN
+      client.send(data);
+    }
+  }
+}
+
+/**
+ * Get the number of connected clients
+ * @returns {number}
+ */
+function getClientCount() {
+  return clients.size;
+}
+
+/**
+ * Check if the server is running
+ * @returns {boolean}
+ */
+function isRunning() {
+  return wss !== null;
+}
+
+module.exports = {
+  start,
+  stop,
+  broadcast,
+  getClientCount,
+  isRunning,
+  DEFAULT_PORT,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.65",
+  "version": "4.4.66",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {