ccmanager 1.2.0 → 1.3.1

package/dist/services/sessionManager.test.js

@@ -1,10 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { SessionManager } from './sessionManager.js';
-import { configurationManager } from './configurationManager.js';
 import { spawn } from 'node-pty';
 import { EventEmitter } from 'events';
+import { exec } from 'child_process';
 // Mock node-pty
 vi.mock('node-pty');
+// Mock child_process
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+}));
 // Mock configuration manager
 vi.mock('./configurationManager.js', () => ({
     configurationManager: {
@@ -28,6 +31,10 @@ vi.mock('@xterm/headless', () => ({
         })),
     },
 }));
+// Mock worktreeService
+vi.mock('./worktreeService.js', () => ({
+    WorktreeService: vi.fn(),
+}));
 // Create a mock IPty class
 class MockPty extends EventEmitter {
     constructor() {
@@ -71,53 +78,140 @@ class MockPty extends EventEmitter {
 describe('SessionManager', () => {
     let sessionManager;
     let mockPty;
-    beforeEach(() => {
+    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('createSession with command configuration', () => {
-        it('should create session with default command when no args configured', async () => {
-            // Setup mock configuration
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+    describe('createSessionWithPreset', () => {
+        it('should use default preset when no preset ID specified', 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
-            await sessionManager.createSession('/test/worktree');
-            // Verify spawn was called with correct arguments
-            expect(spawn).toHaveBeenCalledWith('claude', [], {
+            // Create session with preset
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg'], {
                 name: 'xterm-color',
                 cols: expect.any(Number),
                 rows: expect.any(Number),
                 cwd: '/test/worktree',
                 env: process.env,
             });
-            // Session creation verified by spawn being called
         });
-        it('should create session with configured arguments', async () => {
-            // Setup mock configuration with args
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+        it('should use specific preset when ID provided', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+                id: '2',
+                name: 'Development',
                 command: 'claude',
-                args: ['--resume', '--model', 'opus'],
+                args: ['--resume', '--dev'],
+                fallbackArgs: ['--no-mcp'],
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
-            await sessionManager.createSession('/test/worktree');
-            // Verify spawn was called with configured arguments
-            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--model', 'opus'], expect.objectContaining({
+            // Create session with specific preset
+            await sessionManager.createSessionWithPreset('/test/worktree', '2');
+            // Verify getPresetById was called with correct ID
+            expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
+            // Verify spawn was called with preset config
+            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev'], {
+                name: 'xterm-color',
+                cols: expect.any(Number),
+                rows: expect.any(Number),
                 cwd: '/test/worktree',
-            }));
-            // Session creation verified by spawn being called
+                env: process.env,
+            });
+        });
+        it('should fall back to default preset if specified preset not found', async () => {
+            // Setup mocks
+            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session with non-existent preset
+            await sessionManager.createSessionWithPreset('/test/worktree', 'invalid');
+            // Verify fallback to default preset
+            expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
+            expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
+        });
+        it('should throw error when spawn fails with preset', async () => {
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
+            });
+            // Mock spawn to fail
+            vi.mocked(spawn).mockImplementation(() => {
+                throw new Error('Command failed');
+            });
+            // 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
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session twice
+            const session1 = await sessionManager.createSessionWithPreset('/test/worktree');
+            const session2 = await sessionManager.createSessionWithPreset('/test/worktree');
+            // Should return the same session
+            expect(session1).toBe(session2);
+            // Spawn should only be called once
+            expect(spawn).toHaveBeenCalledTimes(1);
+        });
+        it('should throw error when spawn fails with fallback args', async () => {
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'nonexistent-command',
+                args: ['--flag1'],
+                fallbackArgs: ['--flag2'],
+            });
+            // Mock spawn to always throw error
+            vi.mocked(spawn).mockImplementation(() => {
+                throw new Error('Command not found');
+            });
+            // Expect createSessionWithPreset to throw the original error
+            await expect(sessionManager.createSessionWithPreset('/test/worktree')).rejects.toThrow('Command not found');
         });
         it('should use fallback args when main command exits with code 1', async () => {
-            // Setup mock configuration with fallback
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
                 command: 'claude',
                 args: ['--invalid-flag'],
                 fallbackArgs: ['--resume'],
@@ -130,7 +224,7 @@ describe('SessionManager', () => {
                 .mockReturnValueOnce(firstMockPty)
                 .mockReturnValueOnce(secondMockPty);
             // Create session
-            const session = await sessionManager.createSession('/test/worktree');
+            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' }));
@@ -145,38 +239,11 @@ describe('SessionManager', () => {
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
         });
-        it('should throw error when spawn fails and no fallback configured', async () => {
-            // Setup mock configuration without fallback
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
-                command: 'claude',
-                args: ['--invalid-flag'],
-            });
-            // Mock spawn to throw error
-            vi.mocked(spawn).mockImplementation(() => {
-                throw new Error('spawn failed');
-            });
-            // Expect createSession to throw
-            await expect(sessionManager.createSession('/test/worktree')).rejects.toThrow('spawn failed');
-        });
-        it('should handle custom command configuration', async () => {
-            // Setup mock configuration with custom command
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
-                command: 'my-custom-claude',
-                args: ['--config', '/path/to/config'],
-            });
-            // Setup spawn mock
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
-            await sessionManager.createSession('/test/worktree');
-            // Verify spawn was called with custom command
-            expect(spawn).toHaveBeenCalledWith('my-custom-claude', ['--config', '/path/to/config'], expect.objectContaining({
-                cwd: '/test/worktree',
-            }));
-            // Session creation verified by spawn being called
-        });
         it('should not use fallback if main command succeeds', async () => {
-            // Setup mock configuration with fallback
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+            // Setup mock preset with fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
                 command: 'claude',
                 args: ['--resume'],
                 fallbackArgs: ['--other-flag'],
@@ -184,53 +251,90 @@ describe('SessionManager', () => {
             // Setup spawn mock - process doesn't exit early
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create session
-            await sessionManager.createSession('/test/worktree');
+            await sessionManager.createSessionWithPreset('/test/worktree');
             // Wait a bit to ensure no early exit
             await new Promise(resolve => setTimeout(resolve, 600));
             // Verify only one spawn attempt
             expect(spawn).toHaveBeenCalledTimes(1);
             expect(spawn).toHaveBeenCalledWith('claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
-            // Session creation verified by spawn being called
         });
-        it('should return existing session if already created', async () => {
-            // Setup mock configuration
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+        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({
+                id: '1',
+                name: 'Main',
+                command: 'my-custom-claude',
+                args: ['--config', '/path/to/config'],
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session twice
-            const session1 = await sessionManager.createSession('/test/worktree');
-            const session2 = await sessionManager.createSession('/test/worktree');
-            // Should return the same session
-            expect(session1).toBe(session2);
-            // Spawn should only be called once
-            expect(spawn).toHaveBeenCalledTimes(1);
+            // Create session
+            await sessionManager.createSessionWithPreset('/test/worktree');
+            // Verify spawn was called with custom command
+            expect(spawn).toHaveBeenCalledWith('my-custom-claude', ['--config', '/path/to/config'], expect.objectContaining({
+                cwd: '/test/worktree',
+            }));
         });
-        it('should throw error when spawn fails with fallback args', async () => {
-            // Setup mock configuration with fallback
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
-                command: 'nonexistent-command',
-                args: ['--flag1'],
-                fallbackArgs: ['--flag2'],
+        it('should throw error when spawn fails and no fallback configured', async () => {
+            // Setup mock preset without fallback
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--invalid-flag'],
             });
-            // Mock spawn to always throw error
+            // Mock spawn to throw error
             vi.mocked(spawn).mockImplementation(() => {
-                throw new Error('Command not found');
+                throw new Error('spawn failed');
             });
-            // Expect createSession to throw the original error
-            await expect(sessionManager.createSession('/test/worktree')).rejects.toThrow('Command not found');
+            // Expect createSessionWithPreset to throw
+            await expect(sessionManager.createSessionWithPreset('/test/worktree')).rejects.toThrow('spawn failed');
         });
     });
     describe('session lifecycle', () => {
         it('should destroy session and clean up resources', async () => {
             // Setup
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create and destroy session
-            await sessionManager.createSession('/test/worktree');
+            await sessionManager.createSessionWithPreset('/test/worktree');
             sessionManager.destroySession('/test/worktree');
             // Verify cleanup
             expect(mockPty.kill).toHaveBeenCalled();
@@ -238,7 +342,9 @@ describe('SessionManager', () => {
         });
         it('should handle session exit event', async () => {
             // Setup
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
@@ -248,7 +354,7 @@ describe('SessionManager', () => {
                 exitedSession = session;
             });
             // Create session
-            const createdSession = await sessionManager.createSession('/test/worktree');
+            const createdSession = await sessionManager.createSessionWithPreset('/test/worktree');
             // Simulate process exit after successful creation
             setTimeout(() => {
                 mockPty.emit('exit', { exitCode: 0 });
@@ -259,27 +365,46 @@ describe('SessionManager', () => {
             expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
         });
     });
-    describe('createSession with presets', () => {
-        it('should use default preset when no preset ID specified', async () => {
+    describe('createSessionWithDevcontainer', () => {
+        beforeEach(() => {
+            // Reset shouldFail flag
+            const mockExec = vi.mocked(exec);
+            mockExec.shouldFail = false;
+            // Setup exec mock to work with promisify
+            mockExec.mockImplementation(((...args) => {
+                const [command, , callback] = args;
+                if (callback) {
+                    // Handle callback style
+                    if (command.includes('devcontainer up')) {
+                        if (mockExec.shouldFail) {
+                            callback(new Error('Container startup failed'));
+                        }
+                        else {
+                            callback(null, '', '');
+                        }
+                    }
+                }
+            }));
+        });
+        it('should execute devcontainer up command before creating session', async () => {
             // Setup mock preset
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
-                args: ['--preset-arg'],
+                args: ['--resume'],
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session with preset
-            await sessionManager.createSessionWithPreset('/test/worktree');
-            // Verify spawn was called with preset config
-            expect(spawn).toHaveBeenCalledWith('claude', ['--preset-arg'], {
-                name: 'xterm-color',
-                cols: expect.any(Number),
-                rows: expect.any(Number),
-                cwd: '/test/worktree',
-                env: process.env,
-            });
+            // Create session with devcontainer
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            };
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig);
+            // Verify spawn was called correctly which proves devcontainer up succeeded
+            // Verify spawn was called with devcontainer exec
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude', '--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
         });
         it('should use specific preset when ID provided', async () => {
             // Setup mock preset
@@ -288,76 +413,285 @@ describe('SessionManager', () => {
                 name: 'Development',
                 command: 'claude',
                 args: ['--resume', '--dev'],
-                fallbackArgs: ['--no-mcp'],
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session with specific preset
-            await sessionManager.createSessionWithPreset('/test/worktree', '2');
-            // Verify getPresetById was called with correct ID
+            // Create session with devcontainer and specific preset
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up',
+                execCommand: 'devcontainer exec',
+            };
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig, '2');
+            // Verify correct preset was used
             expect(configurationManager.getPresetById).toHaveBeenCalledWith('2');
-            // Verify spawn was called with preset config
-            expect(spawn).toHaveBeenCalledWith('claude', ['--resume', '--dev'], {
-                name: 'xterm-color',
-                cols: expect.any(Number),
-                rows: expect.any(Number),
-                cwd: '/test/worktree',
-                env: process.env,
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--', 'claude', '--resume', '--dev'], expect.any(Object));
+        });
+        it('should throw error when devcontainer up fails', async () => {
+            // Setup exec to fail
+            const mockExec = vi.mocked(exec);
+            mockExec.shouldFail = true;
+            // Create session with devcontainer
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up',
+                execCommand: 'devcontainer exec',
+            };
+            await expect(sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig)).rejects.toThrow('Failed to start devcontainer: Container startup failed');
+        });
+        it('should return existing session if already created', async () => {
+            // Setup mock preset
+            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
             });
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up',
+                execCommand: 'devcontainer exec',
+            };
+            // Create session twice
+            const session1 = await sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig);
+            const session2 = await sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig);
+            // Should return the same session
+            expect(session1).toBe(session2);
+            // spawn should only be called once
+            expect(spawn).toHaveBeenCalledTimes(1);
         });
-        it('should fall back to default preset if specified preset not found', async () => {
-            // Setup mocks
-            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
+        it('should handle complex exec commands with multiple arguments', async () => {
+            // Setup mock preset
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
+                args: ['--model', 'opus'],
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session with non-existent preset
-            await sessionManager.createSessionWithPreset('/test/worktree', 'invalid');
-            // Verify fallback to default preset
-            expect(configurationManager.getDefaultPreset).toHaveBeenCalled();
-            expect(spawn).toHaveBeenCalledWith('claude', [], expect.any(Object));
+            // Create session with complex exec command
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up --workspace-folder . --log-level debug',
+                execCommand: 'devcontainer exec --workspace-folder . --container-name mycontainer',
+            };
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', devcontainerConfig);
+            // Verify spawn was called with properly parsed exec command
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--container-name',
+                'mycontainer',
+                '--',
+                'claude',
+                '--model',
+                'opus',
+            ], expect.any(Object));
         });
-        it('should try fallback args with preset if main command fails', async () => {
-            // Setup mock preset with fallback
+        it('should spawn process with devcontainer exec command', async () => {
+            // Create a new session manager and reset mocks
+            vi.clearAllMocks();
+            sessionManager = new SessionManager();
             vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
-                args: ['--bad-flag'],
-                fallbackArgs: ['--good-flag'],
+                args: [],
             });
-            // Mock spawn to fail first, succeed second
-            let callCount = 0;
-            vi.mocked(spawn).mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new Error('Command failed');
+            // Setup spawn mock
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            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 mockPty;
+                return {};
             });
-            // Create session
-            await sessionManager.createSessionWithPreset('/test/worktree');
-            // Verify both attempts were made
+            await sessionManager.createSessionWithDevcontainer('/test/worktree2', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+            // Should spawn with devcontainer exec command
+            expect(spawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], expect.objectContaining({
+                cwd: '/test/worktree2',
+            }));
+        });
+        it('should use preset with devcontainer', 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 {};
+            });
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            }, 'custom-preset');
+            // Should call createSessionWithPreset internally
+            const session = sessionManager.getSession('/test/worktree');
+            expect(session).toBeDefined();
+            expect(session?.devcontainerConfig).toEqual({
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            });
+        });
+        it('should parse exec command and append preset command', 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 {};
+            });
+            const config = {
+                upCommand: 'devcontainer up --workspace-folder /path/to/project',
+                execCommand: 'devcontainer exec --workspace-folder /path/to/project --user vscode',
+            };
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', config);
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '/path/to/project',
+                '--user',
+                'vscode',
+                '--',
+                'claude',
+            ], expect.any(Object));
+        });
+        it('should handle preset with args in devcontainer', 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 {};
+            });
+            vi.mocked(configurationManager.getPresetById).mockReturnValue({
+                id: 'claude-with-args',
+                name: 'Claude with Args',
+                command: 'claude',
+                args: ['-m', 'claude-3-opus'],
+            });
+            await sessionManager.createSessionWithDevcontainer('/test/worktree', {
+                upCommand: 'devcontainer up --workspace-folder .',
+                execCommand: 'devcontainer exec --workspace-folder .',
+            }, 'claude-with-args');
+            expect(spawn).toHaveBeenCalledWith('devcontainer', [
+                'exec',
+                '--workspace-folder',
+                '.',
+                '--',
+                'claude',
+                '-m',
+                '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(1, 'claude', ['--bad-flag'], expect.any(Object));
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--good-flag'], expect.any(Object));
+            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 maintain backward compatibility with createSession', async () => {
-            // Setup legacy config
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+        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: ['--legacy'],
+                args: ['--bad-flag'],
+                fallbackArgs: ['--good-flag'],
             });
-            // Setup spawn mock
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session using legacy method
-            await sessionManager.createSession('/test/worktree');
-            // Verify legacy method still works
-            expect(spawn).toHaveBeenCalledWith('claude', ['--legacy'], expect.any(Object));
+            // 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);
         });
     });
 });