commandmate 0.1.10 → 0.1.11

package/dist/server/src/lib/auto-yes-manager.js

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * Auto Yes Manager - Server-side in-memory state management
+ *
+ * Manages auto-yes mode per worktree using an in-memory Map.
+ * State is automatically cleared on server restart.
+ *
+ * Issue #138: Added server-side polling functionality to handle
+ * auto-yes responses when browser tabs are in background.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.POLLING_INTERVAL_MS = void 0;
+exports.isValidWorktreeId = isValidWorktreeId;
+exports.calculateBackoffInterval = calculateBackoffInterval;
+exports.isAutoYesExpired = isAutoYesExpired;
+exports.getAutoYesState = getAutoYesState;
+exports.setAutoYesEnabled = setAutoYesEnabled;
+exports.clearAllAutoYesStates = clearAllAutoYesStates;
+exports.getActivePollerCount = getActivePollerCount;
+exports.clearAllPollerStates = clearAllPollerStates;
+exports.getLastServerResponseTimestamp = getLastServerResponseTimestamp;
+exports.startAutoYesPolling = startAutoYesPolling;
+exports.stopAutoYesPolling = stopAutoYesPolling;
+exports.stopAllAutoYesPolling = stopAllAutoYesPolling;
+const cli_session_1 = require("./cli-session");
+const prompt_detector_1 = require("./prompt-detector");
+const auto_yes_resolver_1 = require("./auto-yes-resolver");
+const tmux_1 = require("./tmux");
+const manager_1 = require("./cli-tools/manager");
+const cli_patterns_1 = require("./cli-patterns");
+// =============================================================================
+// Constants (Issue #138)
+// =============================================================================
+/** Polling interval in milliseconds */
+exports.POLLING_INTERVAL_MS = 2000;
+/** Maximum backoff interval in milliseconds (60 seconds) */
+exports.MAX_BACKOFF_MS = 60000;
+/** Number of consecutive errors before applying backoff */
+exports.MAX_CONSECUTIVE_ERRORS = 5;
+/** Maximum concurrent pollers (DoS protection) */
+exports.MAX_CONCURRENT_POLLERS = 50;
+/** Timeout duration: 1 hour in milliseconds */
+const AUTO_YES_TIMEOUT_MS = 3600000;
+/** Worktree ID validation pattern (security: prevent command injection) */
+const WORKTREE_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+// =============================================================================
+// In-memory State
+// =============================================================================
+/** In-memory storage for auto-yes states */
+const autoYesStates = new Map();
+/** In-memory storage for poller states (Issue #138) */
+const autoYesPollerStates = new Map();
+// =============================================================================
+// Utility Functions
+// =============================================================================
+/**
+ * Validate worktree ID format (security measure)
+ * Only allows alphanumeric characters, hyphens, and underscores.
+ */
+function isValidWorktreeId(worktreeId) {
+    if (!worktreeId || worktreeId.length === 0)
+        return false;
+    return WORKTREE_ID_PATTERN.test(worktreeId);
+}
+/**
+ * Calculate backoff interval based on consecutive errors
+ */
+function calculateBackoffInterval(consecutiveErrors) {
+    if (consecutiveErrors < exports.MAX_CONSECUTIVE_ERRORS) {
+        return exports.POLLING_INTERVAL_MS;
+    }
+    // Exponential backoff: 2^(errors - 4) * 2000
+    // 5 errors: 2^1 * 2000 = 4000
+    // 6 errors: 2^2 * 2000 = 8000
+    // etc.
+    const backoffMultiplier = Math.pow(2, consecutiveErrors - exports.MAX_CONSECUTIVE_ERRORS + 1);
+    const backoffMs = exports.POLLING_INTERVAL_MS * backoffMultiplier;
+    return Math.min(backoffMs, exports.MAX_BACKOFF_MS);
+}
+// =============================================================================
+// Auto-Yes State Management (Existing)
+// =============================================================================
+/**
+ * Check if an auto-yes state has expired
+ */
+function isAutoYesExpired(state) {
+    return Date.now() > state.expiresAt;
+}
+/**
+ * Get the auto-yes state for a worktree
+ * Returns null if no state exists or if expired (auto-disables on expiry)
+ */
+function getAutoYesState(worktreeId) {
+    const state = autoYesStates.get(worktreeId);
+    if (!state)
+        return null;
+    // Auto-disable if expired
+    if (isAutoYesExpired(state)) {
+        const disabledState = {
+            ...state,
+            enabled: false,
+        };
+        autoYesStates.set(worktreeId, disabledState);
+        return disabledState;
+    }
+    return state;
+}
+/**
+ * Set the auto-yes enabled state for a worktree
+ */
+function setAutoYesEnabled(worktreeId, enabled) {
+    if (enabled) {
+        const now = Date.now();
+        const state = {
+            enabled: true,
+            enabledAt: now,
+            expiresAt: now + AUTO_YES_TIMEOUT_MS,
+        };
+        autoYesStates.set(worktreeId, state);
+        return state;
+    }
+    else {
+        const existing = autoYesStates.get(worktreeId);
+        const state = {
+            enabled: false,
+            enabledAt: existing?.enabledAt ?? 0,
+            expiresAt: existing?.expiresAt ?? 0,
+        };
+        autoYesStates.set(worktreeId, state);
+        return state;
+    }
+}
+/**
+ * Clear all auto-yes states (for testing)
+ */
+function clearAllAutoYesStates() {
+    autoYesStates.clear();
+}
+// =============================================================================
+// Server-side Polling (Issue #138)
+// =============================================================================
+/**
+ * Get the number of active pollers
+ */
+function getActivePollerCount() {
+    return autoYesPollerStates.size;
+}
+/**
+ * Clear all poller states (for testing)
+ */
+function clearAllPollerStates() {
+    stopAllAutoYesPolling();
+    autoYesPollerStates.clear();
+}
+/**
+ * Get the last server response timestamp for a worktree
+ * Used by clients to prevent duplicate responses
+ */
+function getLastServerResponseTimestamp(worktreeId) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    return pollerState?.lastServerResponseTimestamp ?? null;
+}
+/**
+ * Update the last server response timestamp
+ */
+function updateLastServerResponseTimestamp(worktreeId, timestamp) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (pollerState) {
+        pollerState.lastServerResponseTimestamp = timestamp;
+    }
+}
+/**
+ * Reset error count for a poller
+ */
+function resetErrorCount(worktreeId) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (pollerState) {
+        pollerState.consecutiveErrors = 0;
+        pollerState.currentInterval = exports.POLLING_INTERVAL_MS;
+    }
+}
+/**
+ * Increment error count and apply backoff if needed
+ */
+function incrementErrorCount(worktreeId) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (pollerState) {
+        pollerState.consecutiveErrors++;
+        pollerState.currentInterval = calculateBackoffInterval(pollerState.consecutiveErrors);
+    }
+}
+/**
+ * Internal polling function (setTimeout recursive)
+ */
+async function pollAutoYes(worktreeId, cliToolId) {
+    // Check if poller was stopped
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (!pollerState)
+        return;
+    // Check if auto-yes is still enabled
+    const autoYesState = getAutoYesState(worktreeId);
+    if (!autoYesState?.enabled || isAutoYesExpired(autoYesState)) {
+        stopAutoYesPolling(worktreeId);
+        return;
+    }
+    try {
+        // 1. Capture tmux output
+        const output = await (0, cli_session_1.captureSessionOutput)(worktreeId, cliToolId, 5000);
+        // 2. Strip ANSI codes and detect prompt
+        const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
+        const promptDetection = (0, prompt_detector_1.detectPrompt)(cleanOutput);
+        if (!promptDetection.isPrompt || !promptDetection.promptData) {
+            // No prompt detected, schedule next poll
+            scheduleNextPoll(worktreeId, cliToolId);
+            return;
+        }
+        // 3. Resolve auto answer
+        const answer = (0, auto_yes_resolver_1.resolveAutoAnswer)(promptDetection.promptData);
+        if (answer === null) {
+            // Cannot auto-answer this prompt
+            scheduleNextPoll(worktreeId, cliToolId);
+            return;
+        }
+        // 4. Send answer to tmux
+        const manager = manager_1.CLIToolManager.getInstance();
+        const cliTool = manager.getTool(cliToolId);
+        const sessionName = cliTool.getSessionName(worktreeId);
+        // Send answer followed by Enter
+        await (0, tmux_1.sendKeys)(sessionName, answer, false);
+        await new Promise(resolve => setTimeout(resolve, 100));
+        await (0, tmux_1.sendKeys)(sessionName, '', true);
+        // 5. Update timestamp
+        updateLastServerResponseTimestamp(worktreeId, Date.now());
+        // 6. Reset error count on success
+        resetErrorCount(worktreeId);
+        // Log success (without sensitive content)
+        console.info(`[Auto-Yes Poller] Sent response for worktree: ${worktreeId}`);
+    }
+    catch (error) {
+        // Increment error count on failure
+        incrementErrorCount(worktreeId);
+        // Log error (without sensitive details)
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.warn(`[Auto-Yes Poller] Error for worktree ${worktreeId}: ${errorMessage}`);
+    }
+    // Schedule next poll
+    scheduleNextPoll(worktreeId, cliToolId);
+}
+/**
+ * Schedule the next polling iteration
+ */
+function scheduleNextPoll(worktreeId, cliToolId) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (!pollerState)
+        return;
+    pollerState.timerId = setTimeout(() => {
+        pollAutoYes(worktreeId, cliToolId);
+    }, pollerState.currentInterval);
+}
+/**
+ * Start server-side auto-yes polling for a worktree
+ */
+function startAutoYesPolling(worktreeId, cliToolId) {
+    // Validate worktree ID (security)
+    if (!isValidWorktreeId(worktreeId)) {
+        return { started: false, reason: 'invalid worktree ID' };
+    }
+    // Check if auto-yes is enabled
+    const autoYesState = getAutoYesState(worktreeId);
+    if (!autoYesState?.enabled) {
+        return { started: false, reason: 'auto-yes not enabled' };
+    }
+    // Check concurrent poller limit (DoS protection)
+    // If this worktree already has a poller, don't count it toward the limit
+    const existingPoller = autoYesPollerStates.has(worktreeId);
+    if (!existingPoller && autoYesPollerStates.size >= exports.MAX_CONCURRENT_POLLERS) {
+        return { started: false, reason: 'max concurrent pollers reached' };
+    }
+    // Stop existing poller if any
+    if (existingPoller) {
+        stopAutoYesPolling(worktreeId);
+    }
+    // Create new poller state
+    const pollerState = {
+        timerId: null,
+        cliToolId,
+        consecutiveErrors: 0,
+        currentInterval: exports.POLLING_INTERVAL_MS,
+        lastServerResponseTimestamp: null,
+    };
+    autoYesPollerStates.set(worktreeId, pollerState);
+    // Start polling immediately
+    pollerState.timerId = setTimeout(() => {
+        pollAutoYes(worktreeId, cliToolId);
+    }, exports.POLLING_INTERVAL_MS);
+    console.info(`[Auto-Yes Poller] Started for worktree: ${worktreeId}, cliTool: ${cliToolId}`);
+    return { started: true };
+}
+/**
+ * Stop server-side auto-yes polling for a worktree
+ */
+function stopAutoYesPolling(worktreeId) {
+    const pollerState = autoYesPollerStates.get(worktreeId);
+    if (!pollerState)
+        return;
+    // Clear timer
+    if (pollerState.timerId) {
+        clearTimeout(pollerState.timerId);
+    }
+    // Remove state
+    autoYesPollerStates.delete(worktreeId);
+    console.info(`[Auto-Yes Poller] Stopped for worktree: ${worktreeId}`);
+}
+/**
+ * Stop all server-side auto-yes polling (graceful shutdown)
+ */
+function stopAllAutoYesPolling() {
+    for (const [worktreeId, pollerState] of autoYesPollerStates.entries()) {
+        if (pollerState.timerId) {
+            clearTimeout(pollerState.timerId);
+        }
+        console.info(`[Auto-Yes Poller] Stopped for worktree: ${worktreeId} (shutdown)`);
+    }
+    autoYesPollerStates.clear();
+}

