ccmanager 1.2.0 → 1.3.0

package/README.md

@@ -19,6 +19,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Command presets with automatic fallback support
 - Configurable state detection strategies for different CLI tools
 - Status change hooks for automation and notifications
+- Devcontainer integration
 
 ## Why CCManager over Claude Squad?
 
@@ -177,6 +178,35 @@ CCManager can automatically generate worktree directory paths based on branch na
 
 For detailed configuration and examples, see [docs/worktree-auto-directory.md](docs/worktree-auto-directory.md).
 
+## Devcontainer Integration
+
+CCManager supports running AI assistant sessions inside devcontainers while keeping the manager itself on the host machine. This enables sandboxed development environments with restricted network access while maintaining host-level notifications and automation.
+
+### Features
+
+- **Host-based management**: CCManager runs on your host machine, managing sessions inside containers
+- **Seamless integration**: All existing features (presets, status hooks, etc.) work with devcontainers
+- **Security-focused**: Compatible with Anthropic's recommended devcontainer configurations
+- **Persistent state**: Configuration and history persist across container recreations
+
+### Usage
+
+```bash
+# Start CCManager with devcontainer support
+npx ccmanager --devc-up-command "<your devcontainer up command>" \
+              --devc-exec-command "<your devcontainer exec command>"
+```
+
+The devcontainer integration requires both commands:
+- `--devc-up-command`: Any command to start the devcontainer
+- `--devc-exec-command`: Any command to execute inside the container
+
+### Benefits
+
+- **Safe experimentation**: Run commands like `claude --dangerously-skip-permissions` without risk
+
+For detailed setup and configuration, see [docs/devcontainer.md](docs/devcontainer.md).
+
 ## Git Worktree Configuration
 
 CCManager can display enhanced git status information for each worktree when Git's worktree configuration extension is enabled.

package/dist/cli.d.ts

@@ -1,2 +1,9 @@
 #!/usr/bin/env node
-export {};
+export declare const parsedArgs: import("meow").Result<{
+    devcUpCommand: {
+        type: "string";
+    };
+    devcExecCommand: {
+        type: "string";
+    };
+}>;

package/dist/cli.js

@@ -4,19 +4,35 @@ import { render } from 'ink';
 import meow from 'meow';
 import App from './components/App.js';
 import { worktreeConfigManager } from './services/worktreeConfigManager.js';
