ccmanager 2.8.0 → 2.9.1

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

@@ -0,0 +1,321 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Effect, Either } from 'effect';
+import { spawn } from 'node-pty';
+import { EventEmitter } from 'events';
+// Mock node-pty
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
+// Mock child_process
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+    execFile: vi.fn(),
+}));
+// Mock configuration manager
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getDefaultPreset: vi.fn(),
+        getPresetById: vi.fn(),
+    },
+}));
+// Mock Terminal
+vi.mock('@xterm/headless', () => ({
+    default: {
+        Terminal: vi.fn().mockImplementation(() => ({
+            buffer: {
+                active: {
+                    length: 0,
+                    getLine: vi.fn(),
+                },
+            },
+            write: vi.fn(),
+        })),
+    },
+}));
+// Create a mock IPty class
+class MockPty extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "kill", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "resize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "write", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "onData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((callback) => {
+                this.on('data', callback);
+            })
+        });
+        Object.defineProperty(this, "onExit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((callback) => {
+                this.on('exit', callback);
+            })
+        });
+    }
+}
+describe('SessionManager Effect-based Operations', () => {
+    let sessionManager;
+    let mockPty;
+    let SessionManager;
+    let configurationManager;
+    beforeEach(async () => {
+        vi.clearAllMocks();
+        // Dynamically import after mocks are set up
+        const sessionManagerModule = await import('./sessionManager.js');
+        const configManagerModule = await import('./configurationManager.js');
+        SessionManager = sessionManagerModule.SessionManager;
+        configurationManager = configManagerModule.configurationManager;
+        sessionManager = new SessionManager();
+        mockPty = new MockPty();
+    });
+    afterEach(() => {
+        sessionManager.destroy();
+    });
+    describe('createSessionWithPreset returning Effect', () => {
+        it('should return Effect that succeeds with Session', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--preset-arg'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with preset - should return Effect
+            const effect = sessionManager.createSessionWithPresetEffect('/test/worktree');
+            // Execute the Effect and verify it succeeds with a Session
+            const session = await Effect.runPromise(effect);
+            expect(session).toBeDefined();
+            expect(session.worktreePath).toBe('/test/worktree');
+            expect(session.state).toBe('busy');
+        });
+        it('should return Effect that fails with ConfigError when preset not found', async () => {
+            // Setup mocks - both return null/undefined
+            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue(undefined);
+            // Create session with non-existent preset - should return Effect
+            const effect = sessionManager.createSessionWithPresetEffect('/test/worktree', 'invalid-preset');
+            // Execute the Effect and expect it to fail with ConfigError
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ConfigError');
+                if (result.left._tag === 'ConfigError') {
+                    expect(result.left.reason).toBe('validation');
+                    expect(result.left.details).toContain('preset');
+                }
+            }
+        });
+        it('should return Effect that fails with ProcessError when spawn fails', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'invalid-command',
+                args: ['--arg'],
+            });
+            // Mock spawn to throw error
+            vi.mocked(spawn).mockImplementation(() => {
+                throw new Error('spawn ENOENT: command not found');
+            });
+            // Create session - should return Effect
+            const effect = sessionManager.createSessionWithPresetEffect('/test/worktree');
+            // Execute the Effect and expect it to fail with ProcessError
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ProcessError');
+                if (result.left._tag === 'ProcessError') {
+                    expect(result.left.command).toContain('createSessionWithPreset');
+                    expect(result.left.message).toContain('spawn');
+                }
+            }
+        });
+        it('should return existing session without creating new Effect', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session twice
+            const effect1 = sessionManager.createSessionWithPresetEffect('/test/worktree');
+            const session1 = await Effect.runPromise(effect1);
+            const effect2 = sessionManager.createSessionWithPresetEffect('/test/worktree');
+            const session2 = await Effect.runPromise(effect2);
+            // Should return the same session
+            expect(session1).toBe(session2);
+            // Spawn should only be called once
+            expect(spawn).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('createSessionWithDevcontainer returning Effect', () => {
+        it('should return Effect that succeeds with Session', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--resume'],
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Mock exec to succeed
+            const { exec } = await import('child_process');
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            };
+            // Create session with devcontainer - should return Effect
+            const effect = sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig);
+            // Execute the Effect and verify it succeeds with a Session
+            const session = await Effect.runPromise(effect);
+            expect(session).toBeDefined();
+            expect(session.worktreePath).toBe('/test/worktree');
+            expect(session.devcontainerConfig).toEqual(devcontainerConfig);
+        });
+        it('should return Effect that fails with ProcessError when devcontainer up fails', async () => {
+            // Mock exec to fail
+            const { exec } = await import('child_process');
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(new Error('Container failed to start'), '', '');
+                }
+                return {};
+            });
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            };
+            // Create session with devcontainer - should return Effect
+            const effect = sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig);
+            // Execute the Effect and expect it to fail with ProcessError
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ProcessError');
+                if (result.left._tag === 'ProcessError') {
+                    expect(result.left.command).toContain('devcontainer up');
+                    expect(result.left.message).toContain('Container failed');
+                }
+            }
+        });
+        it('should return Effect that fails with ConfigError when preset not found', async () => {
+            // Setup mocks - both return null/undefined
+            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue(undefined);
+            // Mock exec to succeed (devcontainer up)
+            const { exec } = await import('child_process');
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up',
+                execCommand: 'devcontainer exec',
+            };
+            // Create session with invalid preset
+            const effect = sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig, 'invalid-preset');
+            // Execute the Effect and expect it to fail with ConfigError
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ConfigError');
+            }
+        });
+    });
+    describe('terminateSession returning Effect', () => {
+        it('should return Effect that succeeds when session exists', async () => {
+            // Setup mock preset and create a session first
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Terminate session - should return Effect
+            const effect = sessionManager.terminateSessionEffect('/test/worktree');
+            // Execute the Effect and verify it succeeds
+            await Effect.runPromise(effect);
+            // Verify session was destroyed
+            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+            expect(mockPty.kill).toHaveBeenCalled();
+        });
+        it('should return Effect that fails with ProcessError when session does not exist', async () => {
+            // Terminate non-existent session - should return Effect
+            const effect = sessionManager.terminateSessionEffect('/nonexistent/worktree');
+            // Execute the Effect and expect it to fail with ProcessError
+            const result = await Effect.runPromise(Effect.either(effect));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                expect(result.left._tag).toBe('ProcessError');
+                expect(result.left.message).toContain('Session not found');
+            }
+        });
+        it('should return Effect that succeeds even when process kill fails', async () => {
+            // Setup mock preset and create a session
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Mock kill to throw error
+            mockPty.kill.mockImplementation(() => {
+                throw new Error('Process already terminated');
+            });
+            // Terminate session - should still succeed
+            const effect = sessionManager.terminateSessionEffect('/test/worktree');
+            // Should not throw, gracefully handle kill failure
+            await Effect.runPromise(effect);
+            // Session should still be removed from map
+            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+        });
+    });
+});

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() {