package/dist/server/src/lib/auto-yes-resolver.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Auto Yes Resolver - Determines automatic answer for prompt data
+ *
+ * Rules:
+ * - yes/no prompt -> 'y'
+ * - multiple_choice with default option -> default option number
+ * - multiple_choice without default -> first option number
+ * - option requiring text input -> null (skip)
+ * - unknown type -> null (skip)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAutoAnswer = resolveAutoAnswer;
+/**
+ * Resolve the automatic answer for a given prompt
+ * @returns The answer string to send, or null if auto-answer is not possible
+ */
+function resolveAutoAnswer(promptData) {
+    if (promptData.type === 'yes_no') {
+        return 'y';
+    }
+    if (promptData.type === 'multiple_choice') {
+        const defaultOpt = promptData.options.find(o => o.isDefault);
+        const target = defaultOpt ?? promptData.options[0];
+        if (!target) {
+            return null;
+        }
+        if (target.requiresTextInput) {
+            return null;
+        }
+        return target.number.toString();
+    }
+    return null;
+}

package/dist/server/src/lib/cli-patterns.js

@@ -33,8 +33,13 @@ exports.CODEX_THINKING_PATTERN = /•\s*(Planning|Searching|Exploring|Running|Th
 /**
  * Claude prompt pattern (waiting for input)
  * Supports both legacy '>' and new '❯' (U+276F) prompt characters
+ * Issue #132: Also matches prompts with recommended commands (e.g., "❯ /work-plan")
+ *
+ * Matches:
+ * - Empty prompt: "❯ " or "> "
+ * - Prompt with command: "❯ /work-plan" or "> npm install"
  */
-exports.CLAUDE_PROMPT_PATTERN = /^[>❯]\s*$/m;
+exports.CLAUDE_PROMPT_PATTERN = /^[>❯](\s*$|\s+\S)/m;
 /**
  * Claude separator pattern
  */

package/dist/server/src/lib/db-instance.js

@@ -2,6 +2,9 @@
 /**
  * Database instance singleton
  * Provides a shared database connection for API routes
+ *
+ * Issue #135: DB path resolution fix
+ * Uses getEnv().CM_DB_PATH for consistent path handling across all install types
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -12,10 +15,14 @@ exports.closeDbInstance = closeDbInstance;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const path_1 = __importDefault(require("path"));
 const db_migrations_1 = require("./db-migrations");
+const env_1 = require("./env");
 let dbInstance = null;
 /**
  * Get or create the database instance
  *
+ * Issue #135: Now uses getEnv().CM_DB_PATH instead of direct DATABASE_PATH access
+ * This ensures consistent DB path resolution for both global and local installs.
+ *
  * @returns Singleton database instance
  *
  * @example
@@ -26,13 +33,16 @@ let dbInstance = null;
  */
 function getDbInstance() {
     if (!dbInstance) {
-        const dbPath = process.env.DATABASE_PATH || path_1.default.join(process.cwd(), 'data', 'db.sqlite');
+        // Issue #135: Use getEnv() for consistent DB path resolution
+        const env = (0, env_1.getEnv)();
+        const dbPath = env.CM_DB_PATH;
         // Ensure the database directory exists
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const fs = require('fs');
         const dir = path_1.default.dirname(dbPath);
         if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
+            // SEC-003: Set directory permissions to 0o700 (owner only)
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
         }
         dbInstance = new better_sqlite3_1.default(dbPath);
         (0, db_migrations_1.runMigrations)(dbInstance);

package/dist/server/src/lib/db-migrations.js

@@ -19,7 +19,7 @@ const db_1 = require("./db");
  * Current schema version
  * Increment this when adding new migrations
  */
-exports.CURRENT_SCHEMA_VERSION = 15;
+exports.CURRENT_SCHEMA_VERSION = 16;
 /**
  * Migration registry
  * All migrations should be added to this array in order
@@ -650,6 +650,73 @@ const migrations = [
       `);
             console.log('✓ Removed initial_branch column from worktrees table');
         }
+    },
+    {
+        version: 16,
+        name: 'add-issue-no-to-external-apps',
+        up: (db) => {
+            // Issue #136: Add issue_no column to external_apps table
+            // This column identifies which worktree/issue an external app belongs to
+            // NULL = main app (non-worktree), integer = issue number
+            db.exec(`
+        ALTER TABLE external_apps ADD COLUMN issue_no INTEGER;
+      `);
+            // Create index for efficient querying by issue_no
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_external_apps_issue_no ON external_apps(issue_no);
+      `);
+            console.log('✓ Added issue_no column to external_apps table');
+            console.log('✓ Created index idx_external_apps_issue_no');
+        },
+        down: (db) => {
+            // SQLite doesn't support DROP COLUMN directly
+            // Recreate table without issue_no column
+            db.exec(`
+        -- 1. Create backup table without issue_no
+        CREATE TABLE external_apps_backup AS
+        SELECT id, name, display_name, description, path_prefix, target_port,
+               target_host, app_type, websocket_enabled, websocket_path_pattern,
+               enabled, created_at, updated_at
+        FROM external_apps;
+
+        -- 2. Drop original table (this also drops indexes)
+        DROP TABLE external_apps;
+
+        -- 3. Recreate table without issue_no
+        CREATE TABLE external_apps (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL UNIQUE,
+          display_name TEXT NOT NULL,
+          description TEXT,
+          path_prefix TEXT NOT NULL UNIQUE,
+          target_port INTEGER NOT NULL,
+          target_host TEXT DEFAULT 'localhost',
+          app_type TEXT NOT NULL CHECK(app_type IN ('sveltekit', 'streamlit', 'nextjs', 'other')),
+          websocket_enabled INTEGER DEFAULT 0,
+          websocket_path_pattern TEXT,
+          enabled INTEGER DEFAULT 1,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        -- 4. Restore data
+        INSERT INTO external_apps (id, name, display_name, description, path_prefix,
+               target_port, target_host, app_type, websocket_enabled, websocket_path_pattern,
+               enabled, created_at, updated_at)
+        SELECT id, name, display_name, description, path_prefix,
+               target_port, target_host, app_type, websocket_enabled, websocket_path_pattern,
+               enabled, created_at, updated_at
+        FROM external_apps_backup;
+
+        -- 5. Drop backup
+        DROP TABLE external_apps_backup;
+
+        -- 6. Recreate original indexes
+        CREATE INDEX idx_external_apps_path_prefix ON external_apps(path_prefix);
+        CREATE INDEX idx_external_apps_enabled ON external_apps(enabled);
+      `);
+            console.log('✓ Removed issue_no column from external_apps table');
+        }
     }
 ];
 /**

package/dist/server/src/lib/db-path-resolver.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * DB Path Resolver
+ * Issue #135: DB path resolution logic fix
+ * Issue #136: Import from install-context.ts to avoid circular imports
+ *
+ * Provides consistent DB path resolution for both global and local installs.
+ * This module centralizes DB path logic to follow SRP (Single Responsibility Principle).
+ *
+ * @module db-path-resolver
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultDbPath = getDefaultDbPath;
+exports.getIssueDbPath = getIssueDbPath;
+exports.validateDbPath = validateDbPath;
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+const install_context_1 = require("../cli/utils/install-context");
+const system_directories_1 = require("../config/system-directories");
+/**
+ * Get the default database path based on install type
+ *
+ * For global installs: ~/.commandmate/data/cm.db
+ * For local installs: <cwd>/data/cm.db (as absolute path)
+ *
+ * @returns Absolute path to the default database file
+ *
+ * @example
+ * ```typescript
+ * const dbPath = getDefaultDbPath();
+ * // Global: /Users/username/.commandmate/data/cm.db
+ * // Local: /path/to/project/data/cm.db
+ * ```
+ */
+function getDefaultDbPath() {
+    if ((0, install_context_1.isGlobalInstall)()) {
+        return path_1.default.join((0, os_1.homedir)(), '.commandmate', 'data', 'cm.db');
+    }
+    return path_1.default.resolve(process.cwd(), 'data', 'cm.db');
+}
+/**
+ * Get the database path for a specific issue (worktree)
+ * Issue #136: Worktree-specific DB path
+ *
+ * @param issueNo - The issue number
+ * @returns Absolute path to the issue-specific database file
+ *
+ * @example
+ * ```typescript
+ * const dbPath = getIssueDbPath(135);
+ * // Returns: /Users/username/.commandmate/data/cm-135.db
+ * ```
+ */
+function getIssueDbPath(issueNo) {
+    const configDir = (0, install_context_1.getConfigDir)();
+    return path_1.default.join(configDir, 'data', `cm-${issueNo}.db`);
+}
+/**
+ * Validate database path for security
+ *
+ * SEC-001: Protects against writing to system directories
+ * - Global install: DB path must be within home directory
+ * - Local install: DB path must not be in system directories
+ *
+ * @param dbPath - The database path to validate
+ * @returns The resolved absolute path if valid
+ * @throws Error if path is in a forbidden location
+ *
+ * @example
+ * ```typescript
+ * // Valid paths
+ * validateDbPath('~/.commandmate/data/cm.db'); // Global
+ * validateDbPath('./data/cm.db'); // Local
+ *
+ * // Invalid paths (throws)
+ * validateDbPath('/etc/cm.db');
+ * validateDbPath('/var/lib/cm.db');
+ * ```
+ */
+function validateDbPath(dbPath) {
+    const resolvedPath = path_1.default.resolve(dbPath);
+    if ((0, install_context_1.isGlobalInstall)()) {
+        // Global install: DB path must be within home directory
+        const homeDir = (0, os_1.homedir)();
+        if (!resolvedPath.startsWith(homeDir)) {
+            throw new Error(`Security error: DB path must be within home directory: ${resolvedPath}`);
+        }
+    }
+    else {
+        // Local install: DB path must not be in system directories (SEC-001)
+        if ((0, system_directories_1.isSystemDirectory)(resolvedPath)) {
+            throw new Error(`Security error: DB path cannot be in system directory: ${resolvedPath}`);
+        }
+    }
+    return resolvedPath;
+}

package/dist/server/src/lib/db.js

@@ -41,6 +41,7 @@ exports.saveInitialBranch = saveInitialBranch;
 exports.getInitialBranch = getInitialBranch;
 exports.getWorktreeIdsByRepository = getWorktreeIdsByRepository;
 exports.deleteRepositoryWorktrees = deleteRepositoryWorktrees;
+exports.deleteWorktreesByIds = deleteWorktreesByIds;
 const crypto_1 = require("crypto");
 function mapChatMessage(row) {
     return {
@@ -875,3 +876,23 @@ function deleteRepositoryWorktrees(db, repositoryPath) {
     const result = stmt.run(repositoryPath);
     return { deletedCount: result.changes };
 }
+/**
+ * Delete worktrees by their IDs
+ * Related data (chat_messages, session_states, worktree_memos) will be
+ * automatically deleted via CASCADE foreign key constraints.
+ *
+ * @param db - Database instance
+ * @param worktreeIds - Array of worktree IDs to delete
+ * @returns Object containing the count of deleted worktrees
+ */
+function deleteWorktreesByIds(db, worktreeIds) {
+    if (worktreeIds.length === 0) {
+        return { deletedCount: 0 };
+    }
+    const placeholders = worktreeIds.map(() => '?').join(',');
+    const stmt = db.prepare(`
+    DELETE FROM worktrees WHERE id IN (${placeholders})
+  `);
+    const result = stmt.run(...worktreeIds);
+    return { deletedCount: result.changes };
+}