-meow(`
+const cli = meow(`
 	Usage
 	  $ ccmanager
 
 	Options
-	  --help     Show help
-	  --version  Show version
+	  --help                Show help
+	  --version             Show version
+	  --devc-up-command     Command to start devcontainer
+	  --devc-exec-command   Command to execute in devcontainer
 
 	Examples
 	  $ ccmanager
+	  $ ccmanager --devc-up-command "devcontainer up --workspace-folder ." --devc-exec-command "devcontainer exec --workspace-folder ."
 `, {
     importMeta: import.meta,
+    flags: {
+        devcUpCommand: {
+            type: 'string',
+        },
+        devcExecCommand: {
+            type: 'string',
+        },
+    },
 });
+// Validate devcontainer arguments using XOR
+if (!!cli.flags.devcUpCommand !== !!cli.flags.devcExecCommand) {
+    console.error('Error: Both --devc-up-command and --devc-exec-command must be provided together');
+    process.exit(1);
+}
 // Check if we're in a TTY environment
 if (!process.stdin.isTTY || !process.stdout.isTTY) {
     console.error('Error: ccmanager must be run in an interactive terminal (TTY)');
@@ -24,4 +40,15 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
 }
 // Initialize worktree config manager
 worktreeConfigManager.initialize();
-render(React.createElement(App, null));
+// Prepare devcontainer config
+const devcontainerConfig = cli.flags.devcUpCommand && cli.flags.devcExecCommand
+    ? {
+        upCommand: cli.flags.devcUpCommand,
+        execCommand: cli.flags.devcExecCommand,
+    }
+    : undefined;
+// Pass config to App
+const appProps = devcontainerConfig ? { devcontainerConfig } : {};
+render(React.createElement(App, { ...appProps }));
+// Export for testing
+export const parsedArgs = cli;

package/dist/components/App.d.ts

@@ -1,3 +1,7 @@
 import React from 'react';
-declare const App: React.FC;
+import { DevcontainerConfig } from '../types/index.js';
+interface AppProps {
+    devcontainerConfig?: DevcontainerConfig;
+}
+declare const App: React.FC<AppProps>;
 export default App;

package/dist/components/App.js

@@ -11,7 +11,7 @@ import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { configurationManager } from '../services/configurationManager.js';
-const App = () => {
+const App = ({ devcontainerConfig }) => {
     const { exit } = useApp();
     const [view, setView] = useState('menu');
     const [sessionManager] = useState(() => new SessionManager());
@@ -87,7 +87,12 @@ const App = () => {
             }
             try {
                 // Use preset-based session creation with default preset
-                session = await sessionManager.createSessionWithPreset(worktree.path);
+                if (devcontainerConfig) {
+                    session = await sessionManager.createSessionWithDevcontainer(worktree.path, devcontainerConfig);
+                }
+                else {
+                    session = await sessionManager.createSessionWithPreset(worktree.path);
+                }
             }
             catch (error) {
                 setError(`Failed to create session: ${error}`);
@@ -102,7 +107,13 @@ const App = () => {
             return;
         try {
             // Create session with selected preset
-            const session = await sessionManager.createSessionWithPreset(selectedWorktree.path, presetId);
+            let session;
+            if (devcontainerConfig) {
+                session = await sessionManager.createSessionWithDevcontainer(selectedWorktree.path, devcontainerConfig, presetId);
+            }
+            else {
+                session = await sessionManager.createSessionWithPreset(selectedWorktree.path, presetId);
+            }
             setActiveSession(session);
             setView('session');
             setSelectedWorktree(null);
@@ -120,7 +131,7 @@ const App = () => {
     };
     const handleReturnToMenu = () => {
         setActiveSession(null);
-        setError(null);
+        // Don't clear error here - let user dismiss it manually
         // Add a small delay to ensure Session cleanup completes
         setTimeout(() => {
             setView('menu');
@@ -210,7 +221,7 @@ const App = () => {
         handleReturnToMenu();
     };
     if (view === 'menu') {
-        return (React.createElement(Menu, { key: menuKey, sessionManager: sessionManager, onSelectWorktree: handleSelectWorktree }));
+        return (React.createElement(Menu, { key: menuKey, sessionManager: sessionManager, onSelectWorktree: handleSelectWorktree, error: error, onDismissError: () => setError(null) }));
     }
     if (view === 'session' && activeSession) {
         return (React.createElement(Box, { flexDirection: "column" },

package/dist/components/Menu.d.ts

@@ -4,6 +4,8 @@ import { SessionManager } from '../services/sessionManager.js';
 interface MenuProps {
     sessionManager: SessionManager;
     onSelectWorktree: (worktree: Worktree) => void;
+    error?: string | null;
+    onDismissError?: () => void;
 }
 declare const Menu: React.FC<MenuProps>;
 export default Menu;

package/dist/components/Menu.js

@@ -5,7 +5,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIcons.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
 import { prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
-const Menu = ({ sessionManager, onSelectWorktree }) => {
+const Menu = ({ sessionManager, onSelectWorktree, error, onDismissError, }) => {
     const [baseWorktrees, setBaseWorktrees] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState(null);
     const worktrees = useGitStatus(baseWorktrees, defaultBranch);
@@ -82,6 +82,11 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
     }, [worktrees, sessions, defaultBranch]);
     // Handle hotkeys
     useInput((input, _key) => {
+        // Dismiss error on any key press when error is shown
+        if (error && onDismissError) {
+            onDismissError();
+            return;
+        }
         const keyPressed = input.toLowerCase();
         // Handle number keys 0-9 for worktree selection (first 10 only)
         if (/^[0-9]$/.test(keyPressed)) {
@@ -198,7 +203,13 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             React.createElement(Text, { bold: true, color: "green" }, "CCManager - Claude Code Worktree Manager")),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Select a worktree to start or resume a Claude Code session:")),
-        React.createElement(SelectInput, { items: items, onSelect: handleSelect, isFocused: true }),
+        React.createElement(SelectInput, { items: items, onSelect: handleSelect, isFocused: !error }),
+        error && (React.createElement(Box, { marginTop: 1, paddingX: 1, borderStyle: "round", borderColor: "red" },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: "red", bold: true },
+                    "Error: ",
+                    error),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Press any key to dismiss")))),
         React.createElement(Box, { marginTop: 1, flexDirection: "column" },
             React.createElement(Text, { dimColor: true },
                 "Status: ",

package/dist/integration-tests/devcontainer.integration.test.d.ts

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

package/dist/integration-tests/devcontainer.integration.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SessionManager } from '../services/sessionManager.js';
+import { spawn } from 'node-pty';
+import { exec } from 'child_process';
+// Mock modules
+vi.mock('node-pty');
+vi.mock('child_process');
+vi.mock('util', () => ({
+    promisify: vi.fn((fn) => {
+        return (cmd, options) => {
+            return new Promise((resolve, reject) => {
+                const callback = (err, stdout, stderr) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve({ stdout, stderr });
+                    }
+                };
+                // Call the original function with the promisified callback
+                fn(cmd, options, callback);
+            });
+        };
+    }),
+}));
+vi.mock('../services/configurationManager.js', () => ({
+    configurationManager: {
+        getDefaultPreset: vi.fn(() => ({
+            id: 'claude',
+            name: 'Claude',
+            command: 'claude',
+            args: [],
+        })),
+        getPresetById: vi.fn(),
+    },
+}));
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn(),
+}));
+const mockSpawn = vi.mocked(spawn);
+const mockExec = vi.mocked(exec);
+describe('Devcontainer Integration', () => {
+    let sessionManager;
+    let mockPty;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        sessionManager = new SessionManager();
+        // Mock PTY process
+        mockPty = {
+            onData: vi.fn(),
+            onExit: vi.fn(),
+            write: vi.fn(),
+            resize: vi.fn(),
+            kill: vi.fn(),
+            pid: 12345,
+            cols: 80,
+            rows: 24,
+            process: 'claude',
+        };
+        mockSpawn.mockReturnValue(mockPty);
+    });
+    it('should execute devcontainer up command before creating session', async () => {
+        const devcontainerConfig = {
+            upCommand: 'devcontainer up --workspace-folder .',
+            execCommand: 'devcontainer exec --workspace-folder .',
+        };
+        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', devcontainerConfig);
+        expect(mockExec).toHaveBeenCalledWith(devcontainerConfig.upCommand, { cwd: '/test/worktree' }, expect.any(Function));
+    });
+    it('should handle devcontainer command execution with presets', async () => {
+        const devcontainerConfig = {
+            upCommand: 'devcontainer up --workspace-folder .',
+            execCommand: 'devcontainer exec --workspace-folder .',
+        };
+        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', devcontainerConfig);
+        // Should spawn with devcontainer exec command
+        expect(mockSpawn).toHaveBeenCalledWith('devcontainer', ['exec', '--workspace-folder', '.', '--', 'claude'], expect.objectContaining({
+            cwd: '/test/worktree',
+        }));
+    });
+});

package/dist/services/sessionManager.d.ts

@@ -1,4 +1,4 @@
-import { Session, SessionManager as ISessionManager, SessionState } from '../types/index.js';
+import { Session, SessionManager as ISessionManager, SessionState, DevcontainerConfig } from '../types/index.js';
 import { EventEmitter } from 'events';
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
@@ -7,7 +7,9 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private spawn;
     detectTerminalState(session: Session): SessionState;
     constructor();
-    createSession(worktreePath: string): Promise<Session>;
+    private createSessionId;
+    private createTerminal;
+    private createSessionInternal;
     createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
     private setupDataHandler;
     private setupExitHandler;
@@ -18,5 +20,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
     private executeStatusHook;
+    createSessionWithDevcontainer(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Promise<Session>;
     destroy(): void;
 }

package/dist/services/sessionManager.js

@@ -2,10 +2,12 @@ import { spawn } from 'node-pty';
 import { EventEmitter } from 'events';
 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 { createStateDetector } from './stateDetector.js';
 const { Terminal } = pkg;
+const execAsync = promisify(exec);
 export class SessionManager extends EventEmitter {
     async spawn(command, args, worktreePath) {
         const spawnOptions = {
@@ -45,27 +47,19 @@ export class SessionManager extends EventEmitter {
         });
         this.sessions = new Map();
     }
-    async createSession(worktreePath) {
-        // Check if session already exists
-        const existing = this.sessions.get(worktreePath);
-        if (existing) {
-            return existing;
-        }
-        const id = `session-${Date.now()}-${Math.random()
-            .toString(36)
-            .substr(2, 9)}`;
-        // Get command configuration
-        const commandConfig = configurationManager.getCommandConfig();
-        const command = commandConfig.command || 'claude';
-        const args = commandConfig.args || [];
-        // Spawn the process with fallback support
-        const ptyProcess = await this.spawn(command, args, worktreePath);
-        // Create virtual terminal for state detection
-        const terminal = new Terminal({
+    createSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    createTerminal() {
+        return new Terminal({
             cols: process.stdout.columns || 80,
             rows: process.stdout.rows || 24,
             allowProposedApi: true,
         });
+    }
+    async createSessionInternal(worktreePath, ptyProcess, commandConfig, options = {}) {
+        const id = this.createSessionId();
+        const terminal = this.createTerminal();
         const session = {
             id,
             worktreePath,
@@ -76,9 +70,10 @@ export class SessionManager extends EventEmitter {
             lastActivity: new Date(),
             isActive: false,
             terminal,
-            isPrimaryCommand: true,
+            isPrimaryCommand: options.isPrimaryCommand ?? true,
             commandConfig,
-            detectionStrategy: 'claude', // Default to claude for legacy method
+            detectionStrategy: options.detectionStrategy ?? 'claude',
+            devcontainerConfig: options.devcontainerConfig,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -92,9 +87,6 @@ export class SessionManager extends EventEmitter {
         if (existing) {
             return existing;
         }
-        const id = `session-${Date.now()}-${Math.random()
-            .toString(36)
-            .substr(2, 9)}`;
         // Get preset configuration
         let preset = presetId ? configurationManager.getPresetById(presetId) : null;
         if (!preset) {
@@ -130,31 +122,10 @@ export class SessionManager extends EventEmitter {
                 throw error;
             }
         }
-        // Create virtual terminal for state detection
-        const terminal = new Terminal({
-            cols: process.stdout.columns || 80,
-            rows: process.stdout.rows || 24,
-            allowProposedApi: true,
-        });
-        const session = {
-            id,
-            worktreePath,
-            process: ptyProcess,
-            state: 'busy', // Session starts as busy when created
-            output: [],
-            outputHistory: [],
-            lastActivity: new Date(),
-            isActive: false,
-            terminal,
+        return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
             isPrimaryCommand,
-            commandConfig,
-            detectionStrategy: preset.detectionStrategy || 'claude',
-        };
-        // Set up persistent background data handler for state detection
-        this.setupBackgroundHandler(session);
-        this.sessions.set(worktreePath, session);
-        this.emit('sessionCreated', session);
-        return session;
+            detectionStrategy: preset.detectionStrategy,
+        });
     }
     setupDataHandler(session) {
         // This handler always runs for all data
@@ -304,6 +275,48 @@ export class SessionManager extends EventEmitter {
             });
         }
     }
+    async createSessionWithDevcontainer(worktreePath, devcontainerConfig, presetId) {
+        // Check if session already exists
+        const existing = this.sessions.get(worktreePath);
+        if (existing) {
+            return existing;
+        }
+        // Execute devcontainer up command first
+        try {
+            await execAsync(devcontainerConfig.upCommand, { cwd: worktreePath });
+        }
+        catch (error) {
+            throw new Error(`Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Get preset configuration
+        let preset = presetId ? configurationManager.getPresetById(presetId) : null;
+        if (!preset) {
+            preset = configurationManager.getDefaultPreset();
+        }
+        // Parse the exec command to extract arguments
+        const execParts = devcontainerConfig.execCommand.split(/\s+/);
+        const devcontainerCmd = execParts[0] || 'devcontainer'; // Should be 'devcontainer'
+        const execArgs = execParts.slice(1); // Rest of the exec command args
+        // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
+        const fullArgs = [
+            ...execArgs,
+            '--',
+            preset.command,
+            ...(preset.args || []),
+        ];
+        // Spawn the process within devcontainer
+        const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
+        const commandConfig = {
+            command: preset.command,
+            args: preset.args,
+            fallbackArgs: preset.fallbackArgs,
+        };
+        return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+            isPrimaryCommand: true,
+            detectionStrategy: preset.detectionStrategy,
+            devcontainerConfig,
+        });
+    }
     destroy() {
         // Clean up all sessions
         for (const worktreePath of this.sessions.keys()) {

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,146 @@ 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 try fallback args with preset if main command fails', 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 first, succeed second
+            let callCount = 0;
+            vi.mocked(spawn).mockImplementation(() => {
+                callCount++;
+                if (callCount === 1) {
+                    throw new Error('Command failed');
+                }
+                return mockPty;
+            });
+            // 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));
+        });
+        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 +230,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 +245,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 +257,57 @@ 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({
-                command: 'claude',
+        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 +315,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 +327,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 +338,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 +386,194 @@ 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;
                 }
-                return mockPty;
+                if (callback && typeof callback === 'function') {
+                    callback(null, 'Container started', '');
+                }
+                return {};
             });
-            // 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));
+            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 maintain backward compatibility with createSession', async () => {
-            // Setup legacy config
-            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+        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: ['--legacy'],
+                args: ['-m', 'claude-3-opus'],
             });
-            // 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));
+            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));
         });
     });
 });

package/dist/types/index.d.ts

@@ -26,10 +26,10 @@ export interface Session {
     isPrimaryCommand?: boolean;
     commandConfig?: CommandConfig;
     detectionStrategy?: StateDetectionStrategy;
+    devcontainerConfig?: DevcontainerConfig;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
-    createSession(worktreePath: string): Promise<Session>;
     getSession(worktreePath: string): Session | undefined;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
@@ -76,6 +76,10 @@ export interface CommandPresetsConfig {
     defaultPresetId: string;
     selectPresetOnStart?: boolean;
 }
+export interface DevcontainerConfig {
+    upCommand: string;
+    execCommand: string;
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;

package/package.json

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