ccmanager 2.0.0 → 2.2.0

package/dist/services/sessionManager.js

@@ -4,7 +4,7 @@ import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
-import { WorktreeService } from './worktreeService.js';
+import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
@@ -188,13 +188,13 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
-        // Set up interval-based state detection
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
             const newState = this.detectTerminalState(session);
             if (newState !== oldState) {
                 session.state = newState;
-                this.executeStatusHook(oldState, newState, session);
+                // Execute status hook asynchronously (non-blocking)
+                void executeStatusHook(oldState, newState, session);
                 this.emit('sessionStateChanged', session);
             }
         }, 100); // Check every 100ms
@@ -252,36 +252,6 @@ export class SessionManager extends EventEmitter {
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
-    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';
-            // Execute the hook command in the session's worktree directory
-            exec(hook.command, {
-                cwd: session.worktreePath,
-                env: {
-                    ...process.env,
-                    CCMANAGER_OLD_STATE: oldState,
-                    CCMANAGER_NEW_STATE: newState,
-                    CCMANAGER_WORKTREE: session.worktreePath,
-                    CCMANAGER_WORKTREE_BRANCH: branch,
-                    CCMANAGER_SESSION_ID: session.id,
-                },
-            }, (error, _stdout, stderr) => {
-                if (error) {
-                    console.error(`Failed to execute ${newState} hook: ${error.message}`);
-                }
-                if (stderr) {
-                    console.error(`Hook stderr: ${stderr}`);
-                }
-            });
-        }
-    }
     async createSessionWithDevcontainer(worktreePath, devcontainerConfig, presetId) {
         // Check if session already exists
         const existing = this.sessions.get(worktreePath);

package/dist/services/worktreeService.d.ts

@@ -10,10 +10,10 @@ export declare class WorktreeService {
     getGitRootPath(): string;
     getDefaultBranch(): string;
     getAllBranches(): 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/services/worktreeService.js

@@ -3,6 +3,8 @@ import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
+import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
+import { configurationManager } from './configurationManager.js';
 const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
@@ -188,7 +190,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
+    async createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -239,6 +241,21 @@ export class WorktreeService {
                     console.error('Warning: Failed to copy .claude directory:', error);
                 }
             }
+            // Execute post-creation hook if configured
+            const worktreeHooks = configurationManager.getWorktreeHooks();
+            if (worktreeHooks.post_creation?.enabled &&
+                worktreeHooks.post_creation?.command) {
+                // Create a worktree object for the hook
+                const newWorktree = {
+                    path: resolvedPath,
+                    branch: branch,
+                    isMainWorktree: false,
+                    hasSession: false,
+                };
+                // Execute the hook synchronously (blocking)
+                // Wait for the hook to complete before returning
+                await executeWorktreePostCreationHook(worktreeHooks.post_creation.command, newWorktree, this.gitRootPath, baseBranch);
+            }
             return { success: true };
         }
         catch (error) {

package/dist/services/worktreeService.test.js

@@ -1,7 +1,9 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 import { existsSync, statSync } from 'fs';
+import { configurationManager } from './configurationManager.js';
+import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -14,10 +16,22 @@ vi.mock('./worktreeConfigManager.js', () => ({
         reset: vi.fn(),
     },
 }));
+// Mock configurationManager
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getWorktreeHooks: vi.fn(),
+    },
+}));
+// Mock HookExecutor
+vi.mock('../utils/hookExecutor.js', () => ({
+    executeWorktreePostCreationHook: vi.fn(),
+}));
 // Get the mocked function with proper typing
 const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
+const mockedGetWorktreeHooks = vi.mocked(configurationManager.getWorktreeHooks);
+const mockedExecuteHook = vi.mocked(executeWorktreePostCreationHook);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
@@ -29,6 +43,8 @@ describe('WorktreeService', () => {
             }
             throw new Error('Command not mocked: ' + cmd);
         });
+        // Default mock for getWorktreeHooks to return empty config
+        mockedGetWorktreeHooks.mockReturnValue({});
         service = new WorktreeService('/fake/path');
     });
     describe('getGitRootPath', () => {
@@ -177,7 +193,7 @@ origin/feature/test
         });
     });
     describe('createWorktree', () => {
-        it('should create worktree with base branch when branch does not exist', () => {
+        it('should create worktree with base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -190,11 +206,11 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "develop"', expect.any(Object));
         });
-        it('should create worktree without base branch when branch exists', () => {
+        it('should create worktree without base branch when branch exists', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -207,11 +223,11 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
+            const result = await service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add "/path/to/worktree" "existing-feature"', expect.any(Object));
         });
-        it('should create worktree from specified base branch when branch does not exist', () => {
+        it('should create worktree from specified base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -224,7 +240,7 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'main');
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'main');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "main"', expect.any(Object));
         });
@@ -389,4 +405,143 @@ branch refs/heads/other-branch
             expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
         });
     });
+    describe('Worktree Hook Execution', () => {
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should execute post-creation hook when worktree is created', async () => {
+            // Arrange
+            const hookCommand = 'echo "Worktree created: $CCMANAGER_WORKTREE_PATH"';
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: hookCommand,
+                    enabled: true,
+                },
+            });
+            mockedExecuteHook.mockResolvedValue(undefined);
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).toHaveBeenCalledWith(hookCommand, expect.objectContaining({
+                path: '/fake/path/feature-branch-dir',
+                branch: 'feature-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            }), '/fake/path', 'main');
+        });
+        it('should not execute hook when disabled', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: 'echo "Should not run"',
+                    enabled: false,
+                },
+            });
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).not.toHaveBeenCalled();
+        });
+        it('should not execute hook when not configured', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({});
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).not.toHaveBeenCalled();
+        });
+        it('should not fail worktree creation if hook execution fails', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: 'failing-command',
+                    enabled: true,
+                },
+            });
+            // The real executeWorktreePostCreationHook doesn't throw, it catches errors internally
+            // So the mock should resolve, not reject
+            mockedExecuteHook.mockResolvedValue(undefined);
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Allow async operations to complete
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedExecuteHook).toHaveBeenCalled();
+        });
+    });
 });

package/dist/types/index.d.ts

@@ -54,6 +54,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 +91,7 @@ export interface DevcontainerConfig {
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
+    worktreeHooks?: WorktreeHookConfig;
     worktree?: WorktreeConfig;
     command?: CommandConfig;
     commandPresets?: CommandPresetsConfig;
@@ -126,10 +134,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 {};