ccmanager 2.2.0 → 2.2.1

package/dist/constants/statePersistence.d.ts

@@ -0,0 +1,2 @@
+export declare const STATE_PERSISTENCE_DURATION_MS = 200;
+export declare const STATE_CHECK_INTERVAL_MS = 100;

package/dist/constants/statePersistence.js

@@ -0,0 +1,4 @@
+// Duration in milliseconds that a detected state must persist before being confirmed
+export const STATE_PERSISTENCE_DURATION_MS = 200;
+// Check interval for state detection in milliseconds
+export const STATE_CHECK_INTERVAL_MS = 100;

package/dist/services/sessionManager.js

@@ -6,6 +6,7 @@ import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 export class SessionManager extends EventEmitter {
@@ -71,10 +72,13 @@ export class SessionManager extends EventEmitter {
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             commandConfig,
             detectionStrategy: options.detectionStrategy ?? 'claude',
-            devcontainerConfig: options.devcontainerConfig,
+            devcontainerConfig: options.devcontainerConfig ?? undefined,
+            pendingState: undefined,
+            pendingStateStart: undefined,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -188,16 +192,39 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
+        // Set up interval-based state detection with persistence
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
-            const newState = this.detectTerminalState(session);
-            if (newState !== oldState) {
-                session.state = newState;
-                // Execute status hook asynchronously (non-blocking)
-                void executeStatusHook(oldState, newState, session);
-                this.emit('sessionStateChanged', session);
+            const detectedState = this.detectTerminalState(session);
+            const now = Date.now();
+            // If detected state is different from current state
+            if (detectedState !== oldState) {
+                // If this is a new pending state or the pending state changed
+                if (session.pendingState !== detectedState) {
+                    session.pendingState = detectedState;
+                    session.pendingStateStart = now;
+                }
+                else if (session.pendingState !== undefined &&
+                    session.pendingStateStart !== undefined) {
+                    // Check if the pending state has persisted long enough
+                    const duration = now - session.pendingStateStart;
+                    if (duration >= STATE_PERSISTENCE_DURATION_MS) {
+                        // Confirm the state change
+                        session.state = detectedState;
+                        session.pendingState = undefined;
+                        session.pendingStateStart = undefined;
+                        // Execute status hook asynchronously (non-blocking)
+                        void executeStatusHook(oldState, detectedState, session);
+                        this.emit('sessionStateChanged', session);
+                    }
+                }
+            }
+            else {
+                // Detected state matches current state, clear any pending state
+                session.pendingState = undefined;
+                session.pendingStateStart = undefined;
             }
-        }, 100); // Check every 100ms
+        }, STATE_CHECK_INTERVAL_MS);
         // Setup exit handler
         this.setupExitHandler(session);
     }
