ccmanager 3.2.5 → 3.2.7

package/README.md

@@ -20,6 +20,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Configurable state detection strategies for different CLI tools
 - Status change hooks for automation and notifications
 - Devcontainer integration
+- **Auto Approval (experimental)**: Automatically approve safe prompts using AI verification
 
 ## Why CCManager over Claude Squad?
 
@@ -249,6 +250,25 @@ CCManager can automatically generate worktree directory paths based on branch na
 
 For detailed configuration and examples, see [docs/worktree-auto-directory.md](docs/worktree-auto-directory.md).
 
+## Auto Approval (Experimental)
+
+CCManager can automatically approve Claude Code prompts that don't require user permission, reducing manual intervention while maintaining safety for sensitive operations.
+
+### Features
+
+- **Automatic decision**: Uses Claude (Haiku) to analyze prompts and determine if they need manual approval
+- **Custom commands**: Replace the default verifier with your own script or different AI model
+- **Safe fallback**: Always defaults to manual approval on errors or timeouts
+- **Interruptible**: Press any key to cancel auto-approval and review manually
+
+### Quick Start
+
+1. Navigate to **Configuration** → **Other & Experimental**
+2. Enable **Auto Approval (experimental)**
+3. (Optional) Configure a custom command for verification
+
+For detailed configuration and usage, see [docs/auto-approval.md](docs/auto-approval.md).
+
 ## Devcontainer Integration
 
 CCManager supports running AI assistant sessions inside devcontainers while keeping the manager itself on the host machine. This enables sandboxed development environments with restricted network access while maintaining host-level notifications and automation.

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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.2.5",
+	"version": "3.2.7",
 	"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.5",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.5",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.5",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.2.5",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.2.5"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.2.7",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.7",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.7",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.2.7",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.2.7"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",