ccmanager 2.11.5 → 3.0.0

package/dist/services/sessionManager.js

@@ -9,8 +9,11 @@ import { createStateDetector } from './stateDetector.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';
+import { autoApprovalVerifier } from './autoApprovalVerifier.js';
+import { logger } from '../utils/logger.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
+const TERMINAL_CONTENT_MAX_LINES = 300;
 export class SessionManager extends EventEmitter {
     async spawn(command, args, worktreePath) {
         const spawnOptions = {
@@ -26,7 +29,104 @@ export class SessionManager extends EventEmitter {
         // Create a detector based on the session's detection strategy
         const strategy = session.detectionStrategy || 'claude';
         const detector = createStateDetector(strategy);
-        return detector.detectState(session.terminal, session.state);
+        const detectedState = detector.detectState(session.terminal, session.state);
+        // If auto-approval is enabled and state is waiting_input, convert to pending_auto_approval
+        if (detectedState === 'waiting_input' &&
+            configurationManager.isAutoApprovalEnabled() &&
+            !session.autoApprovalFailed) {
+            return 'pending_auto_approval';
+        }
+        return detectedState;
+    }
+    getTerminalContent(session) {
+        const buffer = session.terminal.buffer.active;
+        const lines = [];
+        // Start from the bottom and work our way up
+        for (let i = buffer.length - 1; i >= 0 && lines.length < TERMINAL_CONTENT_MAX_LINES; 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.join('\n');
+    }
+    handleAutoApproval(session) {
+        // Cancel any existing verification before starting a new one
+        this.cancelAutoApprovalVerification(session, 'Restarting verification for pending auto-approval state');
+        const abortController = new AbortController();
+        session.autoApprovalAbortController = abortController;
+        session.autoApprovalReason = undefined;
+        // Get terminal content for verification
+        const terminalContent = this.getTerminalContent(session);
+        // Verify if permission is needed
+        void Effect.runPromise(autoApprovalVerifier.verifyNeedsPermission(terminalContent, {
+            signal: abortController.signal,
+        }))
+            .then(autoApprovalResult => {
+            if (abortController.signal.aborted) {
+                logger.debug(`[${session.id}] Auto-approval verification aborted before completion`);
+                return;
+            }
+            // If state already moved away, skip handling
+            if (session.state !== 'pending_auto_approval') {
+                logger.debug(`[${session.id}] Skipping auto-approval handling; current state is ${session.state}`);
+                return;
+            }
+            if (autoApprovalResult.needsPermission) {
+                // Change state to waiting_input to ask for user permission
+                logger.info(`[${session.id}] Auto-approval verification determined user permission needed`);
+                session.state = 'waiting_input';
+                session.autoApprovalFailed = true;
+                session.autoApprovalReason = autoApprovalResult.reason;
+                session.pendingState = undefined;
+                session.pendingStateStart = undefined;
+                this.emit('sessionStateChanged', session);
+            }
+            else {
+                // Auto-approve by simulating Enter key press
+                logger.info(`[${session.id}] Auto-approval granted, simulating user permission`);
+                session.autoApprovalReason = undefined;
+                session.process.write('\r');
+            }
+        })
+            .catch((error) => {
+            if (abortController.signal.aborted) {
+                logger.debug(`[${session.id}] Auto-approval verification aborted (${error?.message ?? 'aborted'})`);
+                return;
+            }
+            // On failure, fall back to requiring explicit permission
+            logger.error(`[${session.id}] Auto-approval verification failed, requiring user permission`, error);
+            if (session.state === 'pending_auto_approval') {
+                session.state = 'waiting_input';
+                session.autoApprovalFailed = true;
+                session.autoApprovalReason =
+                    error?.message ??
+                        'Auto-approval verification failed';
+                session.pendingState = undefined;
+                session.pendingStateStart = undefined;
+                this.emit('sessionStateChanged', session);
+            }
+        })
+            .finally(() => {
+            if (session.autoApprovalAbortController === abortController) {
+                session.autoApprovalAbortController = undefined;
+            }
+        });
+    }
+    cancelAutoApprovalVerification(session, reason) {
+        const controller = session.autoApprovalAbortController;
+        if (!controller) {
+            return;
+        }
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+        session.autoApprovalAbortController = undefined;
+        logger.info(`[${session.id}] Cancelled auto-approval verification: ${reason}`);
     }
     constructor() {
         super();
@@ -81,6 +181,9 @@ export class SessionManager extends EventEmitter {
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             pendingState: undefined,
             pendingStateStart: undefined,
+            autoApprovalFailed: false,
+            autoApprovalReason: undefined,
+            autoApprovalAbortController: undefined,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -266,6 +369,22 @@ export class SessionManager extends EventEmitter {
                         session.state = detectedState;
                         session.pendingState = undefined;
                         session.pendingStateStart = undefined;
+                        if (session.autoApprovalAbortController &&
+                            detectedState !== 'pending_auto_approval') {
+                            this.cancelAutoApprovalVerification(session, `state changed to ${detectedState}`);
+                        }
+                        // If we previously blocked auto-approval and have moved out of a user prompt,
+                        // allow future auto-approval attempts.
+                        if (session.autoApprovalFailed &&
+                            detectedState !== 'waiting_input' &&
+                            detectedState !== 'pending_auto_approval') {
+                            session.autoApprovalFailed = false;
+                            session.autoApprovalReason = undefined;
+                        }
+                        // Handle auto-approval if state is pending_auto_approval
+                        if (detectedState === 'pending_auto_approval') {
+                            this.handleAutoApproval(session);
+                        }
                         // Execute status hook asynchronously (non-blocking) using Effect
                         void Effect.runPromise(executeStatusHook(oldState, detectedState, session));
                         this.emit('sessionStateChanged', session);
@@ -282,6 +401,9 @@ export class SessionManager extends EventEmitter {
         this.setupExitHandler(session);
     }
     cleanupSession(session) {
+        if (session.autoApprovalAbortController) {
+            this.cancelAutoApprovalVerification(session, 'Session cleanup');
+        }
         // Clear the state check interval
         if (session.stateCheckInterval) {
             clearInterval(session.stateCheckInterval);
@@ -313,9 +435,31 @@ export class SessionManager extends EventEmitter {
             }
         }
     }
+    cancelAutoApproval(worktreePath, reason = 'User input received') {
+        const session = this.sessions.get(worktreePath);
+        if (!session) {
+            return;
+        }
+        if (session.state !== 'pending_auto_approval' &&
+            !session.autoApprovalAbortController) {
+            return;
+        }
+        this.cancelAutoApprovalVerification(session, reason);
+        session.autoApprovalFailed = true;
+        session.autoApprovalReason = reason;
+        session.pendingState = undefined;
+        session.pendingStateStart = undefined;
+        if (session.state === 'pending_auto_approval') {
+            session.state = 'waiting_input';
+            this.emit('sessionStateChanged', session);
+        }
+    }
     destroySession(worktreePath) {
         const session = this.sessions.get(worktreePath);
         if (session) {
+            if (session.autoApprovalAbortController) {
+                this.cancelAutoApprovalVerification(session, 'Session destroyed');
+            }
             // Clear the state check interval
             if (session.stateCheckInterval) {
                 clearInterval(session.stateCheckInterval);
@@ -493,6 +637,7 @@ export class SessionManager extends EventEmitter {
             idle: 0,
             busy: 0,
             waiting_input: 0,
+            pending_auto_approval: 0,
             total: sessions.length,
         };
         sessions.forEach(session => {
@@ -506,6 +651,9 @@ export class SessionManager extends EventEmitter {
                 case 'waiting_input':
                     counts.waiting_input++;
                     break;
+                case 'pending_auto_approval':
+                    counts.pending_auto_approval++;
+                    break;
             }
         });
         return counts;

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

@@ -36,6 +36,8 @@ vi.mock('./configurationManager.js', () => ({
         setWorktreeLastOpened: vi.fn(),
         getWorktreeLastOpenedTime: vi.fn(),
         getWorktreeLastOpened: vi.fn(() => ({})),
+        isAutoApprovalEnabled: vi.fn(() => false),
+        setAutoApprovalEnabled: vi.fn(),
     },
 }));
 describe('SessionManager - State Persistence', () => {

package/dist/services/sessionManager.test.js

@@ -22,6 +22,8 @@ vi.mock('./configurationManager.js', () => ({
         setWorktreeLastOpened: vi.fn(),
         getWorktreeLastOpenedTime: vi.fn(),
         getWorktreeLastOpened: vi.fn(() => ({})),
+        isAutoApprovalEnabled: vi.fn(() => false),
+        setAutoApprovalEnabled: vi.fn(),
     },
 }));
 // Mock Terminal
@@ -743,6 +745,7 @@ describe('SessionManager', () => {
                     idle: 1,
                     busy: 2,
                     waiting_input: 1,
+                    pending_auto_approval: 0,
                     total: 4,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
@@ -753,6 +756,7 @@ describe('SessionManager', () => {
                     idle: 2,
                     busy: 0,
                     waiting_input: 1,
+                    pending_auto_approval: 0,
                     total: 3,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
@@ -763,6 +767,7 @@ describe('SessionManager', () => {
                     idle: 0,
                     busy: 3,
                     waiting_input: 0,
+                    pending_auto_approval: 0,
                     total: 3,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);
@@ -773,6 +778,7 @@ describe('SessionManager', () => {
                     idle: 0,
                     busy: 0,
                     waiting_input: 0,
+                    pending_auto_approval: 0,
                     total: 0,
                 };
                 const formatted = SessionManager.formatSessionCounts(counts);

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@ import { IPty } from 'node-pty';
 import type pkg from '@xterm/headless';
 import { GitStatus } from '../utils/gitStatus.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
-export type SessionState = 'idle' | 'busy' | 'waiting_input';
+export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
 export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline';
 export interface Worktree {
     path: string;
@@ -29,12 +29,20 @@ export interface Session {
     devcontainerConfig: DevcontainerConfig | undefined;
     pendingState: SessionState | undefined;
     pendingStateStart: number | undefined;
+    autoApprovalFailed: boolean;
+    autoApprovalReason?: string;
+    autoApprovalAbortController?: AbortController;
+}
+export interface AutoApprovalResponse {
+    needsPermission: boolean;
+    reason?: string;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
     getSession(worktreePath: string): Session | undefined;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
+    cancelAutoApproval(worktreePath: string, reason?: string): void;
 }
 export interface ShortcutKey {
     ctrl?: boolean;
@@ -55,6 +63,7 @@ export interface StatusHookConfig {
     idle?: StatusHook;
     busy?: StatusHook;
     waiting_input?: StatusHook;
+    pending_auto_approval?: StatusHook;
 }
 export interface WorktreeHook {
     command: string;
@@ -98,6 +107,10 @@ export interface ConfigurationData {
     worktree?: WorktreeConfig;
     command?: CommandConfig;
     commandPresets?: CommandPresetsConfig;
+    autoApproval?: {
+        enabled: boolean;
+        customCommand?: string;
+    };
 }
 export interface GitProject {
     name: string;

package/dist/utils/hookExecutor.test.js

@@ -272,6 +272,7 @@ describe('hookExecutor Integration Tests', () => {
                 pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
+                autoApprovalFailed: false,
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -292,6 +293,7 @@ describe('hookExecutor Integration Tests', () => {
                 },
                 idle: { enabled: false, command: '' },
                 waiting_input: { enabled: false, command: '' },
+                pending_auto_approval: { enabled: false, command: '' },
             });
             try {
                 // Act - execute the hook and await it
@@ -325,6 +327,7 @@ describe('hookExecutor Integration Tests', () => {
                 pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
+                autoApprovalFailed: false,
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -345,6 +348,7 @@ describe('hookExecutor Integration Tests', () => {
                 },
                 idle: { enabled: false, command: '' },
                 waiting_input: { enabled: false, command: '' },
+                pending_auto_approval: { enabled: false, command: '' },
             });
             try {
                 // Act & Assert - should not throw even when hook fails
@@ -376,6 +380,7 @@ describe('hookExecutor Integration Tests', () => {
                 pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
+                autoApprovalFailed: false,
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -396,6 +401,7 @@ describe('hookExecutor Integration Tests', () => {
                 },
                 idle: { enabled: false, command: '' },
                 waiting_input: { enabled: false, command: '' },
+                pending_auto_approval: { enabled: false, command: '' },
             });
             try {
                 // Act
@@ -429,6 +435,7 @@ describe('hookExecutor Integration Tests', () => {
                 pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
+                autoApprovalFailed: false,
             };
             // Mock WorktreeService to fail with GitError
             vi.mocked(WorktreeService).mockImplementation(() => ({
@@ -446,6 +453,7 @@ describe('hookExecutor Integration Tests', () => {
                 },
                 idle: { enabled: false, command: '' },
                 waiting_input: { enabled: false, command: '' },
+                pending_auto_approval: { enabled: false, command: '' },
             });
             try {
                 // Act - should not throw even when getWorktreesEffect fails

package/dist/utils/logger.d.ts

@@ -1,14 +1,83 @@
-export declare const log: {
-    log: (...args: unknown[]) => void;
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-};
-export declare const logger: {
-    log: (...args: unknown[]) => void;
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-};
+/**
+ * Logger configuration with size management and log rotation
+ */
+interface LoggerConfig {
+    /** Maximum log file size in bytes (default: 5MB) */
+    maxSizeBytes: number;
+    /** Number of old logs to keep (default: 3) */
+    maxRotatedFiles: number;
+    /** Enable console output for errors (default: true) */
+    logErrorsToConsole: boolean;
+}
+/**
+ * CLI-optimized logger with size management and rotation
+ *
+ * Features:
+ * - Automatic log rotation when file exceeds max size
+ * - Configurable retention (3 rotated files by default)
+ * - Atomic write operations to prevent corruption
+ * - Platform-aware log location (respects XDG_STATE_HOME on Linux)
+ * - Detailed timestamps and structured log lines
+ * - Sensitive information filtering on console output
+ */
+declare class Logger {
+    private readonly logFile;
+    private readonly config;
+    private writeQueue;
+    private isWriting;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Resolve log file path following XDG Base Directory specification
+     * and respecting environment overrides for testing
+     */
+    private resolveLogPath;
+    /**
+     * Initialize log file and ensure directory exists
+     */
+    private initializeLogFile;
+    /**
+     * Check if log file exceeds size limit and rotate if needed
+     */
+    private rotateLogIfNeeded;
+    /**
+     * Queue write operation to prevent concurrent writes
+     * This ensures log file integrity with atomic operations
+     */
+    private queueWrite;
+    /**
+     * Process write queue sequentially to prevent concurrent writes
+     */
+    private processQueue;
+    /**
+     * Write log entry with level and formatted message
+     */
+    private writeLog;
+    /**
+     * Get the path to the current log file
+     * Useful for users to locate and inspect logs
+     */
+    getLogPath(): string;
+    /**
+     * Log entry at LOG level (general information)
+     */
+    log(...args: unknown[]): void;
+    /**
+     * Log entry at INFO level (significant events)
+     */
+    info(...args: unknown[]): void;
+    /**
+     * Log entry at WARN level (potentially harmful situations)
+     */
+    warn(...args: unknown[]): void;
+    /**
+     * Log entry at ERROR level (error conditions)
+     */
+    error(...args: unknown[]): void;
+    /**
+     * Log entry at DEBUG level (detailed diagnostic information)
+     * Only written to file, not to console
+     */
+    debug(...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export {};