ccmanager 0.1.8 → 0.1.10

package/README.md

@@ -11,6 +11,7 @@ https://github.com/user-attachments/assets/a6d80e73-dc06-4ef8-849d-e3857f6c7024
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
 - Configurable keyboard shortcuts
+- Command configuration with automatic fallback support
 - Status change hooks for automation and notifications
 
 ## Why CCManager over Claude Squad?
@@ -53,18 +54,8 @@ $ npx ccmanager
 
 ### CCMANAGER_CLAUDE_ARGS
 
-You can pass additional arguments to Claude Code sessions by setting the `CCMANAGER_CLAUDE_ARGS` environment variable:
+⚠️ **Deprecated in v0.1.9**: `CCMANAGER_CLAUDE_ARGS` is no longer supported. Please use the [Command Configuration](#command-configuration) feature instead.
 
-```bash
-# Start Claude Code with specific arguments for all sessions
-export CCMANAGER_CLAUDE_ARGS="--resume"
-npx ccmanager
-
-# Or set it inline
-CCMANAGER_CLAUDE_ARGS="--resume" npx ccmanager
-```
-
-The arguments are applied to all Claude Code sessions started by CCManager.
 
 ## Keyboard Shortcuts
 
@@ -117,6 +108,31 @@ Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.
   - Ctrl+D
   - Ctrl+[ (equivalent to Escape)
 
+
+## Command Configuration
+
+![Screenshot From 2025-06-18 16-43-27](https://github.com/user-attachments/assets/47d62483-ce81-4340-8687-8afcae93d5db)
+
+
+CCManager supports configuring the command and arguments used to run Claude Code sessions, with automatic fallback options for reliability.
+
+### Features
+
+- Configure the main command (default: `claude`)
+- Set primary arguments (e.g., `--resume`)
+- Define fallback arguments if the primary configuration fails
+- Automatic retry with no arguments as final fallback
+
+### Quick Start
+
+1. Navigate to **Configuration** → **Configure Command**
+2. Set your desired arguments (e.g., `--resume` for resuming sessions)
+3. Optionally set fallback arguments
+4. Save changes
+
+For detailed configuration options and examples, see [docs/command-config.md](docs/command-config.md).
+
+
 ## Status Change Hooks
 
 CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.

package/dist/components/App.js

@@ -46,7 +46,7 @@ const App = () => {
             sessionManager.destroy();
         };
     }, [sessionManager]);
-    const handleSelectWorktree = (worktree) => {
+    const handleSelectWorktree = async (worktree) => {
         // Check if this is the new worktree option
         if (worktree.path === '') {
             setView('new-worktree');
@@ -76,7 +76,13 @@ const App = () => {
         // Get or create session for this worktree
         let session = sessionManager.getSession(worktree.path);
         if (!session) {
-            session = sessionManager.createSession(worktree.path);
+            try {
+                session = await sessionManager.createSession(worktree.path);
+            }
+            catch (error) {
+                setError(`Failed to create session: ${error}`);
+                return;
+            }
         }
         setActiveSession(session);
         setView('session');

package/dist/components/Configuration.js

@@ -4,6 +4,7 @@ import SelectInput from 'ink-select-input';
 import ConfigureShortcuts from './ConfigureShortcuts.js';
 import ConfigureHooks from './ConfigureHooks.js';
 import ConfigureWorktree from './ConfigureWorktree.js';
+import ConfigureCommand from './ConfigureCommand.js';
 const Configuration = ({ onComplete }) => {
     const [view, setView] = useState('menu');
     const menuItems = [
@@ -19,6 +20,10 @@ const Configuration = ({ onComplete }) => {
             label: '📁  Configure Worktree Settings',
             value: 'worktree',
         },
+        {
+            label: '🚀  Configure Command',
+            value: 'command',
+        },
         {
             label: '← Back to Main Menu',
             value: 'back',
@@ -37,6 +42,9 @@ const Configuration = ({ onComplete }) => {
         else if (item.value === 'worktree') {
             setView('worktree');
         }
+        else if (item.value === 'command') {
+            setView('command');
+        }
     };
     const handleSubMenuComplete = () => {
         setView('menu');
@@ -50,6 +58,9 @@ const Configuration = ({ onComplete }) => {
     if (view === 'worktree') {
         return React.createElement(ConfigureWorktree, { onComplete: handleSubMenuComplete });
     }
+    if (view === 'command') {
+        return React.createElement(ConfigureCommand, { onComplete: handleSubMenuComplete });
+    }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configuration")),

package/dist/components/ConfigureCommand.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureCommandProps {
+    onComplete: () => void;
+}
+declare const ConfigureCommand: React.FC<ConfigureCommandProps>;
+export default ConfigureCommand;

package/dist/components/ConfigureCommand.js

@@ -0,0 +1,182 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { configurationManager } from '../services/configurationManager.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const ConfigureCommand = ({ onComplete }) => {
+    // Load current configuration once
+    const currentConfig = configurationManager.getCommandConfig();
+    const [originalConfig] = useState(currentConfig);
+    const [config, setConfig] = useState(currentConfig);
+    const [editMode, setEditMode] = useState('menu');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [inputValue, setInputValue] = useState('');
+    const [hasChanges, setHasChanges] = useState(false);
+    const menuItems = [
+        {
+            label: 'Command',
+            value: config.command,
+            key: 'command',
+            isButton: false,
+            disabled: false,
+        },
+        {
+            label: 'Arguments',
+            value: config.args?.join(' ') || '(none)',
+            key: 'args',
+            isButton: false,
+            disabled: false,
+        },
+        {
+            label: 'Fallback Arguments',
+            value: config.fallbackArgs?.join(' ') || '(none)',
+            key: 'fallbackArgs',
+            isButton: false,
+            disabled: false,
+        },
+        {
+            label: hasChanges ? '💾 Save Changes' : '💾 Save Changes (no changes)',
+            value: '',
+            key: 'save',
+            isButton: true,
+            disabled: !hasChanges,
+        },
+        {
+            label: '❌ Exit Without Saving',
+            value: '',
+            key: 'exit',
+            isButton: true,
+            disabled: false,
+        },
+    ];
+    const handleMenuNavigation = (key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : menuItems.length - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex(prev => (prev < menuItems.length - 1 ? prev + 1 : 0));
+        }
+    };
+    const getInitialInputValue = (key) => {
+        switch (key) {
+            case 'command':
+                return config.command;
+            case 'args':
+                return config.args?.join(' ') || '';
+            case 'fallbackArgs':
+                return config.fallbackArgs?.join(' ') || '';
+            default:
+                return '';
+        }
+    };
+    const handleMenuItemSelect = () => {
+        const selectedItem = menuItems[selectedIndex];
+        if (!selectedItem || selectedItem.disabled)
+            return;
+        switch (selectedItem.key) {
+            case 'save':
+                configurationManager.setCommandConfig(config);
+                onComplete();
+                break;
+            case 'exit':
+                onComplete();
+                break;
+            default:
+                if (!selectedItem.isButton) {
+                    setEditMode(selectedItem.key);
+                    setInputValue(getInitialInputValue(selectedItem.key));
+                }
+        }
+    };
+    useInput((input, key) => {
+        // Handle cancel shortcut in any mode
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            if (editMode === 'menu') {
+                onComplete(); // Exit without saving
+            }
+            else {
+                setEditMode('menu');
+                setInputValue('');
+            }
+            return;
+        }
+        // Handle menu mode inputs
+        if (editMode === 'menu') {
+            handleMenuNavigation(key);
+            if (key.return) {
+                handleMenuItemSelect();
+            }
+        }
+    });
+    const handleInputSubmit = (value) => {
+        let updatedConfig = { ...config };
+        if (editMode === 'command') {
+            updatedConfig.command = value || 'claude';
+        }
+        else if (editMode === 'args') {
+            // Parse arguments, handling empty string as no arguments
+            const args = value.trim() ? value.trim().split(/\s+/) : undefined;
+            updatedConfig.args = args;
+        }
+        else if (editMode === 'fallbackArgs') {
+            // Parse fallback arguments, handling empty string as no arguments
+            const fallbackArgs = value.trim() ? value.trim().split(/\s+/) : undefined;
+            updatedConfig.fallbackArgs = fallbackArgs;
+        }
+        // Update state only (don't save to file yet)
+        setConfig(updatedConfig);
+        // Check if there are changes
+        const hasChanges = JSON.stringify(updatedConfig) !== JSON.stringify(originalConfig);
+        setHasChanges(hasChanges);
+        // Return to menu
+        setEditMode('menu');
+        setInputValue('');
+    };
+    if (editMode !== 'menu') {
+        const titles = {
+            command: 'Enter command (e.g., claude):',
+            args: 'Enter command arguments (space-separated):',
+            fallbackArgs: 'Enter fallback arguments (space-separated):',
+        };
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Configure Command")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, titles[editMode])),
+            React.createElement(Box, null,
+                React.createElement(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleInputSubmit, placeholder: editMode === 'args' || editMode === 'fallbackArgs'
+                        ? 'e.g., --resume or leave empty'
+                        : '' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press Enter to save, ",
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    ' ',
+                    "to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Command")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Configure the command and arguments for running code sessions")),
+        hasChanges && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "yellow" }, "\u26A0\uFE0F You have unsaved changes"))),
+        React.createElement(Box, { flexDirection: "column" }, menuItems.map((item, index) => {
+            const isSelected = selectedIndex === index;
+            const isDisabled = item.disabled || false;
+            const color = isDisabled ? 'gray' : isSelected ? 'cyan' : undefined;
+            return (React.createElement(Box, { key: item.key, marginTop: item.isButton && index > 0 ? 1 : 0 },
+                React.createElement(Text, { color: color },
+                    isSelected ? '> ' : '  ',
+                    item.isButton ? (React.createElement(Text, { bold: isSelected && !isDisabled, dimColor: isDisabled }, item.label)) : (`${item.label}: ${item.value}`))));
+        })),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press \u2191\u2193 to navigate, Enter to edit,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to go back")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Note: If command fails with main args, fallback args will be tried"))));
+};
+export default ConfigureCommand;

package/dist/components/DeleteWorktree.js

@@ -75,8 +75,9 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
                 React.createElement(Text, null, "You are about to delete the following worktrees:"),
                 selectedWorktrees.map(wt => (React.createElement(Text, { key: wt.path, color: "red" },
                     "\u2022 ",
-                    wt.branch.replace('refs/heads/', ''),
-                    " (",
+                    wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
+                    ' ',
+                    "(",
                     wt.path,
                     ")")))),
             React.createElement(Text, { bold: true }, "This will also delete their branches. Are you sure?")));
