ccmanager 2.8.0 → 2.9.0

package/dist/services/projectManager.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import { Effect, Either } from 'effect';
 // Mock modules before any other imports that might use them
 vi.mock('fs');
 vi.mock('os', () => ({
@@ -10,6 +11,7 @@ vi.mock('os', () => ({
 // Now import modules that depend on the mocked modules
 import { ProjectManager } from './projectManager.js';
 import { ENV_VARS } from '../constants/env.js';
+import { FileSystemError, ConfigError } from '../types/errors.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const mockFs = fs;
 describe('ProjectManager', () => {
@@ -78,7 +80,7 @@ describe('ProjectManager', () => {
                     throw new Error('Not found');
                 }),
             };
-            await projectManager.refreshProjects();
+            await Effect.runPromise(projectManager.refreshProjectsEffect());
             expect(projectManager.projects).toHaveLength(2);
             expect(projectManager.projects[0]).toMatchObject({
                 name: 'project1',
@@ -95,7 +97,15 @@ describe('ProjectManager', () => {
             mockFs.promises = {
                 access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
             };
-            await expect(projectManager.refreshProjects()).rejects.toThrow(`Projects directory does not exist: ${mockProjectsDir}`);
+            const result = await Effect.runPromise(Effect.either(projectManager.refreshProjectsEffect()));
+            expect(Either.isLeft(result)).toBe(true);
+            if (Either.isLeft(result)) {
+                const error = result.left;
+                expect(error._tag).toBe('FileSystemError');
+                if (error._tag === 'FileSystemError') {
+                    expect(error.cause).toContain(`Projects directory does not exist: ${mockProjectsDir}`);
+                }
+            }
         });
     });
     describe('recent projects', () => {
@@ -338,4 +348,234 @@ describe('ProjectManager', () => {
             expect(isValid).toBe(false);
         });
     });
+    describe('Effect-based API', () => {
+        beforeEach(() => {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = mockProjectsDir;
+            projectManager = new ProjectManager();
+        });
+        describe('discoverProjectsEffect', () => {
+            it('should return Effect with projects on success', async () => {
+                // Mock file system for project discovery
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation((dir) => {
+                        if (dir === mockProjectsDir) {
+                            return Promise.resolve([
+                                { name: 'project1', isDirectory: () => true },
+                                { name: 'project2', isDirectory: () => true },
+                            ]);
+                        }
+                        return Promise.resolve([]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(2);
+                expect(projects[0]).toMatchObject({
+                    name: 'project1',
+                    isValid: true,
+                });
+            });
+            it('should return Effect with FileSystemError when directory does not exist', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    expect(error.operation).toBe('read');
+                    expect(error.path).toBe(mockProjectsDir);
+                }
+            });
+            it('should use Effect.all for parallel project scanning', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation(() => {
+                        return Promise.resolve([
+                            { name: 'project1', isDirectory: () => true },
+                            { name: 'project2', isDirectory: () => true },
+                            { name: 'project3', isDirectory: () => true },
+                        ]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.discoverProjectsEffect(mockProjectsDir);
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(3);
+            });
+        });
+        describe('loadRecentProjectsEffect', () => {
+            it('should return Effect with recent projects on success', async () => {
+                const mockRecentProjects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                    {
+                        path: '/path/to/project2',
+                        name: 'project2',
+                        lastAccessed: Date.now() - 1000,
+                    },
+                ];
+                mockFs.readFileSync.mockReturnValue(JSON.stringify(mockRecentProjects));
+                mockFs.existsSync.mockReturnValue(true);
+                // Re-create to load recent projects
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const projects = await Effect.runPromise(effect);
+                expect(projects).toHaveLength(2);
+                expect(projects[0]?.name).toBe('project1');
+            });
+            it('should return Effect with FileSystemError when file read fails', async () => {
+                mockFs.existsSync.mockReturnValue(true);
+                mockFs.readFileSync.mockImplementation(() => {
+                    throw new Error('Permission denied');
+                });
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    if (error._tag === 'FileSystemError') {
+                        expect(error.operation).toBe('read');
+                    }
+                }
+            });
+            it('should return Effect with ConfigError when JSON parse fails', async () => {
+                mockFs.existsSync.mockReturnValue(true);
+                mockFs.readFileSync.mockReturnValue('invalid json{');
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('ConfigError');
+                    expect(error).toBeInstanceOf(ConfigError);
+                    if (error._tag === 'ConfigError') {
+                        expect(error.reason).toBe('parse');
+                    }
+                }
+            });
+            it('should use Effect.catchAll for fallback to empty cache on error', async () => {
+                mockFs.existsSync.mockReturnValue(false);
+                projectManager = new ProjectManager();
+                const effect = projectManager.loadRecentProjectsEffect();
+                const projects = await Effect.runPromise(Effect.catchAll(effect, () => Effect.succeed([])));
+                expect(projects).toEqual([]);
+            });
+        });
+        describe('saveRecentProjectsEffect', () => {
+            it('should return Effect with void on success', async () => {
+                mockFs.writeFileSync.mockImplementation(() => { });
+                projectManager = new ProjectManager();
+                const projects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                ];
+                const effect = projectManager.saveRecentProjectsEffect(projects);
+                await Effect.runPromise(effect);
+                expect(mockFs.writeFileSync).toHaveBeenCalledWith(mockRecentProjectsPath, expect.any(String));
+            });
+            it('should return Effect with FileSystemError when write fails', async () => {
+                mockFs.writeFileSync.mockImplementation(() => {
+                    throw new Error('Disk full');
+                });
+                projectManager = new ProjectManager();
+                const projects = [
+                    {
+                        path: '/path/to/project1',
+                        name: 'project1',
+                        lastAccessed: Date.now(),
+                    },
+                ];
+                const effect = projectManager.saveRecentProjectsEffect(projects);
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                    expect(error.operation).toBe('write');
+                }
+            });
+        });
+        describe('refreshProjectsEffect', () => {
+            it('should return Effect with void on success', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockResolvedValue(undefined),
+                    readdir: vi.fn().mockImplementation(() => {
+                        return Promise.resolve([
+                            { name: 'project1', isDirectory: () => true },
+                        ]);
+                    }),
+                    stat: vi.fn().mockImplementation((path) => {
+                        if (path.endsWith('.git')) {
+                            return Promise.resolve({
+                                isDirectory: () => true,
+                                isFile: () => false,
+                            });
+                        }
+                        throw new Error('Not found');
+                    }),
+                };
+                const effect = projectManager.refreshProjectsEffect();
+                await Effect.runPromise(effect);
+                expect(projectManager.projects).toHaveLength(1);
+            });
+            it('should return Effect with FileSystemError when projects directory not configured', async () => {
+                // Create without multi-project root
+                delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+                projectManager = new ProjectManager();
+                const effect = projectManager.refreshProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(error._tag).toBe('FileSystemError');
+                    expect(error).toBeInstanceOf(FileSystemError);
+                }
+            });
+            it('should return Effect with FileSystemError or GitError on discovery failure', async () => {
+                mockFs.promises = {
+                    access: vi.fn().mockRejectedValue({ code: 'ENOENT' }),
+                };
+                const effect = projectManager.refreshProjectsEffect();
+                const result = await Effect.runPromise(Effect.either(effect));
+                expect(Either.isLeft(result)).toBe(true);
+                if (Either.isLeft(result)) {
+                    const error = result.left;
+                    expect(['FileSystemError', 'GitError']).toContain(error._tag);
+                }
+            });
+        });
+    });
 });

package/dist/services/sessionManager.d.ts

@@ -1,5 +1,7 @@
 import { Session, SessionManager as ISessionManager, SessionState, DevcontainerConfig } from '../types/index.js';
 import { EventEmitter } from 'events';
+import { Effect } from 'effect';
+import { ProcessError, ConfigError } from '../types/errors.js';
 export interface SessionCounts {
     idle: number;
     busy: number;
@@ -16,7 +18,25 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createSessionId;
     private createTerminal;
     private createSessionInternal;
-    createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
+    /**
+     * 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: string, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     private setupDataHandler;
     /**
      * Sets up exit handler for the session process.
@@ -31,8 +51,30 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     getSession(worktreePath: string): Session | undefined;
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;
+    /**
+     * 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: string): Effect.Effect<void, ProcessError, never>;
     getAllSessions(): Session[];
-    createSessionWithDevcontainer(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Promise<Session>;
+    /**
+     * 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: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;
     static formatSessionCounts(counts: SessionCounts): string;

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

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

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();
+        });
+    });
+});