ccmanager 2.8.0 → 2.9.0

package/dist/services/sessionManager.js

@@ -7,6 +7,8 @@ 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';
+import { Effect } from 'effect';
+import { ProcessError, ConfigError } from '../types/errors.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 export class SessionManager extends EventEmitter {
@@ -86,29 +88,78 @@ export class SessionManager extends EventEmitter {
         this.emit('sessionCreated', session);
         return session;
     }
-    async createSessionWithPreset(worktreePath, presetId) {
-        // Check if session already exists
-        const existing = this.sessions.get(worktreePath);
-        if (existing) {
-            return existing;
-        }
-        // Get preset configuration
-        let preset = presetId ? configurationManager.getPresetById(presetId) : null;
-        if (!preset) {
-            preset = configurationManager.getDefaultPreset();
-        }
-        const command = preset.command;
-        const args = preset.args || [];
-        const commandConfig = {
-            command: preset.command,
-            args: preset.args,
-            fallbackArgs: preset.fallbackArgs,
-        };
-        // Spawn the process - fallback will be handled by setupExitHandler
-        const ptyProcess = await this.spawn(command, args, worktreePath);
-        return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
-            isPrimaryCommand: true,
-            detectionStrategy: preset.detectionStrategy,
+    /**
+     * Create session with command preset using Effect-based error handling
+     *
+     * @param {string} worktreePath - Path to the worktree
+     * @param {string} [presetId] - Optional preset ID, uses default if not provided
+     * @returns {Effect.Effect<Session, ProcessError | ConfigError, never>} Effect that may fail with ProcessError (spawn failure) or ConfigError (invalid preset)
+     *
+     * @example
+     * ```typescript
+     * // Use Effect.match for type-safe error handling
+     * const result = await Effect.runPromise(
+     *   Effect.match(effect, {
+     *     onFailure: (error) => ({ type: 'error', message: error.message }),
+     *     onSuccess: (session) => ({ type: 'success', data: session })
+     *   })
+     * );
+     * ```
+     */
+    createSessionWithPresetEffect(worktreePath, presetId) {
+        return Effect.tryPromise({
+            try: async () => {
+                // Check if session already exists
+                const existing = this.sessions.get(worktreePath);
+                if (existing) {
+                    return existing;
+                }
+                // Get preset configuration
+                let preset = presetId
+                    ? configurationManager.getPresetById(presetId)
+                    : null;
+                if (!preset) {
+                    preset = configurationManager.getDefaultPreset();
+                }
+                // Validate preset exists
+                if (!preset) {
+                    throw new ConfigError({
+                        configPath: 'configuration',
+                        reason: 'validation',
+                        details: presetId
+                            ? `Preset with ID '${presetId}' not found and no default preset available`
+                            : 'No default preset available',
+                    });
+                }
+                const command = preset.command;
+                const args = preset.args || [];
+                const commandConfig = {
+                    command: preset.command,
+                    args: preset.args,
+                    fallbackArgs: preset.fallbackArgs,
+                };
+                // Spawn the process - fallback will be handled by setupExitHandler
+                const ptyProcess = await this.spawn(command, args, worktreePath);
+                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                    isPrimaryCommand: true,
+                    detectionStrategy: preset.detectionStrategy,
+                });
+            },
+            catch: (error) => {
+                // If it's already a ConfigError, return it
+                if (error instanceof ConfigError) {
+                    return error;
+                }
+                // Otherwise, wrap in ProcessError
+                return new ProcessError({
+                    command: presetId
+                        ? `createSessionWithPreset (preset: ${presetId})`
+                        : 'createSessionWithPreset (default preset)',
+                    message: error instanceof Error
+                        ? error.message
+                        : 'Failed to create session with preset',
+                });
+            },
         });
     }
     setupDataHandler(session) {
@@ -213,8 +264,8 @@ export class SessionManager extends EventEmitter {
                         session.state = detectedState;
                         session.pendingState = undefined;
                         session.pendingStateStart = undefined;
-                        // Execute status hook asynchronously (non-blocking)
-                        void executeStatusHook(oldState, detectedState, session);
+                        // Execute status hook asynchronously (non-blocking) using Effect
+                        void Effect.runPromise(executeStatusHook(oldState, detectedState, session));
                         this.emit('sessionStateChanged', session);
                     }
                 }