@@ -90,7 +91,9 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
         worktrees.map((worktree, index) => {
             const isSelected = selectedIndices.has(index);
             const isFocused = index === focusedIndex;
-            const branchName = worktree.branch.replace('refs/heads/', '');
+            const branchName = worktree.branch
+                ? worktree.branch.replace('refs/heads/', '')
+                : 'detached';
             return (React.createElement(Box, { key: worktree.path },
                 React.createElement(Text, { color: isFocused ? 'green' : undefined, inverse: isFocused, dimColor: !isFocused && !isSelected },
                     isSelected ? '[✓]' : '[ ]',

package/dist/components/Menu.js

@@ -41,7 +41,9 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             if (session) {
                 status = ` [${getStatusDisplay(session.state)}]`;
             }
-            const branchName = wt.branch.replace('refs/heads/', '');
+            const branchName = wt.branch
+                ? wt.branch.replace('refs/heads/', '')
+                : 'detached';
             const isMain = wt.isMainWorktree ? ' (main)' : '';
             return {
                 label: `${branchName}${isMain}${status}`,

package/dist/components/MergeWorktree.js

@@ -16,9 +16,9 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         const loadedWorktrees = worktreeService.getWorktrees();
         // Create branch items for selection
         const items = loadedWorktrees.map(wt => ({
-            label: wt.branch.replace('refs/heads/', '') +
+            label: (wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached') +
                 (wt.isMainWorktree ? ' (main)' : ''),
-            value: wt.branch.replace('refs/heads/', ''),
+            value: wt.branch ? wt.branch.replace('refs/heads/', '') : 'detached',
         }));
         setBranchItems(items);
     }, []);

package/dist/services/configurationManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig } from '../types/index.js';
+import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig } from '../types/index.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -15,5 +15,7 @@ export declare class ConfigurationManager {
     setConfiguration(config: ConfigurationData): void;
     getWorktreeConfig(): WorktreeConfig;
     setWorktreeConfig(worktreeConfig: WorktreeConfig): void;
+    getCommandConfig(): CommandConfig;
+    setCommandConfig(commandConfig: CommandConfig): void;
 }
 export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -68,6 +68,11 @@ export class ConfigurationManager {
                 autoDirectory: false,
             };
         }
+        if (!this.config.command) {
+            this.config.command = {
+                command: 'claude',
+            };
+        }
     }
     migrateLegacyShortcuts() {
         if (existsSync(this.legacyShortcutsPath)) {
@@ -125,5 +130,14 @@ export class ConfigurationManager {
         this.config.worktree = worktreeConfig;
         this.saveConfig();
     }
+    getCommandConfig() {
+        return (this.config.command || {
+            command: 'claude',
+        });
+    }
+    setCommandConfig(commandConfig) {
+        this.config.command = commandConfig;
+        this.saveConfig();
+    }
 }
 export const configurationManager = new ConfigurationManager();

package/dist/services/sessionManager.d.ts

@@ -6,11 +6,14 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
     private busyTimers;
-    private stripAnsi;
+    private spawn;
     detectTerminalState(terminal: InstanceType<typeof Terminal>): SessionState;
     constructor();
-    createSession(worktreePath: string): Session;
+    createSession(worktreePath: string): Promise<Session>;
+    private setupDataHandler;
+    private setupExitHandler;
     private setupBackgroundHandler;
+    private cleanupSession;
     getSession(worktreePath: string): Session | undefined;
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;

package/dist/services/sessionManager.js

@@ -6,19 +6,15 @@ import { configurationManager } from './configurationManager.js';
 import { WorktreeService } from './worktreeService.js';
 const { Terminal } = pkg;
 export class SessionManager extends EventEmitter {
-    stripAnsi(str) {
-        // Remove all ANSI escape sequences including cursor movement, color codes, etc.
-        return str
-            .replace(/\x1b\[[0-9;]*m/g, '') // Color codes (including 24-bit)
-            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '') // CSI sequences
-            .replace(/\x1b\][^\x07]*\x07/g, '') // OSC sequences
-            .replace(/\x1b[PX^_].*?\x1b\\/g, '') // DCS/PM/APC/SOS sequences
-            .replace(/\x1b\[\?[0-9;]*[hl]/g, '') // Private mode sequences
-            .replace(/\x1b[>=]/g, '') // Other escape sequences
-            .replace(/[\x00-\x09\x0B-\x1F\x7F]/g, '') // Control characters except newline (\x0A)
-            .replace(/\r/g, '') // Carriage returns
-            .replace(/^[0-9;]+m/gm, '') // Orphaned color codes at line start
-            .replace(/[0-9]+;[0-9]+;[0-9;]+m/g, ''); // Orphaned 24-bit color codes
+    async spawn(command, args, worktreePath) {
+        const spawnOptions = {
+            name: 'xterm-color',
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            cwd: worktreePath,
+            env: process.env,
+        };
+        return spawn(command, args, spawnOptions);
     }
     detectTerminalState(terminal) {
         // Get the last 30 lines from the terminal buffer
@@ -72,7 +68,7 @@ export class SessionManager extends EventEmitter {
         });
         this.sessions = new Map();
     }
-    createSession(worktreePath) {
+    async createSession(worktreePath) {
         // Check if session already exists
         const existing = this.sessions.get(worktreePath);
         if (existing) {
@@ -81,17 +77,12 @@ export class SessionManager extends EventEmitter {
         const id = `session-${Date.now()}-${Math.random()
             .toString(36)
             .substr(2, 9)}`;
-        // Parse Claude command arguments from environment variable
-        const claudeArgs = process.env['CCMANAGER_CLAUDE_ARGS']
-            ? process.env['CCMANAGER_CLAUDE_ARGS'].split(' ')
-            : [];
-        const ptyProcess = spawn('claude', claudeArgs, {
-            name: 'xterm-color',
-            cols: process.stdout.columns || 80,
-            rows: process.stdout.rows || 24,
-            cwd: worktreePath,
-            env: process.env,
-        });
+        // 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({
             cols: process.stdout.columns || 80,
@@ -108,6 +99,8 @@ export class SessionManager extends EventEmitter {
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            isPrimaryCommand: true,
+            commandConfig,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -115,7 +108,7 @@ export class SessionManager extends EventEmitter {
         this.emit('sessionCreated', session);
         return session;
     }
-    setupBackgroundHandler(session) {
+    setupDataHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {
             // Write data to virtual terminal
@@ -138,6 +131,37 @@ export class SessionManager extends EventEmitter {
                 this.emit('sessionData', session, data);
             }
         });
+    }
+    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);
+                    // Replace the process
+                    session.process = fallbackProcess;
+                    session.isPrimaryCommand = false;
+                    // Setup handlers for the new process (data and exit only)
+                    this.setupDataHandler(session);
+                    this.setupExitHandler(session);
+                    // Emit event to notify process replacement
+                    this.emit('sessionProcessReplaced', session);
+                }
+                catch (_error) {
+                    // Fallback failed, proceed with cleanup
+                    this.cleanupSession(session);
+                }
+            }
+            else {
+                // No fallback needed or possible, cleanup
+                this.cleanupSession(session);
+            }
+        });
+    }
+    setupBackgroundHandler(session) {
+        // Setup data handler
+        this.setupDataHandler(session);
         // Set up interval-based state detection
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
@@ -148,17 +172,19 @@ export class SessionManager extends EventEmitter {
                 this.emit('sessionStateChanged', session);
             }
         }, 100); // Check every 100ms
