ccmanager 1.3.0 → 1.3.1

package/dist/services/sessionManager.d.ts

@@ -12,6 +12,13 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createSessionInternal;
     createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
     private setupDataHandler;
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     private setupExitHandler;
     private setupBackgroundHandler;
     private cleanupSession;

package/dist/services/sessionManager.js

@@ -99,31 +99,10 @@ export class SessionManager extends EventEmitter {
             args: preset.args,
             fallbackArgs: preset.fallbackArgs,
         };
-        // Try to spawn the process
-        let ptyProcess;
-        let isPrimaryCommand = true;
-        try {
-            ptyProcess = await this.spawn(command, args, worktreePath);
-        }
-        catch (error) {
-            // If primary command fails and we have fallback args, try them
-            if (preset.fallbackArgs) {
-                try {
-                    ptyProcess = await this.spawn(command, preset.fallbackArgs, worktreePath);
-                    isPrimaryCommand = false;
-                }
-                catch (_fallbackError) {
-                    // Both attempts failed, throw the original error
-                    throw error;
-                }
-            }
-            else {
-                // No fallback args, throw the error
-                throw error;
-            }
-        }
+        // Spawn the process - fallback will be handled by setupExitHandler
+        const ptyProcess = await this.spawn(command, args, worktreePath);
         return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
-            isPrimaryCommand,
+            isPrimaryCommand: true,
             detectionStrategy: preset.detectionStrategy,
         });
     }
@@ -151,13 +130,40 @@ export class SessionManager extends EventEmitter {
             }
         });
     }
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     setupExitHandler(session) {
         session.process.onExit(async (e) => {
             // Check if we should attempt fallback
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
-                    // Spawn fallback process
-                    const fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', session.commandConfig?.fallbackArgs || [], session.worktreePath);
+                    let fallbackProcess;
+                    // Use fallback args if available, otherwise use empty args
+                    const fallbackArgs = session.commandConfig?.fallbackArgs || [];
+                    // Check if we're in a devcontainer session
+                    if (session.devcontainerConfig) {
+                        // Parse the exec command to extract arguments
+                        const execParts = session.devcontainerConfig.execCommand.split(/\s+/);
+                        const devcontainerCmd = execParts[0] || 'devcontainer';
+                        const execArgs = execParts.slice(1);
+                        // Build fallback command for devcontainer
+                        const fallbackFullArgs = [
+                            ...execArgs,
+                            '--',
+                            session.commandConfig?.command || 'claude',
+                            ...fallbackArgs,
+                        ];
+                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
+                    }
+                    else {
+                        // Regular fallback without devcontainer
+                        fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', fallbackArgs, session.worktreePath);
+                    }
                     // Replace the process
                     session.process = fallbackProcess;
                     session.isPrimaryCommand = false;
@@ -304,7 +310,7 @@ export class SessionManager extends EventEmitter {
             preset.command,
             ...(preset.args || []),
         ];
-        // Spawn the process within devcontainer
+        // Spawn the process within devcontainer - fallback will be handled by setupExitHandler
         const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
         const commandConfig = {
             command: preset.command,

package/dist/services/sessionManager.test.js

@@ -155,7 +155,7 @@ describe('SessionManager', () => {
             expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
             expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
         });
-        it('should try fallback args with preset if main command fails', async () => {
+        it('should throw error when spawn fails with preset', async () => {
             // Setup mock preset with fallback
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -164,21 +164,15 @@ describe('SessionManager', () => {
                 args: ['--bad-flag'],
                 fallbackArgs: ['--good-flag'],
             });
-            // Mock spawn to fail first, succeed second
-            let callCount = 0;
+            // Mock spawn to fail
             vi.mocked(spawn).mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new Error('Command failed');
-                }
-                return mockPty;
+                throw new Error('Command failed');
             });
-            // Create session
-            await sessionManager.createSessionWithPreset('/test/worktree');
-            // Verify both attempts were made
-            expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(1, 'claude', ['--bad-flag'], expect.any(Object));
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--good-flag'], expect.any(Object));
+            // Expect createSessionWithPreset to throw
+            await expect(sessionManager.createSessionWithPreset('/test/worktree')).rejects.toThrow('Command failed');
+            // Verify only one spawn attempt was made
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('claude', ['--bad-flag'], expect.any(Object));
         });
         it('should return existing session if already created', async () => {
             // Setup mock preset
@@ -264,6 +258,39 @@ describe('SessionManager', () => {
             expect(spawn).toHaveBeenCalledTimes(1);
             expect(spawn).toHaveBeenCalledWith('claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
         });
+        it('should use empty args as fallback when no fallback args specified', async () => {
+            // Setup mock preset without fallback args
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--invalid-flag'],
+                // No fallbackArgs
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            // Create session
+            const session = await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('claude', ['--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called with empty args
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', [], // Empty args
+            expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
         it('should handle custom command configuration', async () => {
             // Setup mock preset with custom command
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
@@ -575,5 +602,96 @@ describe('SessionManager', () => {
                 'claude-3-opus',
             ], expect.any(Object));
         });
+        it('should use empty args as fallback in devcontainer when no fallback args specified', async () => {
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                    options = undefined;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            // Setup preset without fallback args
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--invalid-flag'],
+                // No fallbackArgs
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            const session = await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--invalid-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called with empty args
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], // No args after claude
+            expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
+        it('should use fallback args in devcontainer when primary command exits with code 1', async () => {
+            const mockExec = vi.mocked(exec);
+            mockExec.mockImplementation((cmd, options, callback) => {
+                if (typeof options === 'function') {
+                    callback = options;
+                    options = undefined;
+                }
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
+            });
+            // Setup preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
+            });
+            // First spawn attempt - will exit with code 1
+            const firstMockPty = new MockPty();
+            // Second spawn attempt - succeeds
+            const secondMockPty = new MockPty();
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            const session = await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+            // Verify initial spawn
+            expect(spawn).toHaveBeenCalledTimes(1);
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--bad-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Simulate exit with code 1 on first attempt
+            firstMockPty.emit('exit', { exitCode: 1 });
+            // Wait for fallback to occur
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Verify fallback spawn was called
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--good-flag'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
+        });
     });
 });

package/package.json

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