commandmate 0.2.0 → 0.2.2

package/dist/server/server.js

@@ -37,6 +37,8 @@ const response_poller_1 = require("./src/lib/response-poller");
 const auto_yes_manager_1 = require("./src/lib/auto-yes-manager");
 const db_migrations_1 = require("./src/lib/db-migrations");
 const env_1 = require("./src/lib/env");
+const db_repository_1 = require("./src/lib/db-repository");
+const db_1 = require("./src/lib/db");
 const dev = process.env.NODE_ENV !== 'production';
 const hostname = (0, env_1.getEnvByKey)('CM_BIND') || '127.0.0.1';
 const port = parseInt((0, env_1.getEnvByKey)('CM_PORT') || '3000', 10);
@@ -76,8 +78,29 @@ app.prepare().then(() => {
             repositoryPaths.forEach((path, i) => {
                 console.log(`  ${i + 1}. ${path}`);
             });
-            // Scan all repositories
-            const worktrees = await (0, worktrees_1.scanMultipleRepositories)(repositoryPaths);
+            // Issue #202: Register environment variable repositories and filter out excluded ones
+            // registerAndFilterRepositories() encapsulates the ordering constraint:
+            // registration MUST happen before filtering (see design policy Section 4)
+            const { filteredPaths, excludedPaths, excludedCount } = (0, db_repository_1.registerAndFilterRepositories)(db, repositoryPaths);
+            if (excludedCount > 0) {
+                console.log(`Excluded repositories: ${excludedCount}, Active repositories: ${filteredPaths.length}`);
+                // SF-SEC-003: Log excluded repository paths for audit/troubleshooting
+                excludedPaths.forEach(p => {
+                    console.log(`  [excluded] ${p}`);
+                });
+                // Issue #202: Remove worktrees of excluded repositories from DB
+                // Without this, worktree records remain in DB and appear in the UI
+                for (const excludedPath of excludedPaths) {
+                    const resolvedPath = (0, db_repository_1.resolveRepositoryPath)(excludedPath);
+                    const worktreeIds = (0, db_1.getWorktreeIdsByRepository)(db, resolvedPath);
+                    if (worktreeIds.length > 0) {
+                        const result = (0, db_1.deleteWorktreesByIds)(db, worktreeIds);
+                        console.log(`  Removed ${result.deletedCount} worktree(s) from excluded repository: ${resolvedPath}`);
+                    }
+                }
+            }
+            // Scan filtered repositories (excluded repos are skipped)
+            const worktrees = await (0, worktrees_1.scanMultipleRepositories)(filteredPaths);
             // Sync to database
             (0, worktrees_1.syncWorktreesToDB)(db, worktrees);
             console.log(`✓ Total: ${worktrees.length} worktree(s) synced to database`);

package/dist/server/src/config/auto-yes-config.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Auto-Yes Configuration Constants
+ *
+ * Shared config for Auto-Yes duration settings.
+ * Used by both server (auto-yes-manager.ts, route.ts) and client
+ * (AutoYesConfirmDialog.tsx, AutoYesToggle.tsx) components.
+ *
+ * Issue #225: Duration selection feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURATION_LABELS = exports.DEFAULT_AUTO_YES_DURATION = exports.ALLOWED_DURATIONS = void 0;
+exports.isAllowedDuration = isAllowedDuration;
+exports.formatTimeRemaining = formatTimeRemaining;
+/** Allowed Auto-Yes durations in milliseconds */
+exports.ALLOWED_DURATIONS = [3600000, 10800000, 28800000];
+/** Default Auto-Yes duration (1 hour = 3600000ms) */
+exports.DEFAULT_AUTO_YES_DURATION = 3600000;
+/** UI display labels for each duration value */
+exports.DURATION_LABELS = {
+    3600000: '1時間',
+    10800000: '3時間',
+    28800000: '8時間',
+};
+/**
+ * Type guard: check whether a value is a valid AutoYesDuration.
+ * Replaces `as AutoYesDuration` casts with a runtime-safe check.
+ */
+function isAllowedDuration(value) {
+    return typeof value === 'number' && exports.ALLOWED_DURATIONS.includes(value);
+}
+/** Milliseconds per second */
+const MS_PER_SECOND = 1000;
+/** Milliseconds per minute */
+const MS_PER_MINUTE = 60000;
+/** Milliseconds per hour */
+const MS_PER_HOUR = 3600000;
+/**
+ * Format remaining time as MM:SS (under 1 hour) or H:MM:SS (1 hour or more).
+ *
+ * Extracted from AutoYesToggle.tsx for direct testability and reuse.
+ * Negative remaining time is clamped to 0.
+ */
+function formatTimeRemaining(expiresAt) {
+    const remaining = Math.max(0, expiresAt - Date.now());
+    const hours = Math.floor(remaining / MS_PER_HOUR);
+    const minutes = Math.floor((remaining % MS_PER_HOUR) / MS_PER_MINUTE);
+    const seconds = Math.floor((remaining % MS_PER_MINUTE) / MS_PER_SECOND);
+    if (hours > 0) {
+        return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+    }
+    return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+}

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

@@ -9,7 +9,7 @@
  * 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.THINKING_CHECK_LINE_COUNT = 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;
@@ -28,6 +28,7 @@ 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");
+const auto_yes_config_1 = require("../config/auto-yes-config");
 // =============================================================================
 // Constants (Issue #138)
 // =============================================================================
@@ -39,8 +40,16 @@ exports.MAX_BACKOFF_MS = 60000;
 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;
+/**
+ * Number of lines from the end to check for thinking indicators (Issue #191)
+ * Matches detectPrompt()'s multiple_choice scan range (50 lines in prompt-detector.ts)
+ * to ensure Issue #161 Layer 1 defense covers the same scope as prompt detection.
+ *
+ * IMPORTANT: This value is semantically coupled to the hardcoded 50 in
+ * prompt-detector.ts detectMultipleChoicePrompt() (L268: Math.max(0, lines.length - 50)).
+ * See SF-001 in Stage 1 review. A cross-reference test validates this coupling.
+ */
+exports.THINKING_CHECK_LINE_COUNT = 50;
 /** 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) */
@@ -106,14 +115,17 @@ function getAutoYesState(worktreeId) {
 }
 /**
  * Set the auto-yes enabled state for a worktree
+ * @param duration - Optional duration in milliseconds (must be an ALLOWED_DURATIONS value).
+ *                   Defaults to DEFAULT_AUTO_YES_DURATION (1 hour) when omitted.
  */
-function setAutoYesEnabled(worktreeId, enabled) {
+function setAutoYesEnabled(worktreeId, enabled, duration) {
     if (enabled) {
         const now = Date.now();
+        const effectiveDuration = duration ?? auto_yes_config_1.DEFAULT_AUTO_YES_DURATION;
         const state = {
             enabled: true,
             enabledAt: now,
-            expiresAt: now + AUTO_YES_TIMEOUT_MS,
+            expiresAt: now + effectiveDuration,
         };
         autoYesStates.set(worktreeId, state);
         return state;
@@ -210,12 +222,29 @@ async function pollAutoYes(worktreeId, cliToolId) {
         // 2.5. Skip prompt detection during thinking state (Issue #161, Layer 1)
         // This prevents false positive detection of numbered lists in CLI output
         // while Claude is actively processing (thinking/planning).
-        if ((0, cli_patterns_1.detectThinking)(cliToolId, cleanOutput)) {
+        //
+        // Issue #191: Apply windowing to detectThinking() to prevent stale thinking
+        // summary lines (e.g., "· Simmering…") from blocking prompt detection.
+        // Window size matches detectPrompt()'s multiple_choice scan range (50 lines).
+        //
+        // Safety: Claude CLI does not emit prompts during thinking, so narrowing
+        // the window cannot cause false auto-responses (see IA-003 in design doc).
+        //
+        // Processing order: stripAnsi -> split -> slice -> join
+        // stripAnsi is applied BEFORE split to ensure ANSI escape sequences spanning
+        // line boundaries do not affect line counting (IA-002).
+        //
+        // Boundary case: if buffer has fewer than 50 lines, slice(-50) returns the
+        // entire array (Array.prototype.slice specification), which is safe degradation
+        // equivalent to pre-fix behavior (IA-001).
+        const recentLines = cleanOutput.split('\n').slice(-exports.THINKING_CHECK_LINE_COUNT).join('\n');
+        if ((0, cli_patterns_1.detectThinking)(cliToolId, recentLines)) {
             scheduleNextPoll(worktreeId, cliToolId);
             return;
         }
         // 3. Detect prompt
-        const promptDetection = (0, prompt_detector_1.detectPrompt)(cleanOutput);
+        const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
+        const promptDetection = (0, prompt_detector_1.detectPrompt)(cleanOutput, promptOptions);
         if (!promptDetection.isPrompt || !promptDetection.promptData) {
             // No prompt detected, schedule next poll
             scheduleNextPoll(worktreeId, cliToolId);
@@ -232,10 +261,64 @@ async function pollAutoYes(worktreeId, cliToolId) {
         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);
+        // Issue #193: Claude Code AskUserQuestion uses cursor-based navigation
+        // (Arrow/Space/Enter), not number input. Detect multi-choice and send
+        // appropriate key sequence instead of typing the number.
+        const isClaudeMultiChoice = cliToolId === 'claude'
+            && promptDetection.promptData?.type === 'multiple_choice'
+            && /^\d+$/.test(answer);
+        if (isClaudeMultiChoice && promptDetection.promptData?.type === 'multiple_choice') {
+            const targetNum = parseInt(answer, 10);
+            const mcOptions = promptDetection.promptData.options;
+            const defaultOption = mcOptions.find(o => o.isDefault);
+            const defaultNum = defaultOption?.number ?? 1;
+            const offset = targetNum - defaultNum;
+            // Detect multi-select (checkbox) prompts by checking for [ ] in option labels.
+            const isMultiSelect = mcOptions.some(o => /^\[[ x]\] /.test(o.label));
+            if (isMultiSelect) {
+                // Multi-select: toggle checkbox, then navigate to "Next" and submit
+                const checkboxCount = mcOptions.filter(o => /^\[[ x]\] /.test(o.label)).length;
+                const keys = [];
+                // 1. Navigate to target option
+                if (offset > 0) {
+                    for (let i = 0; i < offset; i++)
+                        keys.push('Down');
+                }
+                else if (offset < 0) {
+                    for (let i = 0; i < Math.abs(offset); i++)
+                        keys.push('Up');
+                }
+                // 2. Space to toggle checkbox
+                keys.push('Space');
+                // 3. Navigate to "Next" button (positioned right after all checkbox options)
+                const downToNext = checkboxCount - targetNum + 1;
+                for (let i = 0; i < downToNext; i++)
+                    keys.push('Down');
+                // 4. Enter to submit
+                keys.push('Enter');
+                await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+            }
+            else {
+                // Single-select: navigate and Enter to select
+                const keys = [];
+                if (offset > 0) {
+                    for (let i = 0; i < offset; i++)
+                        keys.push('Down');
+                }
+                else if (offset < 0) {
+                    for (let i = 0; i < Math.abs(offset); i++)
+                        keys.push('Up');
+                }
+                keys.push('Enter');
+                await (0, tmux_1.sendSpecialKeys)(sessionName, keys);
+            }
+        }
+        else {
+            // Standard CLI prompt: send text + Enter (y/n, Approve?, etc.)
+            await (0, tmux_1.sendKeys)(sessionName, answer, false);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await (0, tmux_1.sendKeys)(sessionName, '', true);
+        }
         // 6. Update timestamp
         updateLastServerResponseTimestamp(worktreeId, Date.now());
         // 7. Reset error count on success

package/dist/server/src/lib/claude-poller.js

@@ -138,6 +138,8 @@ function extractClaudeResponse(output, lastCapturedLine) {
     }
     // Check if this is an interactive prompt (yes/no or multiple choice)
     // Interactive prompts don't have the ">" prompt and separator, so we need to detect them separately
+    // TODO [Issue #193]: This code path is unreachable (claude-poller.ts is superseded by response-poller.ts).
+    // When refactoring/removing claude-poller.ts, apply stripAnsi() + buildDetectPromptOptions() here.
     if (!isThinking) {
         const fullOutput = lines.join('\n');
         const promptDetection = (0, prompt_detector_1.detectPrompt)(fullOutput);
@@ -196,6 +198,8 @@ async function checkForResponse(worktreeId) {
             return false;
         }
         // Response is complete! Check if it's a prompt
+        // TODO [Issue #193]: This code path is unreachable (claude-poller.ts is superseded by response-poller.ts).
+        // When refactoring/removing claude-poller.ts, apply stripAnsi() + buildDetectPromptOptions() here.
         const promptDetection = (0, prompt_detector_1.detectPrompt)(result.response);
         if (promptDetection.isPrompt) {
             // This is a prompt - save as prompt message

package/dist/server/src/lib/claude-session.js

@@ -4,7 +4,7 @@
  * 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.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 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;
@@ -17,6 +17,7 @@ exports.stopClaudeSession = stopClaudeSession;
 exports.restartClaudeSession = restartClaudeSession;
 const tmux_1 = require("./tmux");
 const cli_patterns_1 = require("./cli-patterns");
+const pasted_text_helper_1 = require("./pasted-text-helper");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
@@ -42,6 +43,9 @@ function getErrorMessage(error) {
  * - Authenticate with Anthropic servers (if needed)
  * - Display the interactive prompt
  *
+ * This timeout also covers trust dialog auto-response time (typically <1s).
+ * When reducing this value, consider dialog response overhead.
+ *
  * 15 seconds provides headroom for slower networks or cold starts.
  */
 exports.CLAUDE_INIT_TIMEOUT = 15000;
@@ -75,6 +79,24 @@ exports.CLAUDE_POST_PROMPT_DELAY = 500;
  * if it's still processing a previous request.
  */
 exports.CLAUDE_PROMPT_WAIT_TIMEOUT = 5000;
+/**
+ * Prompt wait timeout before message send (milliseconds).
+ *
+ * Used exclusively by sendMessageToClaude() to limit how long we wait
+ * for Claude to return to a prompt state before sending a user message.
+ * This is separate from CLAUDE_PROMPT_WAIT_TIMEOUT (5000ms, the default
+ * for waitForPrompt()) because sendMessageToClaude() may be called
+ * shortly after session initialization, where Claude CLI needs additional
+ * time to become ready.
+ *
+ * Relationship to other timeout constants:
+ * - CLAUDE_PROMPT_WAIT_TIMEOUT (5000ms): Default for waitForPrompt()
+ * - CLAUDE_SEND_PROMPT_WAIT_TIMEOUT (10000ms): sendMessageToClaude() specific
+ * - CLAUDE_INIT_TIMEOUT (15000ms): Session initialization timeout
+ *
+ * @see Issue #187 - Constant unification for sendMessageToClaude timeout
+ */
+exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = 10000;
 /**
  * Prompt wait polling interval (milliseconds)
  *
@@ -227,7 +249,6 @@ async function waitForPrompt(sessionName, timeout = exports.CLAUDE_PROMPT_WAIT_T
  * await startClaudeSession({
  *   worktreeId: 'feature-foo',
  *   worktreePath: '/path/to/worktree',
- *   baseUrl: 'http://localhost:3000',
  * });
  * ```
  */
@@ -262,21 +283,33 @@ async function startClaudeSession(options) {
         const pollInterval = exports.CLAUDE_INIT_POLL_INTERVAL;
         const startTime = Date.now();
         let initialized = false;
+        let trustDialogHandled = 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 (DRY-001, DRY-002)
-                // Use patterns from cli-patterns.ts for consistency
+                // Claude is ready when we see the prompt (DRY-001)
+                // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
                 // Strip ANSI escape sequences before pattern matching (Issue #152)
+                // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
+                // because separator early-detection caused premature returns before prompt was ready
                 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)) {
+                if (cli_patterns_1.CLAUDE_PROMPT_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;
                 }
+                // Issue #201: Detect trust dialog and auto-respond with Enter
+                // Condition order: CLAUDE_PROMPT_PATTERN (above) is checked first for shortest path
+                if (!trustDialogHandled && cli_patterns_1.CLAUDE_TRUST_DIALOG_PATTERN.test(cleanOutput)) {
+                    await (0, tmux_1.sendKeys)(sessionName, '', true);
+                    trustDialogHandled = true;
+                    // TODO: Log output method unification (console.log vs createLogger) to be addressed in a separate Issue (SF-002)
+                    console.log('Trust dialog detected, sending Enter to confirm');
+                    // Continue polling to wait for prompt detection
+                }
             }
             catch {
                 // Ignore capture errors during initialization
@@ -312,23 +345,26 @@ async function sendMessageToClaude(worktreeId, message) {
         throw new Error(`Claude session ${sessionName} does not exist. Start the session first.`);
     }
     // 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`);
-        }
+        // Path B: Prompt not detected - wait for it (P1: throw on timeout)
+        await waitForPrompt(sessionName, exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT);
     }
+    // P0: Stability delay after prompt detection (both Path A and Path B)
+    // Same delay as startClaudeSession() to ensure Claude CLI input handler is ready
+    // NOTE: This 500ms delay also applies to 2nd+ messages. Currently acceptable since
+    // Claude CLI response time (seconds to tens of seconds) dwarfs this overhead.
+    // If future batch-send use cases arise, this could be optimized to first-message-only,
+    // but that optimization is deferred per YAGNI principle. (ref: F-3)
+    await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
     // 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
+    await (0, tmux_1.sendKeys)(sessionName, message, false);
+    await (0, tmux_1.sendKeys)(sessionName, '', true);
+    // Issue #212: Detect [Pasted text] and resend Enter for multi-line messages
+    // MF-001: Single-line messages skip detection (+0ms overhead)
+    if (message.includes('\n')) {
+        await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
+    }
     console.log(`Sent message to Claude session: ${sessionName}`);
 }
 /**
@@ -403,7 +439,6 @@ async function stopClaudeSession(worktreeId) {
  * await restartClaudeSession({
  *   worktreeId: 'feature-foo',
  *   worktreePath: '/path/to/worktree',
- *   baseUrl: 'http://localhost:3000',
  * });
  * ```
  */

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

@@ -4,10 +4,11 @@
  * Shared between response-poller.ts and API routes
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GEMINI_PROMPT_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
+exports.GEMINI_PROMPT_PATTERN = exports.MAX_PASTED_TEXT_RETRIES = exports.PASTED_TEXT_DETECT_DELAY = exports.PASTED_TEXT_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_TRUST_DIALOG_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
 exports.detectThinking = detectThinking;
 exports.getCliToolPatterns = getCliToolPatterns;
 exports.stripAnsi = stripAnsi;
+exports.buildDetectPromptOptions = buildDetectPromptOptions;
 const logger_1 = require("./logger");
 const logger = (0, logger_1.createLogger)('cli-patterns');
 /**
@@ -23,8 +24,14 @@ exports.CLAUDE_SPINNER_CHARS = [
  * Claude thinking pattern
  * Matches spinner character followed by activity text ending with …
  * The text can contain spaces (e.g., "Verifying implementation (dead code detection)…")
+ *
+ * Alternative 2: "esc to interrupt" status bar text (Issue #XXX)
+ * Claude Code shows "esc to interrupt" in the terminal status bar during active processing.
+ * Previous pattern required closing paren `to interrupt\)` matching `(esc to interrupt)`,
+ * but Claude Code v2.x status bar format uses `· esc to interrupt ·` without parens.
+ * Updated to match `esc to interrupt` which covers both formats.
  */
-exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.join('')}]\\s+.+…|to interrupt\\)`, 'm');
+exports.CLAUDE_THINKING_PATTERN = new RegExp(`[${exports.CLAUDE_SPINNER_CHARS.join('')}]\\s+.+…|esc to interrupt`, 'm');
 /**
  * Codex thinking pattern
  * Matches activity indicators like "• Planning", "• Searching", etc.
@@ -45,6 +52,19 @@ exports.CLAUDE_PROMPT_PATTERN = /^[>❯](\s*$|\s+\S)/m;
  * Claude separator pattern
  */
 exports.CLAUDE_SEPARATOR_PATTERN = /^─{10,}$/m;
+/**
+ * Claude trust dialog pattern (Issue #201)
+ *
+ * Matches the "Quick safety check" dialog displayed by Claude CLI v2.x
+ * when accessing a workspace for the first time.
+ *
+ * Intentionally uses partial matching (no line-start anchor ^):
+ * Other pattern constants (CLAUDE_PROMPT_PATTERN, CLAUDE_SEPARATOR_PATTERN, etc.)
+ * use line-start anchors (^), but this pattern needs to match at any position
+ * within the tmux output buffer because the dialog text may appear after
+ * tmux padding or other output. (SF-001)
+ */
+exports.CLAUDE_TRUST_DIALOG_PATTERN = /Yes, I trust this folder/m;
 /**
  * Codex prompt pattern
  * T1.2: Improved to detect empty prompts as well
@@ -54,6 +74,44 @@ exports.CODEX_PROMPT_PATTERN = /^›\s*/m;
  * Codex separator pattern
  */
 exports.CODEX_SEPARATOR_PATTERN = /^─.*Worked for.*─+$/m;
+/**
+ * Pasted text pattern
+ *
+ * Claude CLI displays this when it detects multi-line text paste in the
+ * ink-based TextInput. The pattern matches the folded display format.
+ *
+ * @example "[Pasted text #1 +46 lines]"
+ * @see Issue #212, #163
+ * @designNote PASTE-001: Pattern matches the start of the indicator only.
+ *   The line count (+XX lines) is variable, so we match the fixed prefix
+ *   to minimize false negatives. False positive risk is low because
+ *   "[Pasted text #" is a unique format generated by Claude CLI's ink renderer.
+ * @designNote PASTE-001-FP (SF-S4-002): When used in skipPatterns,
+ *   line-level matching could filter legitimate response lines if Claude's
+ *   answer text happens to contain "[Pasted text #". This is unlikely and
+ *   acceptable -- only the affected line would be lost.
+ */
+exports.PASTED_TEXT_PATTERN = /\[Pasted text #\d+/;
+/**
+ * Pasted text detection delay (milliseconds)
+ *
+ * Wait time after sendKeys for tmux buffer to reflect [Pasted text] display.
+ *
+ * @see Issue #212
+ * @designNote PASTE-002: 500ms is the empirically measured time for
+ *   Claude CLI's ink rendering to complete. capturePane({ startLine: -10 })
+ *   reads only the last 10 lines since [Pasted text] appears in the most
+ *   recent few lines.
+ */
+exports.PASTED_TEXT_DETECT_DELAY = 500;
+/**
+ * Pasted text detection max retries
+ *
+ * @see Issue #212
+ * @designNote PASTE-003: 3 retries x 500ms = max 1500ms additional delay.
+ *   Typically resolves on the first attempt (+500ms).
+ */
+exports.MAX_PASTED_TEXT_RETRIES = 3;
 /**
  * Gemini shell prompt pattern
  */
@@ -100,6 +158,7 @@ function getCliToolPatterns(cliToolId) {
                     /^\s*Tip:/, // Tip lines
                     /^\s*\?\s*for shortcuts/, // Shortcuts hint
                     /to interrupt\)/, // Part of "esc to interrupt" message
+                    exports.PASTED_TEXT_PATTERN, // [Pasted text #N +XX lines] (Issue #212)
                 ],
             };
         case 'codex':
@@ -121,6 +180,7 @@ function getCliToolPatterns(cliToolId) {
                     /^\s*└/, // Tree output (completion indicator)
                     /^\s*│/, // Continuation lines
                     /\(.*esc to interrupt\)/, // Interrupt hint
+                    exports.PASTED_TEXT_PATTERN, // [Pasted text #N +XX lines] (Issue #212, defensive)
                 ],
             };
         case 'gemini':
@@ -140,10 +200,46 @@ function getCliToolPatterns(cliToolId) {
     }
 }
 /**
- * Strip ANSI escape codes from a string
- * Optimized version at module level for performance
+ * Strip ANSI escape codes from a string.
+ * Optimized version at module level for performance.
+ *
+ * Covers:
+ * - SGR sequences: ESC[Nm (colors, bold, underline, etc.)
+ * - OSC sequences: ESC]...BEL (window title, hyperlinks, etc.)
+ * - CSI sequences: ESC[...letter (cursor movement, erase, etc.)
+ *
+ * Known limitations (SEC-002):
+ * - 8-bit CSI (0x9B): C1 control code form of CSI is not covered
+ * - DEC private modes: ESC[?25h and similar are not covered
+ * - Character set switching: ESC(0, ESC(B are not covered
+ * - Some RGB color forms: ESC[38;2;r;g;bm may not be fully matched
+ *
+ * In practice, tmux capture-pane output rarely contains these sequences,
+ * so the risk is low. Future consideration: adopt the `strip-ansi` npm package
+ * for more comprehensive coverage.
  */
 const ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\[[0-9;]*m/g;
 function stripAnsi(str) {
     return str.replace(ANSI_PATTERN, '');
 }
+/**
+ * Build DetectPromptOptions for a given CLI tool.
+ * Centralizes cliToolId-to-options mapping logic (DRY - MF-001).
+ *
+ * prompt-detector.ts remains CLI tool independent (Issue #161 principle);
+ * this function lives in cli-patterns.ts which already depends on CLIToolType.
+ *
+ * [Future extension memo (C-002)]
+ * If CLI tool count grows significantly (currently 3), consider migrating
+ * to a CLIToolConfig registry pattern where tool-specific settings
+ * (including promptDetectionOptions) are managed in a Record<CLIToolType, CLIToolConfig>.
+ *
+ * @param cliToolId - CLI tool identifier
+ * @returns DetectPromptOptions for the tool, or undefined for default behavior
+ */
+function buildDetectPromptOptions(cliToolId) {
+    if (cliToolId === 'claude') {
+        return { requireDefaultIndicator: false };
+    }
+    return undefined; // Default behavior (requireDefaultIndicator = true)
+}

package/dist/server/src/lib/cli-tools/codex.js

@@ -9,7 +9,15 @@ const base_1 = require("./base");
 const tmux_1 = require("../tmux");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
+const pasted_text_helper_1 = require("../pasted-text-helper");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Extract error message from unknown error type (DRY)
+ * Same pattern as claude-session.ts getErrorMessage()
+ */
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 /**
  * Codex initialization timing constants
  * T2.6: Extracted as constants for maintainability
@@ -79,7 +87,7 @@ class CodexTool extends base_1.BaseCLITool {
             console.log(`✓ Started Codex session: ${sessionName}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = getErrorMessage(error);
             throw new Error(`Failed to start Codex session: ${errorMessage}`);
         }
     }
@@ -105,10 +113,15 @@ class CodexTool extends base_1.BaseCLITool {
             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));
+            // Issue #212: Detect [Pasted text] and resend Enter for multi-line messages
+            // MF-001: Single-line messages skip detection (+0ms overhead)
+            if (message.includes('\n')) {
+                await (0, pasted_text_helper_1.detectAndResendIfPastedText)(sessionName);
+            }
             console.log(`✓ Sent message to Codex session: ${sessionName}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = getErrorMessage(error);
             throw new Error(`Failed to send message to Codex: ${errorMessage}`);
         }
     }
@@ -135,7 +148,7 @@ class CodexTool extends base_1.BaseCLITool {
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = getErrorMessage(error);
             console.error(`Error stopping Codex session: ${errorMessage}`);
             throw error;
         }