jettypod 4.4.55 → 4.4.57

package/claude-hooks/global-guardrails.js

@@ -11,14 +11,40 @@
 const fs = require('fs');
 const path = require('path');
 
+// Debug mode: set GUARDRAILS_DEBUG=1 to enable verbose logging
+const DEBUG = process.env.GUARDRAILS_DEBUG === '1';
+
+/**
+ * Structured debug logger - outputs to stderr to not interfere with JSON response
+ */
+function debug(category, data) {
+  if (!DEBUG) return;
+  const timestamp = new Date().toISOString();
+  const logEntry = { timestamp, category, ...data };
+  console.error(`[guardrails] ${JSON.stringify(logEntry)}`);
+}
+
 // Read hook input from stdin
 let input = '';
 process.stdin.on('data', chunk => input += chunk);
 process.stdin.on('end', () => {
   try {
     const hookInput = JSON.parse(input);
+    debug('input', {
+      tool: hookInput.tool_name,
+      cwd: hookInput.cwd,
+      active_worktree: hookInput.active_worktree_path,
+      branch: hookInput.current_branch
+    });
+
     const result = evaluateRequest(hookInput);
 
+    debug('decision', {
+      tool: hookInput.tool_name,
+      allowed: result.allowed,
+      message: result.message || null
+    });
+
     if (result.allowed) {
       allow();
     } else {
@@ -26,6 +52,7 @@ process.stdin.on('end', () => {
     }
   } catch (err) {
     // On parse error, allow (fail open)
+    debug('error', { type: 'parse', message: err.message });
     console.error('Hook error:', err.message);
     allow();
   }
@@ -159,6 +186,7 @@ function findDatabasePath(cwd) {
 function getActiveWorktreePathFromDB(cwd) {
   const dbPath = findDatabasePath(cwd);
   if (!dbPath) {
+    debug('db_lookup', { status: 'no_db_found', cwd });
     return null;
   }
 
@@ -170,8 +198,11 @@ function getActiveWorktreePathFromDB(cwd) {
       `SELECT worktree_path FROM worktrees WHERE status = 'active' LIMIT 1`
     ).get();
     db.close();
-    return row ? row.worktree_path : null;
+    const result = row ? row.worktree_path : null;
+    debug('db_lookup', { status: 'success', method: 'better-sqlite3', worktree: result });
+    return result;
   } catch (err) {
+    debug('db_lookup', { status: 'fallback', reason: err.message });
     // Fall back to CLI
     const { spawnSync } = require('child_process');
     const result = spawnSync('sqlite3', [
@@ -180,9 +211,12 @@ function getActiveWorktreePathFromDB(cwd) {
     ], { encoding: 'utf-8' });
 
     if (result.error || result.status !== 0) {
+      debug('db_lookup', { status: 'cli_failed', error: result.error?.message || 'non-zero exit' });
       return null;
     }
-    return result.stdout.trim() || null;
+    const worktree = result.stdout.trim() || null;
+    debug('db_lookup', { status: 'success', method: 'sqlite3-cli', worktree });
+    return worktree;
   }
 }
 
@@ -197,6 +231,13 @@ function evaluateWriteOperation(filePath, inputWorktreePath, cwd) {
   const normalizedPath = path.resolve(cwd || '.', filePath);
   const normalizedWorktree = activeWorktreePath ? path.resolve(cwd || '.', activeWorktreePath) : null;
 
+  debug('write_eval', {
+    filePath,
+    normalizedPath,
+    activeWorktreePath,
+    normalizedWorktree
+  });
+
   // BLOCKED: Protected files (skills, hooks)
   const protectedPatterns = [
     /\.claude\/skills\//i,

package/lib/merge-lock.js

@@ -43,6 +43,8 @@ async function acquireMergeLock(db, workItemId, instanceId = null, options = {})
   const lockedBy = instanceId || `${os.hostname()}-${process.pid}`;
 
   let pollCount = 0;
+  let lastStatusTime = 0;
+  const statusInterval = 10000; // Show status every 10 seconds
 
   while (Date.now() - startTime < maxWait) {
     // Cleanup stale locks every 5 polls (every ~10 seconds with 2s poll interval)
@@ -74,6 +76,21 @@ async function acquireMergeLock(db, workItemId, instanceId = null, options = {})
         // Race condition - someone else got it first
         // Continue polling
       }
+    } else {
+      // Show progress when waiting for existing lock
+      const now = Date.now();
+      if (now - lastStatusTime >= statusInterval) {
+        const waitedSeconds = Math.round((now - startTime) / 1000);
+        const lockAge = await getLockAge(db, existingLock.id);
+        const staleIn = Math.max(0, Math.round((staleThreshold - lockAge) / 1000));
+
+        if (staleIn > 0) {
+          console.log(`⏳ Waiting for merge lock... (${waitedSeconds}s elapsed, lock expires in ~${staleIn}s)`);
+        } else {
+          console.log(`⏳ Waiting for merge lock... (${waitedSeconds}s elapsed, cleaning up stale lock)`);
+        }
+        lastStatusTime = now;
+      }
     }
 
     // Wait before retrying
@@ -98,6 +115,27 @@ function checkExistingLock(db) {
   });
 }
 
+/**
+ * Get the age of a lock in milliseconds
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {number} lockId - Lock ID
+ * @returns {Promise<number>} Age in milliseconds
+ */
+function getLockAge(db, lockId) {
+  return new Promise((resolve, reject) => {
+    db.get(
+      `SELECT (julianday('now') - julianday(locked_at)) * 86400000 as age_ms
+       FROM merge_locks WHERE id = ?`,
+      [lockId],
+      (err, row) => {
+        if (err) reject(err);
+        else resolve(row ? row.age_ms : 0);
+      }
+    );
+  });
+}
+
 /**
  * Insert lock record into database
  *

package/lib/work-commands/index.js

@@ -1,7 +1,7 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const { getDb, getDbPath, getJettypodDir } = require('../../lib/database');
+const { getDb, getDbPath, getJettypodDir, waitForMigrations } = require('../../lib/database');
 const { getCurrentWork, setCurrentWork, clearCurrentWork, getCurrentWorkPath } = require('../../lib/current-work');
 const { VALID_STATUSES } = require('../../lib/constants');
 const { updateCurrentWork } = require('../../lib/claudemd');
@@ -1230,6 +1230,9 @@ async function mergeWork(options = {}) {
   const mergeLock = require('../../lib/merge-lock');
   const db = getDb();
 
+  // Wait for database migrations to complete before using merge_locks table
+  await waitForMigrations();
+
   console.log('⏳ Acquiring merge lock...');
   let lock;
   try {
@@ -1249,6 +1252,24 @@ async function mergeWork(options = {}) {
     return Promise.reject(new Error(`Failed to acquire merge lock: ${lockErr.message}`));
   }
 
+  // Set up signal handlers to release lock on interrupt (Ctrl+C, kill, etc.)
+  // Without this, process termination leaves orphan locks that block for 90 seconds
+  const cleanupAndExit = async (signal) => {
+    console.log(`\n⚠️  Received ${signal}, releasing merge lock...`);
+    if (lock) {
+      try {
+        await lock.release();
+        console.log('✅ Merge lock released');
+      } catch (err) {
+        console.warn(`Warning: Failed to release lock: ${err.message}`);
+      }
+    }
+    process.exit(1);
+  };
+
+  process.on('SIGINT', cleanupAndExit);
+  process.on('SIGTERM', cleanupAndExit);
+
   // Wrap all merge operations in try/finally to ensure lock release
   try {
     // Get feature branch - either passed explicitly, from worktree DB, or from current CWD
@@ -1617,6 +1638,10 @@ async function mergeWork(options = {}) {
 
     return Promise.resolve();
   } finally {
+    // Remove signal handlers to avoid interfering with other operations
+    process.removeListener('SIGINT', cleanupAndExit);
+    process.removeListener('SIGTERM', cleanupAndExit);
+
     // Release lock unless holding for transition
     if (lock && !withTransition) {
       try {

package/package.json

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