-        session.process.onExit(() => {
-            // Clear the state check interval
-            if (session.stateCheckInterval) {
-                clearInterval(session.stateCheckInterval);
-            }
-            // Update state to idle before destroying
-            session.state = 'idle';
-            this.emit('sessionStateChanged', session);
-            this.destroySession(session.worktreePath);
-            this.emit('sessionExit', session);
-        });
+        // Setup exit handler
+        this.setupExitHandler(session);
+    }
+    cleanupSession(session) {
+        // Clear the state check interval
+        if (session.stateCheckInterval) {
+            clearInterval(session.stateCheckInterval);
+        }
+        // Update state to idle before destroying
+        session.state = 'idle';
+        this.emit('sessionStateChanged', session);
+        this.destroySession(session.worktreePath);
+        this.emit('sessionExit', session);
     }
     getSession(worktreePath) {
         return this.sessions.get(worktreePath);

package/dist/services/sessionManager.test.js

@@ -1,252 +1,260 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+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';
+// Mock node-pty
+vi.mock('node-pty');
+// Mock configuration manager
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getCommandConfig: vi.fn(),
+        getStatusHooks: vi.fn(() => ({})),
+    },
+}));
+// Mock Terminal
+vi.mock('@xterm/headless', () => ({
+    default: {
+        Terminal: vi.fn().mockImplementation(() => ({
+            buffer: {
+                active: {
+                    length: 0,
+                    getLine: vi.fn(),
+                },
+            },
+            write: vi.fn(),
+        })),
+    },
+}));
+// Create a mock IPty class
+class MockPty extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "kill", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "resize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "write", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn()
+        });
+        Object.defineProperty(this, "onData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((callback) => {
+                this.on('data', callback);
+            })
+        });
+        Object.defineProperty(this, "onExit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: vi.fn((callback) => {
+                this.on('exit', callback);
+            })
+        });
+    }
+}
 describe('SessionManager', () => {
     let sessionManager;
+    let mockPty;
     beforeEach(() => {
-        sessionManager = new SessionManager();
         vi.clearAllMocks();
-    });
-    // TODO: Update tests for new xterm-based state detection
-    it('should create session manager', () => {
-        expect(sessionManager).toBeDefined();
-        expect(sessionManager.sessions).toBeDefined();
-    });
-});
-/*
-describe('SessionManager', () => {
-    let sessionManager: SessionManager;
-    const mockSessionId = 'test-session-123';
-
-    beforeEach(() => {
         sessionManager = new SessionManager();
-        vi.clearAllMocks();
+        mockPty = new MockPty();
     });
-
-    describe.skip('detectSessionState', () => {
-        it('should detect waiting_input state when "Do you want" prompt is present', () => {
-            const cleanData = '│ Do you want to continue?';
-            const currentState: SessionState = 'idle';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('waiting_input');
+    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({
+                command: 'claude',
+            });
+            // 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', [], {
+                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 detect waiting_input state when "Would you like" prompt is present', () => {
-            const cleanData = '│ Would you like to proceed?';
-            const currentState: SessionState = 'idle';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('waiting_input');
+        it('should create session with configured arguments', async () => {
+            // Setup mock configuration with args
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+                args: ['--resume', '--model', 'opus'],
+            });
+            // 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({
+                cwd: '/test/worktree',
+            }));
+            // Session creation verified by spawn being called
         });
-
-        it('should set waitingWithBottomBorder when waiting prompt and bottom border are both present', () => {
-            const cleanData = '│ Do you want to continue?\n└───────────────────────┘';
-            const currentState: SessionState = 'idle';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('waiting_input');
-            // The internal map should have been set to true
+        it('should use fallback args when main command exits with code 1', async () => {
+            // Setup mock configuration with fallback
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+                args: ['--invalid-flag'],
+                fallbackArgs: ['--resume'],
+            });
+            // 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.createSession('/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
+            expect(spawn).toHaveBeenCalledTimes(2);
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--resume'], expect.objectContaining({ cwd: '/test/worktree' }));
+            // Verify session process was replaced
+            expect(session.process).toBe(secondMockPty);
+            expect(session.isPrimaryCommand).toBe(false);
         });
-
-        it('should maintain waiting_input state when bottom border appears after waiting prompt', () => {
-            const cleanData = '└───────────────────────┘';
-            const currentState: SessionState = 'waiting_input';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
-
-            // First call to set up the waiting state without bottom border
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-            sessionManager.detectSessionState(
-                '│ Do you want to continue?',
-                'idle',
-                mockSessionId,
-            );
-
-            // Now test the bottom border appearing
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('waiting_input');
+        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 detect busy state when "esc to interrupt" is present', () => {
-            const cleanData = 'Processing... Press ESC to interrupt';
-            const currentState: SessionState = 'idle';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('busy');
+        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 maintain busy state when transitioning from busy without "esc to interrupt"', () => {
-            const cleanData = 'Some regular output text';
-            const currentState: SessionState = 'busy';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            // With the new logic, it should remain busy and start a timer
-            expect(newState).toBe('busy');
+        it('should not use fallback if main command succeeds', async () => {
+            // Setup mock configuration with fallback
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+                args: ['--resume'],
+                fallbackArgs: ['--other-flag'],
+            });
+            // Setup spawn mock - process doesn't exit early
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            await sessionManager.createSession('/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 handle case-insensitive "esc to interrupt" detection', () => {
-            const cleanData = 'Running task... PRESS ESC TO INTERRUPT';
-            const currentState: SessionState = 'idle';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('busy');
+        it('should return existing session if already created', async () => {
+            // Setup mock configuration
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+            });
+            // 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);
         });
-
-        it('should clear waitingWithBottomBorder flag when transitioning to busy', () => {
-            const cleanData = 'Processing... Press ESC to interrupt';
-            const currentState: SessionState = 'waiting_input';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            // First set up waiting state with bottom border
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(true);
-            sessionManager.detectSessionState(
-                '│ Do you want to continue?\n└───────────────────────┘',
-                'idle',
-                mockSessionId,
-            );
-
-            // Now transition to busy
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                currentState,
-                mockSessionId,
-            );
-
-            expect(newState).toBe('busy');
+        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'],
+            });
+            // Mock spawn to always throw error
+            vi.mocked(spawn).mockImplementation(() => {
+                throw new Error('Command not found');
+            });
+            // Expect createSession to throw the original error
+            await expect(sessionManager.createSession('/test/worktree')).rejects.toThrow('Command not found');
         });
-
-        it('should transition from busy to idle after 500ms timer when no "esc to interrupt"', async () => {
-            // Create a mock session for the timer test
-            const mockWorktreePath = '/test/worktree';
-            const mockSession = {
-                id: mockSessionId,
-                worktreePath: mockWorktreePath,
-                state: 'busy' as SessionState,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                process: {} as any,
-                output: [],
-                outputHistory: [],
-                lastActivity: new Date(),
-                isActive: false,
-            };
-
-            // Add the session to the manager
-            sessionManager.sessions.set(mockWorktreePath, mockSession);
-
-            // Mock the EventEmitter emit method
-            const emitSpy = vi.spyOn(sessionManager, 'emit');
-
-            // First call with no esc to interrupt should maintain busy state
-            const cleanData = 'Some regular output text';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState = sessionManager.detectSessionState(
-                cleanData,
-                'busy',
-                mockWorktreePath,
-            );
-
-            expect(newState).toBe('busy');
-
-            // Wait for timer to fire (500ms + buffer)
-            await new Promise(resolve => setTimeout(resolve, 600));
-
-            // Check that the session state was changed to idle
-            expect(mockSession.state).toBe('idle');
-            expect(emitSpy).toHaveBeenCalledWith('sessionStateChanged', mockSession);
+    });
+    describe('session lifecycle', () => {
+        it('should destroy session and clean up resources', async () => {
+            // Setup
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create and destroy session
+            await sessionManager.createSession('/test/worktree');
+            sessionManager.destroySession('/test/worktree');
+            // Verify cleanup
+            expect(mockPty.kill).toHaveBeenCalled();
+            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
         });
-
-        it('should cancel timer when "esc to interrupt" appears again', async () => {
-            // Create a mock session for the timer test
-            const mockWorktreePath = '/test/worktree';
-            const mockSession = {
-                id: mockSessionId,
-                worktreePath: mockWorktreePath,
-                state: 'busy' as SessionState,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                process: {} as any,
-                output: [],
-                outputHistory: [],
-                lastActivity: new Date(),
-                isActive: false,
-            };
-
-            // Add the session to the manager
-            sessionManager.sessions.set(mockWorktreePath, mockSession);
-
-            // First call with no esc to interrupt should maintain busy state and start timer
-            const cleanData1 = 'Some regular output text';
-            vi.mocked(includesPromptBoxBottomBorder).mockReturnValue(false);
-
-            const newState1 = sessionManager.detectSessionState(
-                cleanData1,
-                'busy',
-                mockWorktreePath,
-            );
-
-            expect(newState1).toBe('busy');
-
-            // Wait 200ms (less than timer duration)
-            await new Promise(resolve => setTimeout(resolve, 200));
-
-            // Second call with esc to interrupt should cancel timer and keep busy
-            const cleanData2 = 'Running... Press ESC to interrupt';
-            const newState2 = sessionManager.detectSessionState(
-                cleanData2,
-                'busy',
-                mockWorktreePath,
-            );
-
-            expect(newState2).toBe('busy');
-
-            // Wait another 400ms (total 600ms, more than timer duration)
-            await new Promise(resolve => setTimeout(resolve, 400));
-
-            // State should still be busy because timer was cancelled
-            expect(mockSession.state).toBe('busy');
+        it('should handle session exit event', async () => {
+            // Setup
+            vi.mocked(configurationManager.getCommandConfig).mockReturnValue({
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Track session exit event
+            let exitedSession = null;
+            sessionManager.on('sessionExit', (session) => {
+                exitedSession = session;
+            });
+            // Create session
+            const createdSession = await sessionManager.createSession('/test/worktree');
+            // Simulate process exit after successful creation
+            setTimeout(() => {
+                mockPty.emit('exit', { exitCode: 0 });
+            }, 600); // After early exit timeout
+            // Wait for exit event
+            await new Promise(resolve => setTimeout(resolve, 700));
+            expect(exitedSession).toBe(createdSession);
+            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
         });
     });
 });
-*/

