commandmate 0.1.10 → 0.1.12

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

@@ -0,0 +1,324 @@
+"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 storage for auto-yes states (globalThis for hot reload persistence) */
+const autoYesStates = globalThis.__autoYesStates ??
+    (globalThis.__autoYesStates = new Map());
+/** In-memory storage for poller states (globalThis for hot reload persistence) */
+const autoYesPollerStates = globalThis.__autoYesPollerStates ??
+    (globalThis.__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/claude-session.js

@@ -4,19 +4,84 @@
  * Manages Claude CLI sessions within tmux for each worktree
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_POST_PROMPT_DELAY = exports.CLAUDE_INIT_POLL_INTERVAL = exports.CLAUDE_INIT_TIMEOUT = void 0;
 exports.getSessionName = getSessionName;
 exports.isClaudeInstalled = isClaudeInstalled;
 exports.isClaudeRunning = isClaudeRunning;
 exports.getClaudeSessionState = getClaudeSessionState;
+exports.waitForPrompt = waitForPrompt;
 exports.startClaudeSession = startClaudeSession;
 exports.sendMessageToClaude = sendMessageToClaude;
 exports.captureClaudeOutput = captureClaudeOutput;
 exports.stopClaudeSession = stopClaudeSession;
 exports.restartClaudeSession = restartClaudeSession;
 const tmux_1 = require("./tmux");
+const cli_patterns_1 = require("./cli-patterns");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// ----- Helper Functions -----
+/**
+ * Extract error message from unknown error type
+ * Provides consistent error message extraction across the module (DRY)
+ *
+ * @param error - Unknown error object
+ * @returns Error message string
+ */
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// ----- Timeout and Polling Constants (OCP-001) -----
+// These constants are exported to allow configuration and testing.
+// Changing these values affects Claude CLI session startup behavior.
+/**
+ * Claude CLI initialization max wait time (milliseconds)
+ *
+ * This timeout allows sufficient time for Claude CLI to:
+ * - Load and initialize its internal state
+ * - Authenticate with Anthropic servers (if needed)
+ * - Display the interactive prompt
+ *
+ * 15 seconds provides headroom for slower networks or cold starts.
+ */
+exports.CLAUDE_INIT_TIMEOUT = 15000;
+/**
+ * Initialization polling interval (milliseconds)
+ *
+ * How frequently we check if Claude CLI has finished initializing.
+ * 300ms balances responsiveness with avoiding excessive polling overhead.
+ */
+exports.CLAUDE_INIT_POLL_INTERVAL = 300;
+/**
+ * Stability delay after prompt detection (milliseconds)
+ *
+ * This delay is necessary because Claude CLI renders its UI progressively:
+ * 1. The prompt character (> or U+276F) appears first
+ * 2. Additional UI elements (tips, suggestions) may render afterward
+ * 3. Sending input too quickly can interrupt this rendering process
+ *
+ * The 500ms value was empirically determined to provide sufficient buffer
+ * for Claude CLI to complete its initialization rendering while maintaining
+ * responsive user experience. (DOC-001)
+ *
+ * @see Issue #152 - First message not being sent after session start
+ */
+exports.CLAUDE_POST_PROMPT_DELAY = 500;
+/**
+ * Prompt wait timeout before message send (milliseconds)
+ *
+ * When sending a message, we first verify Claude is at a prompt state.
+ * This timeout limits how long we wait for Claude to return to prompt
+ * if it's still processing a previous request.
+ */
+exports.CLAUDE_PROMPT_WAIT_TIMEOUT = 5000;
+/**
+ * Prompt wait polling interval (milliseconds)
+ *
+ * How frequently we check for prompt state before sending messages.
+ * 200ms provides quick response while minimizing CPU usage.
+ */
+exports.CLAUDE_PROMPT_POLL_INTERVAL = 200;
 /**
  * Cached Claude CLI path
  */
@@ -122,6 +187,35 @@ async function getClaudeSessionState(worktreeId) {
         lastActivity: new Date(),
     };
 }
