ccmanager 2.1.0 → 2.2.1

package/dist/types/index.d.ts

@@ -22,11 +22,13 @@ export interface Session {
     lastActivity: Date;
     isActive: boolean;
     terminal: Terminal;
-    stateCheckInterval?: NodeJS.Timeout;
-    isPrimaryCommand?: boolean;
-    commandConfig?: CommandConfig;
-    detectionStrategy?: StateDetectionStrategy;
-    devcontainerConfig?: DevcontainerConfig;
+    stateCheckInterval: NodeJS.Timeout | undefined;
+    isPrimaryCommand: boolean;
+    commandConfig: CommandConfig | undefined;
+    detectionStrategy: StateDetectionStrategy | undefined;
+    devcontainerConfig: DevcontainerConfig | undefined;
+    pendingState: SessionState | undefined;
+    pendingStateStart: number | undefined;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
@@ -54,6 +56,13 @@ export interface StatusHookConfig {
     busy?: StatusHook;
     waiting_input?: StatusHook;
 }
+export interface WorktreeHook {
+    command: string;
+    enabled: boolean;
+}
+export interface WorktreeHookConfig {
+    post_creation?: WorktreeHook;
+}
 export interface WorktreeConfig {
     autoDirectory: boolean;
     autoDirectoryPattern?: string;
@@ -84,6 +93,7 @@ export interface DevcontainerConfig {
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
+    worktreeHooks?: WorktreeHookConfig;
     worktree?: WorktreeConfig;
     command?: CommandConfig;
     commandPresets?: CommandPresetsConfig;
@@ -126,10 +136,10 @@ export interface IProjectManager {
 export interface IWorktreeService {
     getWorktrees(): Worktree[];
     getGitRootPath(): string;
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Promise<{
         success: boolean;
         error?: string;
-    };
+    }>;
     deleteWorktree(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): {

package/dist/utils/hookExecutor.d.ts

@@ -0,0 +1,20 @@
+import { Worktree, Session, SessionState } from '../types/index.js';
+export interface HookEnvironment {
+    CCMANAGER_WORKTREE_PATH: string;
+    CCMANAGER_WORKTREE_BRANCH: string;
+    CCMANAGER_GIT_ROOT: string;
+    CCMANAGER_BASE_BRANCH?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Execute a hook command with the provided environment variables
+ */
+export declare function executeHook(command: string, cwd: string, environment: HookEnvironment): Promise<void>;
+/**
+ * Execute a worktree post-creation hook
+ */
+export declare function executeWorktreePostCreationHook(command: string, worktree: Worktree, gitRoot: string, baseBranch?: string): Promise<void>;
+/**
+ * Execute a session status change hook
+ */
+export declare function executeStatusHook(oldState: SessionState, newState: SessionState, session: Session): Promise<void>;

package/dist/utils/hookExecutor.js

@@ -0,0 +1,96 @@
+import { spawn } from 'child_process';
+import { WorktreeService } from '../services/worktreeService.js';
+import { configurationManager } from '../services/configurationManager.js';
+/**
+ * Execute a hook command with the provided environment variables
+ */
+export function executeHook(command, cwd, environment) {
+    return new Promise((resolve, reject) => {
+        // Use spawn with shell to execute the command and wait for all child processes
+        const child = spawn(command, [], {
+            cwd,
+            env: {
+                ...process.env,
+                ...environment,
+            },
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        // Collect stderr for logging
+        child.stderr?.on('data', data => {
+            stderr += data.toString();
+        });
+        // Wait for the process and all its children to exit
+        child.on('exit', (code, signal) => {
+            if (code !== 0 || signal) {
+                let errorMessage = signal
+                    ? `Hook terminated by signal ${signal}`
+                    : `Hook exited with code ${code}`;
+                // Include stderr in the error message when exit code is not 0
+                if (stderr) {
+                    errorMessage += `\nStderr: ${stderr}`;
+                }
+                reject(new Error(errorMessage));
+                return;
+            }
+            // When exit code is 0, ignore stderr and resolve successfully
+            resolve();
+        });
+        // Handle errors in spawning the process
+        child.on('error', error => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Execute a worktree post-creation hook
+ */
+export async function executeWorktreePostCreationHook(command, worktree, gitRoot, baseBranch) {
+    const environment = {
+        CCMANAGER_WORKTREE_PATH: worktree.path,
+        CCMANAGER_WORKTREE_BRANCH: worktree.branch || 'unknown',
+        CCMANAGER_GIT_ROOT: gitRoot,
+    };
+    if (baseBranch) {
+        environment.CCMANAGER_BASE_BRANCH = baseBranch;
+    }
+    try {
+        await executeHook(command, worktree.path, environment);
+    }
+    catch (error) {
+        // Log error but don't throw - hooks should not break the main flow
+        console.error(`Failed to execute post-creation hook: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Execute a session status change hook
+ */
+export async function executeStatusHook(oldState, newState, session) {
+    const statusHooks = configurationManager.getStatusHooks();
+    const hook = statusHooks[newState];
+    if (hook && hook.enabled && hook.command) {
+        // Get branch information
+        const worktreeService = new WorktreeService();
+        const worktrees = worktreeService.getWorktrees();
+        const worktree = worktrees.find(wt => wt.path === session.worktreePath);
+        const branch = worktree?.branch || 'unknown';
+        // Build environment for status hook
+        const environment = {
+            CCMANAGER_WORKTREE_PATH: session.worktreePath,
+            CCMANAGER_WORKTREE_BRANCH: branch,
+            CCMANAGER_GIT_ROOT: session.worktreePath, // For status hooks, we use worktree path as cwd
+            CCMANAGER_OLD_STATE: oldState,
+            CCMANAGER_NEW_STATE: newState,
+            CCMANAGER_SESSION_ID: session.id,
+        };
+        // Execute the hook command in the session's worktree directory
+        try {
+            await executeHook(hook.command, session.worktreePath, environment);
+        }
+        catch (error) {
+            // Log error but don't throw - hooks should not break the main flow
+            console.error(`Failed to execute ${newState} hook: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/utils/hookExecutor.test.d.ts

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

package/dist/utils/hookExecutor.test.js

@@ -0,0 +1,405 @@
+import { describe, it, expect, vi } from 'vitest';
+import { executeHook, executeWorktreePostCreationHook, executeStatusHook, } from './hookExecutor.js';
+import { mkdtemp, rm, readFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { configurationManager } from '../services/configurationManager.js';
+import { WorktreeService } from '../services/worktreeService.js';
+// Mock the configurationManager
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: {
+        getStatusHooks: vi.fn(),
+    },
+}));
+// Mock the WorktreeService
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn(),
+}));
+// Note: This file contains integration tests that execute real commands
+describe('hookExecutor Integration Tests', () => {
+    describe('executeHook (real execution)', () => {
+        it('should execute a simple echo command', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: tmpDir,
+            };
+            try {
+                // Act & Assert - should not throw
+                await expect(executeHook('echo "Test successful"', tmpDir, environment)).resolves.toBeUndefined();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should reject when command fails', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: tmpDir,
+            };
+            try {
+                // Act & Assert
+                await expect(executeHook('exit 1', tmpDir, environment)).rejects.toThrow();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should include stderr in error message when command fails', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: tmpDir,
+            };
+            try {
+                // Act & Assert - command that writes to stderr and exits with error
+                await expect(executeHook('>&2 echo "Error details here"; exit 1', tmpDir, environment)).rejects.toThrow('Hook exited with code 1\nStderr: Error details here\n');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should verify stderr handling in error messages', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: tmpDir,
+            };
+            try {
+                // Test with multiline stderr
+                try {
+                    await executeHook('>&2 echo "Line 1"; >&2 echo "Line 2"; exit 3', tmpDir, environment);
+                    expect.fail('Should have thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toContain('Hook exited with code 3');
+                    expect(error.message).toContain('Stderr: Line 1\nLine 2');
+                }
+                // Test with empty stderr
+                try {
+                    await executeHook('exit 4', tmpDir, environment);
+                    expect.fail('Should have thrown');
+                }
+                catch (error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toBe('Hook exited with code 4');
+                }
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should ignore stderr when command succeeds', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: tmpDir,
+            };
+            try {
+                // Act - command that writes to stderr but exits successfully
+                // Should not throw even though there's stderr output
+                await expect(executeHook('>&2 echo "Warning message"; exit 0', tmpDir, environment)).resolves.toBeUndefined();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should execute hook in the specified working directory', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-cwd-test-'));
+            const outputFile = join(tmpDir, 'cwd.txt');
+            const environment = {
+                CCMANAGER_WORKTREE_PATH: tmpDir,
+                CCMANAGER_WORKTREE_BRANCH: 'test-branch',
+                CCMANAGER_GIT_ROOT: '/some/other/path',
+            };
+            try {
+                // Act - write current directory to file
+                await executeHook(`pwd > "${outputFile}"`, tmpDir, environment);
+                // Read the output
+                const { readFile } = await import('fs/promises');
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - should be executed in tmpDir
+                expect(output.trim()).toBe(tmpDir);
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+    });
+    describe('executeWorktreePostCreationHook (real execution)', () => {
+        it('should not throw even when command fails', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-test-'));
+            const worktree = {
+                path: tmpDir,
+                branch: 'test-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            try {
+                // Act & Assert - should not throw even with failing command
+                await expect(executeWorktreePostCreationHook('exit 1', worktree, tmpDir, 'main')).resolves.toBeUndefined();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should execute worktree hook in the worktree path by default', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-worktree-test-'));
+            const outputFile = join(tmpDir, 'cwd.txt');
+            const worktree = {
+                path: tmpDir,
+                branch: 'test-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            const gitRoot = '/different/git/root';
+            try {
+                // Act - write current directory to file
+                await executeWorktreePostCreationHook(`pwd > "${outputFile}"`, worktree, gitRoot, 'main');
+                // Read the output
+                const { readFile } = await import('fs/promises');
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - should be executed in worktree path, not git root
+                expect(output.trim()).toBe(tmpDir);
+                expect(output.trim()).not.toBe(gitRoot);
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should allow changing to git root using environment variable', async () => {
+            // Arrange
+            const tmpWorktreeDir = await mkdtemp(join(tmpdir(), 'hook-worktree-'));
+            const tmpGitRootDir = await mkdtemp(join(tmpdir(), 'hook-gitroot-'));
+            const outputFile = join(tmpWorktreeDir, 'gitroot.txt');
+            const worktree = {
+                path: tmpWorktreeDir,
+                branch: 'test-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            try {
+                // Act - change to git root and write its path
+                await executeWorktreePostCreationHook(`cd "$CCMANAGER_GIT_ROOT" && pwd > "${outputFile}"`, worktree, tmpGitRootDir, 'main');
+                // Read the output
+                const { readFile } = await import('fs/promises');
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - should have changed to git root
+                expect(output.trim()).toBe(tmpGitRootDir);
+            }
+            finally {
+                // Cleanup
+                await rm(tmpWorktreeDir, { recursive: true });
+                await rm(tmpGitRootDir, { recursive: true });
+            }
+        });
+        it('should wait for all child processes to complete', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'hook-wait-test-'));
+            const outputFile = join(tmpDir, 'delayed.txt');
+            const worktree = {
+                path: tmpDir,
+                branch: 'test-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            };
+            try {
+                // Act - execute a command that spawns a background process with a delay
+                // The background process writes to a file after a delay
+                // We use a shell command that creates a background process and then exits
+                await executeWorktreePostCreationHook(`(sleep 0.1 && echo "completed" > "${outputFile}") & wait`, worktree, tmpDir, 'main');
+                // Read the output - this should exist because we waited for the background process
+                const { readFile } = await import('fs/promises');
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - the file should contain the expected content
+                expect(output.trim()).toBe('completed');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+    });
+    describe('executeStatusHook', () => {
+        it('should wait for hook execution to complete', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'status-hook-test-'));
+            const outputFile = join(tmpDir, 'status-hook-output.txt');
+            const mockSession = {
+                id: 'test-session-123',
+                worktreePath: tmpDir, // Use tmpDir as the worktree path
+                process: {},
+                terminal: {},
+                output: [],
+                outputHistory: [],
+                state: 'idle',
+                stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
+                lastActivity: new Date(),
+                isActive: true,
+            };
+            // Mock WorktreeService to return a worktree with the tmpDir path
+            vi.mocked(WorktreeService).mockImplementation(() => ({
+                getWorktrees: vi.fn(() => [
+                    {
+                        path: tmpDir,
+                        branch: 'test-branch',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+            }));
+            // Configure mock to return a hook that writes to a file with delay
+            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+                busy: {
+                    enabled: true,
+                    command: `sleep 0.1 && echo "Hook executed" > "${outputFile}"`,
+                },
+                idle: { enabled: false, command: '' },
+                waiting_input: { enabled: false, command: '' },
+            });
+            try {
+                // Act - execute the hook and await it
+                await executeStatusHook('idle', 'busy', mockSession);
+                // Assert - file should exist because we awaited the hook
+                const content = await readFile(outputFile, 'utf-8');
+                expect(content.trim()).toBe('Hook executed');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should handle hook execution errors gracefully', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'status-hook-test-'));
+            const mockSession = {
+                id: 'test-session-456',
+                worktreePath: tmpDir, // Use tmpDir as the worktree path
+                process: {},
+                terminal: {},
+                output: [],
+                outputHistory: [],
+                state: 'idle',
+                stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
+                lastActivity: new Date(),
+                isActive: true,
+            };
+            // Mock WorktreeService to return a worktree with the tmpDir path
+            vi.mocked(WorktreeService).mockImplementation(() => ({
+                getWorktrees: vi.fn(() => [
+                    {
+                        path: tmpDir,
+                        branch: 'test-branch',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+            }));
+            // Configure mock to return a hook that fails
+            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+                busy: {
+                    enabled: true,
+                    command: 'exit 1',
+                },
+                idle: { enabled: false, command: '' },
+                waiting_input: { enabled: false, command: '' },
+            });
+            try {
+                // Act & Assert - should not throw even when hook fails
+                await expect(executeStatusHook('idle', 'busy', mockSession)).resolves.toBeUndefined();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should not execute disabled hooks', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'status-hook-test-'));
+            const outputFile = join(tmpDir, 'should-not-exist.txt');
+            const mockSession = {
+                id: 'test-session-789',
+                worktreePath: tmpDir, // Use tmpDir as the worktree path
+                process: {},
+                terminal: {},
+                output: [],
+                outputHistory: [],
+                state: 'idle',
+                stateCheckInterval: undefined,
+                isPrimaryCommand: true,
+                commandConfig: undefined,
+                detectionStrategy: 'claude',
+                devcontainerConfig: undefined,
+                pendingState: undefined,
+                pendingStateStart: undefined,
+                lastActivity: new Date(),
+                isActive: true,
+            };
+            // Mock WorktreeService to return a worktree with the tmpDir path
+            vi.mocked(WorktreeService).mockImplementation(() => ({
+                getWorktrees: vi.fn(() => [
+                    {
+                        path: tmpDir,
+                        branch: 'test-branch',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    },
+                ]),
+            }));
+            // Configure mock to return a disabled hook
+            vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
+                busy: {
+                    enabled: false,
+                    command: `echo "Should not run" > "${outputFile}"`,
+                },
+                idle: { enabled: false, command: '' },
+                waiting_input: { enabled: false, command: '' },
+            });
+            try {
+                // Act
+                await executeStatusHook('idle', 'busy', mockSession);
+                // Assert - file should not exist because hook was disabled
+                await expect(readFile(outputFile, 'utf-8')).rejects.toThrow();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+    });
+});

package/dist/utils/worktreeUtils.test.js

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

package/package.json

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

package/dist/components/ConfigureHooks.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ConfigureHooksProps {
-    onComplete: () => void;
-}
-declare const ConfigureHooks: React.FC<ConfigureHooksProps>;
-export default ConfigureHooks;