package/dist/services/worktreeService.js

@@ -42,32 +42,41 @@ export class WorktreeService {
             });
             const worktrees = [];
             const lines = output.trim().split('\n');
-            let currentWorktree = {};
-            for (const line of lines) {
-                if (line.startsWith('worktree ')) {
-                    if (currentWorktree.path) {
-                        worktrees.push(currentWorktree);
-                    }
-                    currentWorktree = {
-                        path: line.substring(9),
-                        isMainWorktree: false,
-                        hasSession: false,
-                    };
+            const parseWorktree = (lines, startIndex) => {
+                const worktreeLine = lines[startIndex];
+                if (!worktreeLine?.startsWith('worktree ')) {
+                    return [null, startIndex];
                 }
-                else if (line.startsWith('branch ')) {
-                    let branch = line.substring(7);
-                    // Remove refs/heads/ prefix if present
-                    if (branch.startsWith('refs/heads/')) {
-                        branch = branch.substring(11);
+                const worktree = {
+                    path: worktreeLine.substring(9),
+                    isMainWorktree: false,
+                    hasSession: false,
+                };
+                let i = startIndex + 1;
+                while (i < lines.length &&
+                    lines[i] &&
+                    !lines[i].startsWith('worktree ')) {
+                    const line = lines[i];
+                    if (line && line.startsWith('branch ')) {
+                        const branch = line.substring(7);
+                        worktree.branch = branch.startsWith('refs/heads/')
+                            ? branch.substring(11)
+                            : branch;
                     }
-                    currentWorktree.branch = branch;
+                    else if (line === 'bare') {
+                        worktree.isMainWorktree = true;
+                    }
+                    i++;
                 }
-                else if (line === 'bare') {
-                    currentWorktree.isMainWorktree = true;
+                return [worktree, i];
+            };
+            let index = 0;
+            while (index < lines.length) {
+                const [worktree, nextIndex] = parseWorktree(lines, index);
+                if (worktree) {
+                    worktrees.push(worktree);
                 }
-            }
-            if (currentWorktree.path) {
-                worktrees.push(currentWorktree);
+                index = nextIndex > index ? nextIndex : index + 1;
             }
             // Mark the first worktree as main if none are marked
             if (worktrees.length > 0 && !worktrees.some(w => w.isMainWorktree)) {
@@ -224,7 +233,9 @@ export class WorktreeService {
                 encoding: 'utf8',
             });
             // Delete the branch if it exists
-            const branchName = worktree.branch.replace('refs/heads/', '');
+            const branchName = worktree.branch
+                ? worktree.branch.replace('refs/heads/', '')
+                : 'detached';
             try {
                 execSync(`git branch -D "${branchName}"`, {
                     cwd: this.rootPath,
@@ -248,7 +259,7 @@ export class WorktreeService {
         try {
             // Get worktrees to find the target worktree path
             const worktrees = this.getWorktrees();
-            const targetWorktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === targetBranch);
+            const targetWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === targetBranch);
             if (!targetWorktree) {
                 return {
                     success: false,
@@ -258,7 +269,7 @@ export class WorktreeService {
             // Perform the merge or rebase in the target worktree
             if (useRebase) {
                 // For rebase, we need to checkout source branch and rebase it onto target
-                const sourceWorktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === sourceBranch);
+                const sourceWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === sourceBranch);
                 if (!sourceWorktree) {
                     return {
                         success: false,
@@ -300,7 +311,7 @@ export class WorktreeService {
         try {
             // Get worktrees to find the worktree by branch
             const worktrees = this.getWorktrees();
-            const worktree = worktrees.find(wt => wt.branch.replace('refs/heads/', '') === branch);
+            const worktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === branch);
             if (!worktree) {
                 return {
                     success: false,

package/dist/types/index.d.ts

@@ -4,7 +4,7 @@ export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input';
 export interface Worktree {
     path: string;
-    branch: string;
+    branch?: string;
     isMainWorktree: boolean;
     hasSession: boolean;
 }
@@ -19,10 +19,12 @@ export interface Session {
     isActive: boolean;
     terminal: Terminal;
     stateCheckInterval?: NodeJS.Timeout;
+    isPrimaryCommand?: boolean;
+    commandConfig?: CommandConfig;
 }
 export interface SessionManager {
     sessions: Map<string, Session>;
-    createSession(worktreePath: string): Session;
+    createSession(worktreePath: string): Promise<Session>;
     getSession(worktreePath: string): Session | undefined;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
@@ -51,8 +53,14 @@ export interface WorktreeConfig {
     autoDirectory: boolean;
     autoDirectoryPattern?: string;
 }
+export interface CommandConfig {
+    command: string;
+    args?: string[];
+    fallbackArgs?: string[];
+}
 export interface ConfigurationData {
     shortcuts?: ShortcutConfig;
     statusHooks?: StatusHookConfig;
     worktree?: WorktreeConfig;
+    command?: CommandConfig;
 }

package/package.json

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

package/dist/app.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface AppProps {
-    onReturnToMenu?: () => void;
-}
-declare const App: React.FC<AppProps>;
-export default App;

package/dist/app.js

@@ -1,57 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text, useInput, useApp, useStdout } from 'ink';
-import { spawn } from 'node-pty';
-const App = ({ onReturnToMenu }) => {
-    const { exit } = useApp();
-    const { stdout } = useStdout();
-    const [pty, setPty] = useState(null);
-    const [showMenu, setShowMenu] = useState(false);
-    useEffect(() => {
-        const ptyProcess = spawn('claude', [], {
-            name: 'xterm-color',
-            cols: process.stdout.columns || 80,
-            rows: process.stdout.rows || 24,
-            cwd: process.cwd(),
-            env: process.env,
-        });
-        ptyProcess.onData((data) => {
-            if (stdout) {
-                stdout.write(data);
-            }
-        });
-        ptyProcess.onExit(() => {
-            exit();
-        });
-        setPty(ptyProcess);
-        if (stdout) {
-            stdout.on('resize', () => {
-                ptyProcess.resize(process.stdout.columns || 80, process.stdout.rows || 24);
-            });
-        }
-        return () => {
-            ptyProcess.kill();
-        };
-    }, [exit, stdout]);
-    useInput((char, key) => {
-        if (!pty)
-            return;
-        if (key.ctrl && char === 'e') {
-            if (onReturnToMenu) {
-                onReturnToMenu();
-            }
-            else {
-                setShowMenu(true);
-            }
-            return;
-        }
-        // if (char) {
-        // 	pty.write(char);
-        // }
-    });
-    if (showMenu) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "green" }, "Press Ctrl+E to return to menu")));
-    }
-    return null;
-};
-export default App;