+/**
+ * Wait for session to be at prompt state
+ * Polls for prompt detection using CLAUDE_PROMPT_PATTERN (DRY-001)
+ *
+ * @param sessionName - tmux session name
+ * @param timeout - Timeout in milliseconds (default: CLAUDE_PROMPT_WAIT_TIMEOUT)
+ * @throws {Error} If prompt is not detected within timeout
+ *
+ * @example
+ * ```typescript
+ * await waitForPrompt('mcbd-claude-feature-foo');
+ * // Session is now ready to receive input
+ * ```
+ */
+async function waitForPrompt(sessionName, timeout = exports.CLAUDE_PROMPT_WAIT_TIMEOUT) {
+    const startTime = Date.now();
+    const pollInterval = exports.CLAUDE_PROMPT_POLL_INTERVAL;
+    while (Date.now() - startTime < timeout) {
+        // Use -50 lines to capture more context including status bars
+        const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+        // DRY-001: Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts
+        // Strip ANSI escape sequences before pattern matching (Issue #152)
+        if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test((0, cli_patterns_1.stripAnsi)(output))) {
+            return; // Prompt detected
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Prompt detection timeout (${timeout}ms)`);
+}
 /**
  * Start a Claude CLI session in tmux
  *
@@ -162,18 +256,25 @@ async function startClaudeSession(options) {
         const claudePath = await getClaudePath();
         // Start Claude CLI in interactive mode using dynamically resolved path
         await (0, tmux_1.sendKeys)(sessionName, claudePath, true);
-        // Wait for Claude to initialize with dynamic detection
-        // Check for Claude prompt instead of fixed delay
-        const maxWaitTime = 10000; // 10 seconds max
-        const pollInterval = 500; // Check every 500ms
+        // Wait for Claude to initialize with dynamic detection (OCP-001)
+        // Use constants instead of hardcoded values
+        const maxWaitTime = exports.CLAUDE_INIT_TIMEOUT;
+        const pollInterval = exports.CLAUDE_INIT_POLL_INTERVAL;
         const startTime = Date.now();
+        let initialized = false;
         while (Date.now() - startTime < maxWaitTime) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             try {
                 const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
-                // Claude is ready when we see the prompt (> ) or separator line
-                if (/^>\s*$/m.test(output) || /^─{10,}$/m.test(output)) {
-                    console.log(`✓ Claude initialized in ${Date.now() - startTime}ms`);
+                // Claude is ready when we see the prompt or separator line (DRY-001, DRY-002)
+                // Use patterns from cli-patterns.ts for consistency
+                // Strip ANSI escape sequences before pattern matching (Issue #152)
+                const cleanOutput = (0, cli_patterns_1.stripAnsi)(output);
+                if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput) || cli_patterns_1.CLAUDE_SEPARATOR_PATTERN.test(cleanOutput)) {
+                    // Wait for stability after prompt detection (CONS-007, DOC-001)
+                    await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
+                    console.log(`Claude initialized in ${Date.now() - startTime}ms`);
+                    initialized = true;
                     break;
                 }
             }
@@ -181,11 +282,14 @@ async function startClaudeSession(options) {
                 // Ignore capture errors during initialization
             }
         }
-        console.log(`✓ Started Claude session: ${sessionName}`);
+        // Throw error on timeout instead of silently continuing (CONS-005, IMP-001)
+        if (!initialized) {
+            throw new Error(`Claude initialization timeout (${exports.CLAUDE_INIT_TIMEOUT}ms)`);
+        }
+        console.log(`Started Claude session: ${sessionName}`);
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to start Claude session: ${errorMessage}`);
+        throw new Error(`Failed to start Claude session: ${getErrorMessage(error)}`);
     }
 }
 /**
@@ -207,21 +311,25 @@ async function sendMessageToClaude(worktreeId, message) {
     if (!exists) {
         throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
     }
-    try {
-        // Send message to Claude (without Enter)
-        await (0, tmux_1.sendKeys)(sessionName, message, false);
-        // Wait a moment for the text to be typed
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        // Send Enter key to submit (single Enter submits in Claude Code CLI)
-        await execAsync(`tmux send-keys -t "${sessionName}" C-m`);
-        // Wait a moment for the message to be processed
-        await new Promise((resolve) => setTimeout(resolve, 200));
-        console.log(`✓ Sent message to Claude session: ${sessionName}`);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to send message to Claude: ${errorMessage}`);
+    // Verify prompt state before sending (CONS-006, DRY-001)
+    // Use -50 lines to ensure we capture the prompt even with status bars
+    const output = await (0, tmux_1.capturePane)(sessionName, { startLine: -50 });
+    // Strip ANSI escape sequences before pattern matching (Issue #152)
+    if (!cli_patterns_1.CLAUDE_PROMPT_PATTERN.test((0, cli_patterns_1.stripAnsi)(output))) {
+        // Wait for prompt if not at prompt state
+        // Use longer timeout (10s) to handle slow responses
+        try {
+            await waitForPrompt(sessionName, 10000);
+        }
+        catch {
+            // Log warning but don't block - Claude might be in a special state
+            console.warn(`[sendMessageToClaude] Prompt not detected, sending anyway`);
+        }
     }
+    // Send message using sendKeys consistently (CONS-001)
+    await (0, tmux_1.sendKeys)(sessionName, message, false); // Message without Enter
+    await (0, tmux_1.sendKeys)(sessionName, '', true); // Enter key
+    console.log(`Sent message to Claude session: ${sessionName}`);
 }
 /**
  * Capture Claude session output
@@ -247,8 +355,7 @@ async function captureClaudeOutput(worktreeId, lines = 1000) {
         return await (0, tmux_1.capturePane)(sessionName, { startLine: -lines });
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to capture Claude output: ${errorMessage}`);
+        throw new Error(`Failed to capture Claude output: ${getErrorMessage(error)}`);
     }
 }
 /**
@@ -282,8 +389,7 @@ async function stopClaudeSession(worktreeId) {
         return killed;
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`Error stopping Claude session: ${errorMessage}`);
+        console.error(`Error stopping Claude session: ${getErrorMessage(error)}`);
         return false;
     }
 }

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);