@@ -280,49 +331,149 @@ export class SessionManager extends EventEmitter {
             this.emit('sessionDestroyed', session);
         }
     }
+    /**
+     * Terminate session and cleanup resources using Effect-based error handling
+     *
+     * @param {string} worktreePath - Path to the worktree
+     * @returns {Effect.Effect<void, ProcessError, never>} Effect that may fail with ProcessError if session does not exist or cleanup fails
+     *
+     * @example
+     * ```typescript
+     * // Terminate session with error handling
+     * const result = await Effect.runPromise(
+     *   Effect.match(effect, {
+     *     onFailure: (error) => ({ type: 'error', message: error.message }),
+     *     onSuccess: () => ({ type: 'success' })
+     *   })
+     * );
+     * ```
+     */
+    terminateSessionEffect(worktreePath) {
+        return Effect.try({
+            try: () => {
+                const session = this.sessions.get(worktreePath);
+                if (!session) {
+                    throw new ProcessError({
+                        command: 'terminateSession',
+                        message: `Session not found for worktree: ${worktreePath}`,
+                    });
+                }
+                // Clear the state check interval
+                if (session.stateCheckInterval) {
+                    clearInterval(session.stateCheckInterval);
+                }
+                // Try to kill the process - don't fail if process is already dead
+                try {
+                    session.process.kill();
+                }
+                catch (_error) {
+                    // Process might already be dead, this is acceptable
+                }
+                // Clean up any pending timer
+                const timer = this.busyTimers.get(worktreePath);
+                if (timer) {
+                    clearTimeout(timer);
+                    this.busyTimers.delete(worktreePath);
+                }
+                // Remove from sessions map and cleanup
+                this.sessions.delete(worktreePath);
+                this.waitingWithBottomBorder.delete(session.id);
+                this.emit('sessionDestroyed', session);
+            },
+            catch: (error) => {
+                // If it's already a ProcessError, return it
+                if (error instanceof ProcessError) {
+                    return error;
+                }
+                // Otherwise, wrap in ProcessError
+                return new ProcessError({
+                    command: 'terminateSession',
+                    message: error instanceof Error
+                        ? error.message
+                        : `Failed to terminate session for ${worktreePath}`,
+                });
+            },
+        });
+    }
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
-    async createSessionWithDevcontainer(worktreePath, devcontainerConfig, presetId) {
-        // Check if session already exists
-        const existing = this.sessions.get(worktreePath);
-        if (existing) {
-            return existing;
-        }
-        // Execute devcontainer up command first
-        try {
-            await execAsync(devcontainerConfig.upCommand, { cwd: worktreePath });
-        }
-        catch (error) {
-            throw new Error(`Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Get preset configuration
-        let preset = presetId ? configurationManager.getPresetById(presetId) : null;
-        if (!preset) {
-            preset = configurationManager.getDefaultPreset();
-        }
-        // Parse the exec command to extract arguments
-        const execParts = devcontainerConfig.execCommand.split(/\s+/);
-        const devcontainerCmd = execParts[0] || 'devcontainer'; // Should be 'devcontainer'
-        const execArgs = execParts.slice(1); // Rest of the exec command args
-        // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
-        const fullArgs = [
-            ...execArgs,
-            '--',
-            preset.command,
-            ...(preset.args || []),
-        ];
-        // Spawn the process within devcontainer - fallback will be handled by setupExitHandler
-        const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
-        const commandConfig = {
-            command: preset.command,
-            args: preset.args,
-            fallbackArgs: preset.fallbackArgs,
-        };
-        return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
-            isPrimaryCommand: true,
-            detectionStrategy: preset.detectionStrategy,
-            devcontainerConfig,
+    /**
+     * Create session with devcontainer integration using Effect-based error handling
+     * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
+     */
+    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId) {
+        return Effect.tryPromise({
+            try: async () => {
+                // Check if session already exists
+                const existing = this.sessions.get(worktreePath);
+                if (existing) {
+                    return existing;
+                }
+                // Execute devcontainer up command first
+                try {
+                    await execAsync(devcontainerConfig.upCommand, { cwd: worktreePath });
+                }
+                catch (error) {
+                    throw new ProcessError({
+                        command: devcontainerConfig.upCommand,
+                        message: `Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+                // Get preset configuration
+                let preset = presetId
+                    ? configurationManager.getPresetById(presetId)
+                    : null;
+                if (!preset) {
+                    preset = configurationManager.getDefaultPreset();
+                }
+                // Validate preset exists
+                if (!preset) {
+                    throw new ConfigError({
+                        configPath: 'configuration',
+                        reason: 'validation',
+                        details: presetId
+                            ? `Preset with ID '${presetId}' not found and no default preset available`
+                            : 'No default preset available',
+                    });
+                }
+                // Parse the exec command to extract arguments
+                const execParts = devcontainerConfig.execCommand.split(/\s+/);
+                const devcontainerCmd = execParts[0] || 'devcontainer';
+                const execArgs = execParts.slice(1);
+                // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
+                const fullArgs = [
+                    ...execArgs,
+                    '--',
+                    preset.command,
+                    ...(preset.args || []),
+                ];
+                // Spawn the process within devcontainer
+                const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
+                const commandConfig = {
+                    command: preset.command,
+                    args: preset.args,
+                    fallbackArgs: preset.fallbackArgs,
+                };
+                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                    isPrimaryCommand: true,
+                    detectionStrategy: preset.detectionStrategy,
+                    devcontainerConfig,
+                });
+            },
+            catch: (error) => {
+                // If it's already a ConfigError or ProcessError, return it
+                if (error instanceof ConfigError || error instanceof ProcessError) {
+                    return error;
+                }
+                // Otherwise, wrap in ProcessError
+                return new ProcessError({
+                    command: `createSessionWithDevcontainer (${devcontainerConfig.execCommand})`,
+                    message: error instanceof Error
+                        ? error.message
+                        : 'Failed to create session with devcontainer',
+                });
+            },
         });
     }
     destroy() {

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

@@ -3,7 +3,9 @@ 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('node-pty', () => ({
+    spawn: vi.fn(),
+}));
 vi.mock('./configurationManager.js', () => ({
     configurationManager: {
         getConfig: vi.fn().mockReturnValue({
@@ -72,7 +74,8 @@ describe('SessionManager - State Persistence', () => {
         vi.clearAllMocks();
     });
     it('should not change state immediately when detected state changes', async () => {
-        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Initial state should be busy
         expect(session.state).toBe('busy');
@@ -86,7 +89,8 @@ describe('SessionManager - State Persistence', () => {
         expect(session.pendingStateStart).toBeDefined();
     });
     it('should change state after persistence duration is met', async () => {
-        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         const stateChangeHandler = vi.fn();
         sessionManager.on('sessionStateChanged', stateChangeHandler);
@@ -107,7 +111,8 @@ describe('SessionManager - State Persistence', () => {
         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 { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Initial state should be busy
         expect(session.state).toBe('busy');
@@ -125,7 +130,8 @@ describe('SessionManager - State Persistence', () => {
         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 { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Initial state should be busy
         expect(session.state).toBe('busy');
@@ -145,7 +151,8 @@ describe('SessionManager - State Persistence', () => {
         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 { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         const stateChangeHandler = vi.fn();
         sessionManager.on('sessionStateChanged', stateChangeHandler);
@@ -170,7 +177,8 @@ describe('SessionManager - State Persistence', () => {
         expect(stateChangeHandler).not.toHaveBeenCalled();
     });
     it('should properly clean up pending state when session is destroyed', async () => {
-        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
         // Simulate output that would trigger idle state
         eventEmitter.emit('data', 'Some output without busy indicators');
@@ -185,8 +193,9 @@ describe('SessionManager - State Persistence', () => {
         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 { Effect } = await import('effect');
+        const session1 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path1'));
+        const session2 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path2'));
         const eventEmitter1 = eventEmitters.get('/test/path1');
         const eventEmitter2 = eventEmitters.get('/test/path2');
         // Both should start as busy