ccmanager 1.2.0 → 1.3.1

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,9 +7,18 @@ 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;
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     private setupExitHandler;
     private setupBackgroundHandler;
     private cleanupSession;
@@ -18,5 +27,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) {
@@ -107,54 +99,12 @@ export class SessionManager extends EventEmitter {
             args: preset.args,
             fallbackArgs: preset.fallbackArgs,
         };
-        // Try to spawn the process
-        let ptyProcess;
-        let isPrimaryCommand = true;
-        try {
-            ptyProcess = await this.spawn(command, args, worktreePath);
-        }
-        catch (error) {
-            // If primary command fails and we have fallback args, try them
-            if (preset.fallbackArgs) {
-                try {
-                    ptyProcess = await this.spawn(command, preset.fallbackArgs, worktreePath);
-                    isPrimaryCommand = false;
-                }
-                catch (_fallbackError) {
-                    // Both attempts failed, throw the original error
-                    throw error;
-                }
-            }
-            else {
-                // No fallback args, throw the error
-                throw error;
-            }
-        }
-        // Create virtual terminal for state detection
-        const terminal = new Terminal({
-            cols: process.stdout.columns || 80,
-            rows: process.stdout.rows || 24,
-            allowProposedApi: true,
+        // Spawn the process - fallback will be handled by setupExitHandler
+        const ptyProcess = await this.spawn(command, args, worktreePath);
+        return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+            isPrimaryCommand: true,
+            detectionStrategy: preset.detectionStrategy,
         });
-        const session = {
-            id,
-            worktreePath,
-            process: ptyProcess,
-            state: 'busy', // Session starts as busy when created
-            output: [],
-            outputHistory: [],
-            lastActivity: new Date(),
-            isActive: false,
-            terminal,
-            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;
     }
     setupDataHandler(session) {
         // This handler always runs for all data
@@ -180,13 +130,40 @@ export class SessionManager extends EventEmitter {
             }
         });
     }
+    /**
+     * Sets up exit handler for the session process.
+     * When the process exits with code 1 and it's the primary command,
+     * it will attempt to spawn a fallback process.
+     * If fallbackArgs are configured, they will be used.
+     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     */
     setupExitHandler(session) {
         session.process.onExit(async (e) => {
             // Check if we should attempt fallback
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
-                    // Spawn fallback process
-                    const fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', session.commandConfig?.fallbackArgs || [], session.worktreePath);
+                    let fallbackProcess;
+                    // Use fallback args if available, otherwise use empty args
+                    const fallbackArgs = session.commandConfig?.fallbackArgs || [];
+                    // Check if we're in a devcontainer session
+                    if (session.devcontainerConfig) {
+                        // Parse the exec command to extract arguments
+                        const execParts = session.devcontainerConfig.execCommand.split(/\s+/);
+                        const devcontainerCmd = execParts[0] || 'devcontainer';
+                        const execArgs = execParts.slice(1);
+                        // Build fallback command for devcontainer
+                        const fallbackFullArgs = [
+                            ...execArgs,
+                            '--',
+                            session.commandConfig?.command || 'claude',
+                            ...fallbackArgs,
+                        ];
+                        fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
+                    }
+                    else {
+                        // Regular fallback without devcontainer
+                        fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', fallbackArgs, session.worktreePath);
+                    }
                     // Replace the process
                     session.process = fallbackProcess;
                     session.isPrimaryCommand = false;
@@ -304,6 +281,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 - fallback will be handled by setupExitHandler
+        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()) {