@@ -205,7 +232,11 @@ export class SessionManager extends EventEmitter {
         // Clear the state check interval
         if (session.stateCheckInterval) {
             clearInterval(session.stateCheckInterval);
+            session.stateCheckInterval = undefined;
         }
+        // Clear any pending state
+        session.pendingState = undefined;
+        session.pendingStateStart = undefined;
         // Update state to idle before destroying
         session.state = 'idle';
         this.emit('sessionStateChanged', session);

package/dist/services/sessionManager.statePersistence.test.d.ts

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

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

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+import { EventEmitter } from 'events';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+vi.mock('node-pty');
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getConfig: vi.fn().mockReturnValue({
+            commands: [
+                {
+                    id: 'test',
+                    name: 'Test',
+                    command: 'test',
+                    args: [],
+                },
+            ],
+            defaultCommandId: 'test',
+        }),
+        getPresetById: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getDefaultPreset: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getHooks: vi.fn().mockReturnValue({}),
+        getStatusHooks: vi.fn().mockReturnValue({}),
+    },
+}));
+describe('SessionManager - State Persistence', () => {
+    let sessionManager;
+    let mockPtyInstances;
+    let eventEmitters;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        sessionManager = new SessionManager();
+        mockPtyInstances = new Map();
+        eventEmitters = new Map();
+        // Create mock PTY process factory
+        spawn.mockImplementation((command, args, options) => {
+            const path = options.cwd;
+            const eventEmitter = new EventEmitter();
+            eventEmitters.set(path, eventEmitter);
+            const mockPty = {
+                onData: vi.fn((callback) => {
+                    eventEmitter.on('data', callback);
+                    return { dispose: vi.fn() };
+                }),
+                onExit: vi.fn((callback) => {
+                    eventEmitter.on('exit', callback);
+                    return { dispose: vi.fn() };
+                }),
+                write: vi.fn(),
+                resize: vi.fn(),
+                kill: vi.fn(),
+                process: 'test',
+                pid: 12345 + mockPtyInstances.size,
+            };
+            mockPtyInstances.set(path, mockPty);
+            return mockPty;
+        });
+    });
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+        vi.clearAllMocks();
+    });
+    it('should not change state immediately when detected state changes', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // State should still be busy, but pending state should be set
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+    });
+    it('should change state after persistence duration is met', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+        // Advance time to exceed persistence duration
+        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        // State should now be changed
+        expect(session.state).toBe('idle');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+        expect(stateChangeHandler).toHaveBeenCalledWith(session);
+    });
+    it('should cancel pending state if detected state changes again before persistence', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        // Simulate output that would trigger waiting_input state
+        eventEmitter.emit('data', '│ Do you want to continue?');
+        // Advance time to trigger another check
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // Pending state should now be waiting_input, not idle
+        expect(session.state).toBe('busy'); // Still original state
+        expect(session.pendingState).toBe('waiting_input');
+    });
+    it('should clear pending state if detected state returns to current state', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+        // Simulate output that would trigger busy state again (back to original)
+        eventEmitter.emit('data', 'ESC to interrupt');
+        // Advance time to trigger another check
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // Pending state should be cleared
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+    });
+    it('should not confirm state changes that do not persist long enough', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Try to change to idle
+        eventEmitter.emit('data', 'Some idle output\n');
+        // Wait for detection but not full persistence (less than 200ms)
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Should have pending state but not confirmed
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBe('idle');
+        // Now change to a different state before idle persists
+        // Clear terminal first and add waiting prompt
+        eventEmitter.emit('data', '\x1b[2J\x1b[H│ Do you want to continue?\n');
+        // Advance time to detect new state but still less than persistence duration from first change
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // Another 100ms, total 200ms exactly at threshold
+        // Pending state should have changed to waiting_input
+        expect(session.state).toBe('busy'); // Still original state
+        expect(session.pendingState).toBe('waiting_input');
+        // Since states kept changing before persisting, no state change should have been confirmed
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
+    it('should properly clean up pending state when session is destroyed', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+        // Destroy the session
+        sessionManager.destroySession('/test/path');
+        // Check that pending state is cleared
+        const destroyedSession = sessionManager.getSession('/test/path');
+        expect(destroyedSession).toBeUndefined();
+    });
+    it('should handle multiple sessions with independent state persistence', async () => {
+        const session1 = await sessionManager.createSessionWithPreset('/test/path1');
+        const session2 = await sessionManager.createSessionWithPreset('/test/path2');
+        const eventEmitter1 = eventEmitters.get('/test/path1');
+        const eventEmitter2 = eventEmitters.get('/test/path2');
+        // Both should start as busy
+        expect(session1.state).toBe('busy');
+        expect(session2.state).toBe('busy');
+        // Simulate different outputs for each session
+        // Session 1 goes to idle
+        eventEmitter1.emit('data', 'Idle output for session 1');
+        // Session 2 goes to waiting_input
+        eventEmitter2.emit('data', '│ Do you want to continue?');
+        // Advance time to check but not confirm
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // Both should have pending states but not changed yet
+        expect(session1.state).toBe('busy');
+        expect(session1.pendingState).toBe('idle');
+        expect(session2.state).toBe('busy');
+        expect(session2.pendingState).toBe('waiting_input');
+        // Advance time to confirm both
+        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        // Both should now be in their new states
+        expect(session1.state).toBe('idle');
+        expect(session1.pendingState).toBeUndefined();
+        expect(session2.state).toBe('waiting_input');
+        expect(session2.pendingState).toBeUndefined();
+    });
+});

package/dist/types/index.d.ts

@@ -22,11 +22,13 @@ export interface Session {
     lastActivity: Date;
     isActive: boolean;
     terminal: Terminal;
-    stateCheckInterval?: NodeJS.Timeout;
-    isPrimaryCommand?: boolean;
-    commandConfig?: CommandConfig;
-    detectionStrategy?: StateDetectionStrategy;
-    devcontainerConfig?: DevcontainerConfig;
+    stateCheckInterval: NodeJS.Timeout | undefined;
+    isPrimaryCommand: boolean;
+    commandConfig: CommandConfig | undefined;
+    detectionStrategy: StateDetectionStrategy | undefined;
+    devcontainerConfig: DevcontainerConfig | undefined;
+    pendingState: SessionState | undefined;
+    pendingStateStart: number | undefined;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;

package/dist/utils/hookExecutor.test.js

@@ -257,6 +257,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };
@@ -304,6 +310,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };
@@ -349,6 +361,12 @@ describe('hookExecutor Integration Tests', () => {
                 outputHistory: [],
                 state: 'idle',
                 stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
             };

package/dist/utils/worktreeUtils.test.js

@@ -105,6 +105,13 @@ describe('prepareWorktreeItems', () => {
         lastActivity: new Date(),
         isActive: true,
         terminal: {},
+        stateCheckInterval: undefined,
+        isPrimaryCommand: true,
+        commandConfig: undefined,
+        detectionStrategy: 'claude',
+        devcontainerConfig: undefined,
+        pendingState: undefined,
+        pendingStateStart: undefined,
     };
     it('should prepare basic worktree without git status', () => {
         const items = prepareWorktreeItems([mockWorktree], []);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "2.2.0",
+	"version": "2.2.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",