ccmanager 3.3.2 → 3.5.0

package/dist/services/config/testUtils.js

@@ -0,0 +1,351 @@
+/**
+ * @fileoverview Test utilities for config module
+ *
+ * WARNING: This file is intended for TEST USE ONLY.
+ * Do not import from production code.
+ *
+ * These functions provide Effect-based wrappers for testing config operations.
+ */
+import { Effect, Either } from 'effect';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_SHORTCUTS, } from '../../types/index.js';
+import { FileSystemError, ConfigError, ValidationError, } from '../../types/errors.js';
+/**
+ * TEST ONLY: Load configuration from file with Effect-based error handling
+ *
+ * @param configPath - Path to the config file
+ * @param legacyShortcutsPath - Path to legacy shortcuts file for migration
+ * @returns Effect with ConfigurationData on success, errors on failure
+ */
+export function loadConfigEffect(configPath, legacyShortcutsPath) {
+    return Effect.try({
+        try: () => {
+            if (existsSync(configPath)) {
+                const configData = readFileSync(configPath, 'utf-8');
+                const parsedConfig = JSON.parse(configData);
+                return applyDefaults(parsedConfig);
+            }
+            else {
+                const migratedConfig = migrateLegacyShortcutsSync(configPath, legacyShortcutsPath);
+                return applyDefaults(migratedConfig || {});
+            }
+        },
+        catch: (error) => {
+            if (error instanceof SyntaxError) {
+                return new ConfigError({
+                    configPath,
+                    reason: 'parse',
+                    details: String(error),
+                });
+            }
+            return new FileSystemError({
+                operation: 'read',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * Type guard to check if value is a non-null object
+ */
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+function validationError(constraint, receivedValue) {
+    return Either.left(new ValidationError({
+        field: 'config',
+        constraint,
+        receivedValue,
+    }));
+}
+function validationSuccess(config) {
+    return Either.right(config);
+}
+/**
+ * TEST ONLY: Validate configuration structure
+ */
+export function validateConfig(config) {
+    if (!isObject(config)) {
+        return validationError('must be a valid configuration object', config);
+    }
+    const shortcuts = config['shortcuts'];
+    if (shortcuts !== undefined && !isObject(shortcuts)) {
+        return validationError('shortcuts must be a valid object', config);
+    }
+    return validationSuccess(config);
+}
+/**
+ * Apply default values to configuration
+ */
+function applyDefaults(config) {
+    if (!config.shortcuts) {
+        config.shortcuts = DEFAULT_SHORTCUTS;
+    }
+    if (!config.statusHooks) {
+        config.statusHooks = {};
+    }
+    if (!config.worktreeHooks) {
+        config.worktreeHooks = {};
+    }
+    if (!config.worktree) {
+        config.worktree = {
+            autoDirectory: false,
+            copySessionData: true,
+            sortByLastSession: false,
+        };
+    }
+    if (!Object.prototype.hasOwnProperty.call(config.worktree, 'copySessionData')) {
+        config.worktree.copySessionData = true;
+    }
+    if (!Object.prototype.hasOwnProperty.call(config.worktree, 'sortByLastSession')) {
+        config.worktree.sortByLastSession = false;
+    }
+    if (!config.autoApproval) {
+        config.autoApproval = {
+            enabled: false,
+            timeout: 30,
+        };
+    }
+    else {
+        if (!Object.prototype.hasOwnProperty.call(config.autoApproval, 'enabled')) {
+            config.autoApproval.enabled = false;
+        }
+        if (!Object.prototype.hasOwnProperty.call(config.autoApproval, 'timeout')) {
+            config.autoApproval.timeout = 30;
+        }
+    }
+    return config;
+}
+/**
+ * Synchronous legacy shortcuts migration helper
+ */
+function migrateLegacyShortcutsSync(configPath, legacyShortcutsPath) {
+    if (existsSync(legacyShortcutsPath)) {
+        try {
+            const shortcutsData = readFileSync(legacyShortcutsPath, 'utf-8');
+            const shortcuts = JSON.parse(shortcutsData);
+            if (shortcuts && typeof shortcuts === 'object') {
+                const config = { shortcuts };
+                writeFileSync(configPath, JSON.stringify(config, null, 2));
+                console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                return config;
+            }
+        }
+        catch (error) {
+            console.error('Failed to migrate legacy shortcuts:', error);
+        }
+    }
+    return null;
+}
+// ============================================================================
+// Test-only helper functions for GlobalConfigManager
+// These functions were moved from GlobalConfigManager class to reduce its API
+// surface while keeping tests functional.
+// ============================================================================
+/**
+ * TEST ONLY: Add or update a preset in the config manager
+ */
+export function addPreset(configManager, preset) {
+    const presets = configManager.getCommandPresets();
+    // Replace if exists, otherwise add
+    const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+    if (existingIndex >= 0) {
+        presets.presets[existingIndex] = preset;
+    }
+    else {
+        presets.presets.push(preset);
+    }
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Delete a preset by ID
+ */
+export function deletePreset(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    // Don't delete if it's the last preset
+    if (presets.presets.length <= 1) {
+        return;
+    }
+    // Remove the preset
+    presets.presets = presets.presets.filter(p => p.id !== id);
+    // Update default if needed
+    if (presets.defaultPresetId === id && presets.presets.length > 0) {
+        presets.defaultPresetId = presets.presets[0].id;
+    }
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Set the default preset ID
+ */
+export function setDefaultPreset(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    // Only update if preset exists
+    if (presets.presets.some(p => p.id === id)) {
+        presets.defaultPresetId = id;
+        configManager.setCommandPresets(presets);
+    }
+}
+/**
+ * TEST ONLY: Save configuration to file with Effect-based error handling
+ */
+export function saveConfigEffect(configManager, config, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setCommandPresets(config.commandPresets || configManager.getCommandPresets());
+            if (config.shortcuts) {
+                configManager.setShortcuts(config.shortcuts);
+            }
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Set shortcuts with Effect-based error handling
+ */
+export function setShortcutsEffect(configManager, shortcuts, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setShortcuts(shortcuts);
+            const config = {
+                ...{},
+                shortcuts,
+                commandPresets: configManager.getCommandPresets(),
+            };
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Set command presets with Effect-based error handling
+ */
+export function setCommandPresetsEffect(configManager, presets, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setCommandPresets(presets);
+            const config = {
+                ...{},
+                commandPresets: presets,
+            };
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Add or update preset with Effect-based error handling
+ */
+export function addPresetEffect(configManager, preset, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Replace if exists, otherwise add
+    const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+    if (existingIndex >= 0) {
+        presets.presets[existingIndex] = preset;
+    }
+    else {
+        presets.presets.push(preset);
+    }
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Delete preset with Effect-based error handling
+ */
+export function deletePresetEffect(configManager, id, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Don't delete if it's the last preset
+    if (presets.presets.length <= 1) {
+        return Effect.fail(new ValidationError({
+            field: 'presetId',
+            constraint: 'Cannot delete last preset',
+            receivedValue: id,
+        }));
+    }
+    // Remove the preset
+    presets.presets = presets.presets.filter(p => p.id !== id);
+    // Update default if needed
+    if (presets.defaultPresetId === id && presets.presets.length > 0) {
+        presets.defaultPresetId = presets.presets[0].id;
+    }
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Set default preset with Effect-based error handling
+ */
+export function setDefaultPresetEffect(configManager, id, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Only update if preset exists
+    if (!presets.presets.some(p => p.id === id)) {
+        return Effect.fail(new ValidationError({
+            field: 'presetId',
+            constraint: 'Preset not found',
+            receivedValue: id,
+        }));
+    }
+    presets.defaultPresetId = id;
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Get the default preset
+ */
+export function getDefaultPreset(configManager) {
+    const presets = configManager.getCommandPresets();
+    const defaultPreset = presets.presets.find(p => p.id === presets.defaultPresetId);
+    return defaultPreset || presets.presets[0];
+}
+/**
+ * TEST ONLY: Get whether to select preset on start
+ */
+export function getSelectPresetOnStart(configManager) {
+    const presets = configManager.getCommandPresets();
+    return presets.selectPresetOnStart ?? false;
+}
+/**
+ * TEST ONLY: Set whether to select preset on start
+ */
+export function setSelectPresetOnStart(configManager, enabled) {
+    const presets = configManager.getCommandPresets();
+    presets.selectPresetOnStart = enabled;
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Get whether auto-approval is enabled
+ */
+export function isAutoApprovalEnabled(configManager) {
+    const config = configManager.getAutoApprovalConfig();
+    return config?.enabled ?? false;
+}
+/**
+ * TEST ONLY: Get preset by ID with Either-based error handling
+ */
+export function getPresetByIdEffect(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    const preset = presets.presets.find(p => p.id === id);
+    if (!preset) {
+        return Either.left(new ValidationError({
+            field: 'presetId',
+            constraint: 'Preset not found',
+            receivedValue: id,
+        }));
+    }
+    return Either.right(preset);
+}

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
 import { spawn } from './bunTerminal.js';
 import { STATE_CHECK_INTERVAL_MS, STATE_PERSISTENCE_DURATION_MS, } from '../constants/statePersistence.js';
-import { Effect } from 'effect';
+import { Effect, Either } from 'effect';
 const detectStateMock = vi.fn();
 // Create a deferred promise pattern for controllable mock
 let verifyResolve = null;
@@ -15,10 +15,13 @@ vi.mock('./bunTerminal.js', () => ({
     }),
 }));
 vi.mock('./stateDetector/index.js', () => ({
-    createStateDetector: () => ({ detectState: detectStateMock }),
+    createStateDetector: () => ({
+        detectState: detectStateMock,
+        detectBackgroundTask: () => false,
+    }),
 }));
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getConfig: vi.fn().mockReturnValue({
             commands: [
                 {
@@ -30,12 +33,12 @@ vi.mock('./configurationManager.js', () => ({
             ],
             defaultCommandId: 'test',
         }),
-        getPresetById: vi.fn().mockReturnValue({
+        getPresetByIdEffect: vi.fn().mockReturnValue(Either.right({
             id: 'test',
             name: 'Test',
             command: 'test',
             args: [],
-        }),
+        })),
         getDefaultPreset: vi.fn().mockReturnValue({
             id: 'test',
             name: 'Test',

package/dist/services/sessionManager.d.ts

@@ -8,6 +8,7 @@ export interface SessionCounts {
     waiting_input: number;
     pending_auto_approval: number;
     total: number;
+    backgroundTasks: number;
 }
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
@@ -15,6 +16,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private busyTimers;
     private spawn;
     detectTerminalState(session: Session): SessionState;
+    detectBackgroundTask(session: Session): boolean;
     private getTerminalContent;
     private handleAutoApproval;
     private cancelAutoApprovalVerification;

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

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { Effect, Either } from 'effect';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
+import { ValidationError } from '../types/errors.js';
 // Mock bunTerminal
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
@@ -14,10 +15,10 @@ vi.mock('child_process', () => ({
     execFile: vi.fn(),
 }));
 // Mock configuration manager
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getDefaultPreset: vi.fn(),
-        getPresetById: vi.fn(),
+        getPresetByIdEffect: vi.fn(),
         setWorktreeLastOpened: vi.fn(),
         getWorktreeLastOpenedTime: vi.fn(),
         getWorktreeLastOpened: vi.fn(() => ({})),
@@ -83,14 +84,14 @@ describe('SessionManager Effect-based Operations', () => {
     let sessionManager;
     let mockPty;
     let SessionManager;
-    let configurationManager;
+    let configReader;
     beforeEach(async () => {
         vi.clearAllMocks();
         // Dynamically import after mocks are set up
         const sessionManagerModule = await import('./sessionManager.js');
-        const configManagerModule = await import('./configurationManager.js');
+        const configManagerModule = await import('./config/configReader.js');
         SessionManager = sessionManagerModule.SessionManager;
-        configurationManager = configManagerModule.configurationManager;
+        configReader = configManagerModule.configReader;
         sessionManager = new SessionManager();
         mockPty = new MockPty();
     });
@@ -100,7 +101,7 @@ describe('SessionManager Effect-based Operations', () => {
     describe('createSessionWithPreset returning Effect', () => {
         it('should return Effect that succeeds with Session', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -117,9 +118,13 @@ describe('SessionManager Effect-based Operations', () => {
             expect(session.stateMutex.getSnapshot().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);
+            // Setup mocks - getPresetByIdEffect returns Left, getDefaultPreset returns undefined
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: 'invalid-preset',
+            })));
+            vi.mocked(configReader.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
@@ -135,7 +140,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return Effect that fails with ProcessError when spawn fails', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'invalid-command',
@@ -160,7 +165,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return existing session without creating new Effect', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -181,7 +186,7 @@ describe('SessionManager Effect-based Operations', () => {
     describe('createSessionWithDevcontainer returning Effect', () => {
         it('should return Effect that succeeds with Session', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -244,9 +249,13 @@ describe('SessionManager Effect-based Operations', () => {
             }
         });
         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);
+            // Setup mocks - getPresetByIdEffect returns Left, getDefaultPreset returns undefined
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: 'invalid-preset',
+            })));
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue(undefined);
             // Mock exec to succeed (devcontainer up)
             const { exec } = await import('child_process');
             const mockExec = vi.mocked(exec);
@@ -276,7 +285,7 @@ describe('SessionManager Effect-based Operations', () => {
     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({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -305,7 +314,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return Effect that succeeds even when process kill fails', async () => {
             // Setup mock preset and create a session
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',