ccmanager 3.2.6 → 3.2.8

package/README.md

@@ -44,30 +44,12 @@ Claude Squad doesn't show session states in its menu, making it hard to know whi
 ### 🎯 Simple and intuitive interface
 Following Claude Code's philosophy, CCManager keeps things minimal and intuitive. The interface is so simple you'll understand it in seconds - no manual needed.
 
-## Requirements
-
-- **Node.js 22 or later** is required to run CCManager.
-
 ## Install
 
 ```bash
 npm install -g ccmanager
 ```
 
-### Using mise
-
-If you use [mise](https://mise.jdx.dev/) as a version manager, you can install CCManager with:
-
-```bash
-mise install npm:ccmanager && mise use -g npm:ccmanager
-```
-
-To run CCManager with Node.js 22:
-
-```bash
-mise exec node@22 -- ccmanager
-```
-
 ### Local Development
 
 ```bash

package/dist/services/sessionManager.autoApproval.test.js

@@ -14,7 +14,7 @@ vi.mock('./bunTerminal.js', () => ({
         return null;
     }),
 }));
-vi.mock('./stateDetector.js', () => ({
+vi.mock('./stateDetector/index.js', () => ({
     createStateDetector: () => ({ detectState: detectStateMock }),
 }));
 vi.mock('./configurationManager.js', () => ({

package/dist/services/sessionManager.d.ts

@@ -18,6 +18,15 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private getTerminalContent;
     private handleAutoApproval;
     private cancelAutoApprovalVerification;
+    /**
+     * Update session state with automatic status hook execution.
+     * This method ensures that executeStatusHook is always called when state changes.
+     *
+     * @param session - The session to update
+     * @param newState - The new state to set
+     * @param additionalUpdates - Optional additional state data updates
+     */
+    private updateSessionState;
     constructor();
     private createSessionId;
     private createTerminal;

package/dist/services/sessionManager.js

@@ -5,7 +5,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
-import { createStateDetector } from './stateDetector.js';
+import { createStateDetector } from './stateDetector/index.js';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
 import { Effect } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
@@ -85,15 +85,10 @@ export class SessionManager extends EventEmitter {
             if (autoApprovalResult.needsPermission) {
                 // Change state to waiting_input to ask for user permission
                 logger.info(`[${session.id}] Auto-approval verification determined user permission needed`);
-                await session.stateMutex.update(data => ({
-                    ...data,
-                    state: 'waiting_input',
+                await this.updateSessionState(session, 'waiting_input', {
                     autoApprovalFailed: true,
                     autoApprovalReason: autoApprovalResult.reason,
-                    pendingState: undefined,
-                    pendingStateStart: undefined,
-                }));
-                this.emit('sessionStateChanged', session);
+                });
             }
             else {
                 // Auto-approve by simulating Enter key press
@@ -101,14 +96,9 @@ export class SessionManager extends EventEmitter {
                 session.process.write('\r');
                 // Force state to busy to prevent endless auto-approval
                 // when the state detection still sees pending_auto_approval
-                await session.stateMutex.update(data => ({
-                    ...data,
-                    state: 'busy',
+                await this.updateSessionState(session, 'busy', {
                     autoApprovalReason: undefined,
-                    pendingState: undefined,
-                    pendingStateStart: undefined,
-                }));
-                this.emit('sessionStateChanged', session);
+                });
             }
         })
             .catch(async (error) => {
@@ -120,16 +110,11 @@ export class SessionManager extends EventEmitter {
             logger.error(`[${session.id}] Auto-approval verification failed, requiring user permission`, error);
             const currentState = session.stateMutex.getSnapshot().state;
             if (currentState === 'pending_auto_approval') {
-                await session.stateMutex.update(data => ({
-                    ...data,
-                    state: 'waiting_input',
+                await this.updateSessionState(session, 'waiting_input', {
                     autoApprovalFailed: true,
                     autoApprovalReason: error?.message ??
                         'Auto-approval verification failed',
-                    pendingState: undefined,
-                    pendingStateStart: undefined,
-                }));
-                this.emit('sessionStateChanged', session);
+                });
             }
         })
             .finally(async () => {
@@ -157,6 +142,28 @@ export class SessionManager extends EventEmitter {
         }));
         logger.info(`[${session.id}] Cancelled auto-approval verification: ${reason}`);
     }
+    /**
+     * Update session state with automatic status hook execution.
+     * This method ensures that executeStatusHook is always called when state changes.
+     *
+     * @param session - The session to update
+     * @param newState - The new state to set
+     * @param additionalUpdates - Optional additional state data updates
+     */
+    async updateSessionState(session, newState, additionalUpdates = {}) {
+        const oldState = session.stateMutex.getSnapshot().state;
+        await session.stateMutex.update(data => ({
+            ...data,
+            state: newState,
+            pendingState: undefined,
+            pendingStateStart: undefined,
+            ...additionalUpdates,
+        }));
+        if (oldState !== newState) {
+            void Effect.runPromise(executeStatusHook(oldState, newState, session));
+            this.emit('sessionStateChanged', session);
+        }
+    }
     constructor() {
         super();
         Object.defineProperty(this, "sessions", {
@@ -393,31 +400,23 @@ export class SessionManager extends EventEmitter {
                     // Check if the pending state has persisted long enough
                     const duration = now - stateData.pendingStateStart;
                     if (duration >= STATE_PERSISTENCE_DURATION_MS) {
-                        // Confirm the state change
-                        void session.stateMutex.update(data => {
-                            const newData = {
-                                ...data,
-                                state: detectedState,
-                                pendingState: undefined,
-                                pendingStateStart: undefined,
-                            };
-                            // If we previously blocked auto-approval and have moved out of a user prompt,
-                            // allow future auto-approval attempts.
-                            if (data.autoApprovalFailed &&
-                                detectedState !== 'waiting_input' &&
-                                detectedState !== 'pending_auto_approval') {
-                                newData.autoApprovalFailed = false;
-                                newData.autoApprovalReason = undefined;
-                            }
-                            return newData;
-                        });
+                        // Cancel auto-approval verification if state is changing away from pending_auto_approval
                         if (stateData.autoApprovalAbortController &&
                             detectedState !== 'pending_auto_approval') {
                             this.cancelAutoApprovalVerification(session, `state changed to ${detectedState}`);
                         }
-                        // Execute status hook asynchronously (non-blocking) using Effect
-                        void Effect.runPromise(executeStatusHook(oldState, detectedState, session));
-                        this.emit('sessionStateChanged', session);
+                        // Build additional updates for auto-approval reset
+                        const additionalUpdates = {};
+                        // If we previously blocked auto-approval and have moved out of a user prompt,
+                        // allow future auto-approval attempts.
+                        if (stateData.autoApprovalFailed &&
+                            detectedState !== 'waiting_input' &&
+                            detectedState !== 'pending_auto_approval') {
+                            additionalUpdates.autoApprovalFailed = false;
+                            additionalUpdates.autoApprovalReason = undefined;
+                        }
+                        // Confirm the state change with hook execution
+                        void this.updateSessionState(session, detectedState, additionalUpdates);
                     }
                 }
             }
@@ -452,13 +451,7 @@ export class SessionManager extends EventEmitter {
             session.stateCheckInterval = undefined;
         }
         // Clear any pending state and update state to idle before destroying
-        void session.stateMutex.update(data => ({
-            ...data,
-            state: 'idle',
-            pendingState: undefined,
-            pendingStateStart: undefined,
-        }));
-        this.emit('sessionStateChanged', session);
+        void this.updateSessionState(session, 'idle');
         this.destroySession(session.worktreePath);
         this.emit('sessionExit', session);
     }
@@ -490,21 +483,22 @@ export class SessionManager extends EventEmitter {
             return;
         }
         this.cancelAutoApprovalVerification(session, reason);
-        void session.stateMutex.update(data => {
-            const newData = {
+        if (stateData.state === 'pending_auto_approval') {
+            // State change: pending_auto_approval -> waiting_input
+            void this.updateSessionState(session, 'waiting_input', {
+                autoApprovalFailed: true,
+                autoApprovalReason: reason,
+            });
+        }
+        else {
+            // No state change, just update other fields
+            void session.stateMutex.update(data => ({
                 ...data,
                 autoApprovalFailed: true,
                 autoApprovalReason: reason,
                 pendingState: undefined,
                 pendingStateStart: undefined,
-            };
-            if (data.state === 'pending_auto_approval') {
-                newData.state = 'waiting_input';
-            }
-            return newData;
-        });
-        if (stateData.state === 'pending_auto_approval') {
-            this.emit('sessionStateChanged', session);
+            }));
         }
     }
     destroySession(worktreePath) {

package/dist/services/stateDetector/base.d.ts

@@ -0,0 +1,7 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { StateDetector } from './types.js';
+export declare abstract class BaseStateDetector implements StateDetector {
+    abstract detectState(terminal: Terminal, currentState: SessionState): SessionState;
+    protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
+    protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
+}

package/dist/services/stateDetector/base.js

@@ -0,0 +1,21 @@
+export class BaseStateDetector {
+    getTerminalLines(terminal, maxLines = 30) {
+        const buffer = terminal.buffer.active;
+        const lines = [];
+        // Start from the bottom and work our way up
+        for (let i = buffer.length - 1; i >= 0 && lines.length < maxLines; i--) {
+            const line = buffer.getLine(i);
+            if (line) {
+                const text = line.translateToString(true);
+                // Skip empty lines at the bottom
+                if (lines.length > 0 || text.trim() !== '') {
+                    lines.unshift(text);
+                }
+            }
+        }
+        return lines;
+    }
+    getTerminalContent(terminal, maxLines = 30) {
+        return this.getTerminalLines(terminal, maxLines).join('\n');
+    }
+}

package/dist/services/stateDetector/claude.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class ClaudeStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/claude.js

@@ -0,0 +1,26 @@
+import { BaseStateDetector } from './base.js';
+export class ClaudeStateDetector extends BaseStateDetector {
+    detectState(terminal, currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for ctrl+r toggle prompt - maintain current state
+        if (lowerContent.includes('ctrl+r to toggle')) {
+            return currentState;
+        }
+        // Check for "Do you want" or "Would you like" pattern with options
+        // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
+        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for "esc to cancel" - indicates waiting for user input
+        if (lowerContent.includes('esc to cancel')) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (lowerContent.includes('esc to interrupt')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

package/dist/services/{__tests__/stateDetector.claude.test.js → stateDetector/claude.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { ClaudeStateDetector } from '../stateDetector.js';
+import { ClaudeStateDetector } from './claude.js';
 import { createMockTerminal } from './testUtils.js';
 describe('ClaudeStateDetector', () => {
     let detector;
@@ -167,5 +167,48 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect waiting_input when "Yes" has characters before it (e.g., "❯ 1. Yes")', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Do you want to continue?',
+                '❯ 1. Yes',
+                '  2. No',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "esc to cancel" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Enter your message:',
+                'Press esc to cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "esc to cancel" is present (case insensitive)', () => {
+            // Arrange
+            terminal = createMockTerminal(['Waiting for input', 'ESC TO CANCEL']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should prioritize "esc to cancel" over "esc to interrupt" when both present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Press esc to interrupt',
+                'Some input prompt',
+                'Press esc to cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
     });
 });

package/dist/services/stateDetector/cline.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class ClineStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/cline.js

@@ -0,0 +1,24 @@
+import { BaseStateDetector } from './base.js';
+// https://github.com/cline/cline/blob/580db36476b6b52def03c8aeda325aae1c817cde/cli/pkg/cli/task/input_handler.go
+export class ClineStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts with tool permission - Priority 1
+        // Pattern: [\[act|plan\] mode].*?\n.*yes (when mode indicator present)
+        // Or simply: let cline use this tool (distinctive text)
+        if (/\[(act|plan) mode\].*?\n.*yes/i.test(lowerContent) ||
+            /let cline use this tool/i.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for idle state - Priority 2
+        // Pattern: [\[act|plan\] mode].*Cline is ready for your message... (when mode indicator present)
+        // Or simply: cline is ready for your message (distinctive text)
+        if (/\[(act|plan) mode\].*cline is ready for your message/i.test(lowerContent) ||
+            /cline is ready for your message/i.test(lowerContent)) {
+            return 'idle';
+        }
+        // Otherwise busy - Priority 3
+        return 'busy';
+    }
+}

package/dist/services/{__tests__/stateDetector.cline.test.js → stateDetector/cline.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { ClineStateDetector } from '../stateDetector.js';
+import { ClineStateDetector } from './cline.js';
 import { createMockTerminal } from './testUtils.js';
 describe('ClineStateDetector', () => {
     let detector;

package/dist/services/stateDetector/codex.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class CodexStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/codex.js

@@ -0,0 +1,27 @@
+import { BaseStateDetector } from './base.js';
+export class CodexStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for confirmation prompt patterns - highest priority
+        if (lowerContent.includes('press enter to confirm or esc to cancel') ||
+            /confirm with .+ enter/i.test(content)) {
+            return 'waiting_input';
+        }
+        // Check for waiting prompts
+        if (lowerContent.includes('allow command?') ||
+            lowerContent.includes('[y/n]') ||
+            lowerContent.includes('yes (y)')) {
+            return 'waiting_input';
+        }
+        if (/(do you want|would you like)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (/esc.*interrupt/i.test(lowerContent)) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

package/dist/services/{__tests__/stateDetector.codex.test.js → stateDetector/codex.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { CodexStateDetector } from '../stateDetector.js';
+import { CodexStateDetector } from './codex.js';
 import { createMockTerminal } from './testUtils.js';
 describe('CodexStateDetector', () => {
     let detector;

package/dist/services/stateDetector/cursor.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class CursorStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/cursor.js

@@ -0,0 +1,19 @@
+import { BaseStateDetector } from './base.js';
+export class CursorStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts - Priority 1
+        if (lowerContent.includes('(y) (enter)') ||
+            lowerContent.includes('keep (n)') ||
+            /auto .* \(shift\+tab\)/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for busy state - Priority 2
+        if (lowerContent.includes('ctrl+c to stop')) {
+            return 'busy';
+        }
+        // Otherwise idle - Priority 3
+        return 'idle';
+    }
+}

package/dist/services/{__tests__/stateDetector.cursor.test.js → stateDetector/cursor.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { CursorStateDetector } from '../stateDetector.js';
+import { CursorStateDetector } from './cursor.js';
 import { createMockTerminal } from './testUtils.js';
 describe('CursorStateDetector', () => {
     let detector;

package/dist/services/stateDetector/gemini.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class GeminiStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/gemini.js

@@ -0,0 +1,28 @@
+import { BaseStateDetector } from './base.js';
+// https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
+export class GeminiStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for explicit user confirmation message - highest priority
+        if (lowerContent.includes('waiting for user confirmation')) {
+            return 'waiting_input';
+        }
+        // Check for waiting prompts with box character
+        if (content.includes('│ Apply this change') ||
+            content.includes('│ Allow execution') ||
+            content.includes('│ Do you want to proceed')) {
+            return 'waiting_input';
+        }
+        // Check for multiline confirmation prompts ending with "yes"
+        if (/(allow execution|do you want to|apply this change)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for busy state
+        if (lowerContent.includes('esc to cancel')) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

package/dist/services/{__tests__/stateDetector.gemini.test.js → stateDetector/gemini.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { GeminiStateDetector } from '../stateDetector.js';
+import { GeminiStateDetector } from './gemini.js';
 import { createMockTerminal } from './testUtils.js';
 describe('GeminiStateDetector', () => {
     let detector;

package/dist/services/stateDetector/github-copilot.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class GitHubCopilotStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/github-copilot.js

@@ -0,0 +1,21 @@
+import { BaseStateDetector } from './base.js';
+export class GitHubCopilotStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        const lowerContent = content.toLowerCase();
+        // Check for confirmation prompt pattern - highest priority
+        if (/confirm with .+ enter/i.test(content)) {
+            return 'waiting_input';
+        }
+        // Waiting prompt has priority 2
+        if (lowerContent.includes('│ do you want')) {
+            return 'waiting_input';
+        }
+        // Busy state detection has priority 3
+        if (lowerContent.includes('esc to cancel')) {
+            return 'busy';
+        }
+        // Otherwise idle as priority 4
+        return 'idle';
+    }
+}

package/dist/services/{__tests__/stateDetector.github-copilot.test.js → stateDetector/github-copilot.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { GitHubCopilotStateDetector } from '../stateDetector.js';
+import { GitHubCopilotStateDetector } from './github-copilot.js';
 import { createMockTerminal } from './testUtils.js';
 describe('GitHubCopilotStateDetector', () => {
     let detector;

package/dist/services/stateDetector/index.d.ts

@@ -0,0 +1,3 @@
+import { StateDetectionStrategy } from '../../types/index.js';
+import { StateDetector } from './types.js';
+export declare function createStateDetector(strategy?: StateDetectionStrategy): StateDetector;

package/dist/services/stateDetector/index.js

@@ -0,0 +1,24 @@
+import { ClaudeStateDetector } from './claude.js';
+import { GeminiStateDetector } from './gemini.js';
+import { CodexStateDetector } from './codex.js';
+import { CursorStateDetector } from './cursor.js';
+import { GitHubCopilotStateDetector } from './github-copilot.js';
+import { ClineStateDetector } from './cline.js';
+export function createStateDetector(strategy = 'claude') {
+    switch (strategy) {
+        case 'claude':
+            return new ClaudeStateDetector();
+        case 'gemini':
+            return new GeminiStateDetector();
+        case 'codex':
+            return new CodexStateDetector();
+        case 'cursor':
+            return new CursorStateDetector();
+        case 'github-copilot':
+            return new GitHubCopilotStateDetector();
+        case 'cline':
+            return new ClineStateDetector();
+        default:
+            return new ClaudeStateDetector();
+    }
+}

package/dist/services/stateDetector/types.d.ts

@@ -0,0 +1,4 @@
+import { SessionState, Terminal } from '../../types/index.js';
+export interface StateDetector {
+    detectState(terminal: Terminal, currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.2.6",
+	"version": "3.2.8",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.2.6",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.6",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.6",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.2.6",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.2.6"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.2.8",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.8",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.8",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.2.8",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.2.8"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",

package/dist/services/stateDetector.d.ts

@@ -1,28 +0,0 @@
-import { SessionState, Terminal, StateDetectionStrategy } from '../types/index.js';
-export interface StateDetector {
-    detectState(terminal: Terminal, currentState: SessionState): SessionState;
-}
-export declare function createStateDetector(strategy?: StateDetectionStrategy): StateDetector;
-export declare abstract class BaseStateDetector implements StateDetector {
-    abstract detectState(terminal: Terminal, currentState: SessionState): SessionState;
-    protected getTerminalLines(terminal: Terminal, maxLines?: number): string[];
-    protected getTerminalContent(terminal: Terminal, maxLines?: number): string;
-}
-export declare class ClaudeStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, currentState: SessionState): SessionState;
-}
-export declare class GeminiStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
-}
-export declare class CodexStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
-}
-export declare class CursorStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
-}
-export declare class GitHubCopilotStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
-}
-export declare class ClineStateDetector extends BaseStateDetector {
-    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
-}

package/dist/services/stateDetector.js

@@ -1,174 +0,0 @@
-export function createStateDetector(strategy = 'claude') {
-    switch (strategy) {
-        case 'claude':
-            return new ClaudeStateDetector();
-        case 'gemini':
-            return new GeminiStateDetector();
-        case 'codex':
-            return new CodexStateDetector();
-        case 'cursor':
-            return new CursorStateDetector();
-        case 'github-copilot':
-            return new GitHubCopilotStateDetector();
-        case 'cline':
-            return new ClineStateDetector();
-        default:
-            return new ClaudeStateDetector();
-    }
-}
-export class BaseStateDetector {
-    getTerminalLines(terminal, maxLines = 30) {
-        const buffer = terminal.buffer.active;
-        const lines = [];
-        // Start from the bottom and work our way up
-        for (let i = buffer.length - 1; i >= 0 && lines.length < maxLines; i--) {
-            const line = buffer.getLine(i);
-            if (line) {
-                const text = line.translateToString(true);
-                // Skip empty lines at the bottom
-                if (lines.length > 0 || text.trim() !== '') {
-                    lines.unshift(text);
-                }
-            }
-        }
-        return lines;
-    }
-    getTerminalContent(terminal, maxLines = 30) {
-        return this.getTerminalLines(terminal, maxLines).join('\n');
-    }
-}
-export class ClaudeStateDetector extends BaseStateDetector {
-    detectState(terminal, currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for ctrl+r toggle prompt - maintain current state
-        if (lowerContent.includes('ctrl+r to toggle')) {
-            return currentState;
-        }
-        // Check for "Do you want" or "Would you like" pattern with options
-        // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
-        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {
-            return 'waiting_input';
-        }
-        // Check for busy state
-        if (lowerContent.includes('esc to interrupt')) {
-            return 'busy';
-        }
-        // Otherwise idle
-        return 'idle';
-    }
-}
-// https://github.com/google-gemini/gemini-cli/blob/main/packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx
-export class GeminiStateDetector extends BaseStateDetector {
-    detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for explicit user confirmation message - highest priority
-        if (lowerContent.includes('waiting for user confirmation')) {
-            return 'waiting_input';
-        }
-        // Check for waiting prompts with box character
-        if (content.includes('│ Apply this change') ||
-            content.includes('│ Allow execution') ||
-            content.includes('│ Do you want to proceed')) {
-            return 'waiting_input';
-        }
-        // Check for multiline confirmation prompts ending with "yes"
-        if (/(allow execution|do you want to|apply this change)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {
-            return 'waiting_input';
-        }
-        // Check for busy state
-        if (lowerContent.includes('esc to cancel')) {
-            return 'busy';
-        }
-        // Otherwise idle
-        return 'idle';
-    }
-}
-export class CodexStateDetector extends BaseStateDetector {
-    detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for confirmation prompt patterns - highest priority
-        if (lowerContent.includes('press enter to confirm or esc to cancel') ||
-            /confirm with .+ enter/i.test(content)) {
-            return 'waiting_input';
-        }
-        // Check for waiting prompts
-        if (lowerContent.includes('allow command?') ||
-            lowerContent.includes('[y/n]') ||
-            lowerContent.includes('yes (y)')) {
-            return 'waiting_input';
-        }
-        if (/(do you want|would you like)[\s\S]*?\n+[\s\S]*?\byes\b/.test(lowerContent)) {
-            return 'waiting_input';
-        }
-        // Check for busy state
-        if (/esc.*interrupt/i.test(lowerContent)) {
-            return 'busy';
-        }
-        // Otherwise idle
-        return 'idle';
-    }
-}
-export class CursorStateDetector extends BaseStateDetector {
-    detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for waiting prompts - Priority 1
-        if (lowerContent.includes('(y) (enter)') ||
-            lowerContent.includes('keep (n)') ||
-            /auto .* \(shift\+tab\)/.test(lowerContent)) {
-            return 'waiting_input';
-        }
-        // Check for busy state - Priority 2
-        if (lowerContent.includes('ctrl+c to stop')) {
-            return 'busy';
-        }
-        // Otherwise idle - Priority 3
-        return 'idle';
-    }
-}
-export class GitHubCopilotStateDetector extends BaseStateDetector {
-    detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for confirmation prompt pattern - highest priority
-        if (/confirm with .+ enter/i.test(content)) {
-            return 'waiting_input';
-        }
-        // Waiting prompt has priority 2
-        if (lowerContent.includes('│ do you want')) {
-            return 'waiting_input';
-        }
-        // Busy state detection has priority 3
-        if (lowerContent.includes('esc to cancel')) {
-            return 'busy';
-        }
-        // Otherwise idle as priority 4
-        return 'idle';
-    }
-}
-// https://github.com/cline/cline/blob/580db36476b6b52def03c8aeda325aae1c817cde/cli/pkg/cli/task/input_handler.go
-export class ClineStateDetector extends BaseStateDetector {
-    detectState(terminal, _currentState) {
-        const content = this.getTerminalContent(terminal);
-        const lowerContent = content.toLowerCase();
-        // Check for waiting prompts with tool permission - Priority 1
-        // Pattern: [\[act|plan\] mode].*?\n.*yes (when mode indicator present)
-        // Or simply: let cline use this tool (distinctive text)
-        if (/\[(act|plan) mode\].*?\n.*yes/i.test(lowerContent) ||
-            /let cline use this tool/i.test(lowerContent)) {
-            return 'waiting_input';
-        }
-        // Check for idle state - Priority 2
-        // Pattern: [\[act|plan\] mode].*Cline is ready for your message... (when mode indicator present)
-        // Or simply: cline is ready for your message (distinctive text)
-        if (/\[(act|plan) mode\].*cline is ready for your message/i.test(lowerContent) ||
-            /cline is ready for your message/i.test(lowerContent)) {
-            return 'idle';
-        }
-        // Otherwise busy - Priority 3
-        return 'busy';
-    }
-}