ccmanager 3.12.6 → 4.0.1

package/dist/components/App.js

@@ -12,6 +12,8 @@ import Configuration from './Configuration.js';
 import PresetSelector from './PresetSelector.js';
 import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
+import SessionRename from './SessionRename.js';
+import SessionActions from './SessionActions.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
@@ -31,6 +33,8 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     const [error, setError] = useState(null);
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
     const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
+    const [renameTarget, setRenameTarget] = useState(null);
+    const [sessionActionsTarget, setSessionActionsTarget] = useState(null);
     const [selectedProject, setSelectedProject] = useState(null); // Store selected project in multi-project mode
     const [configScope, setConfigScope] = useState('global'); // Store config scope for configuration view
     const [pendingMenuSessionLaunch, setPendingMenuSessionLaunch] = useState(null);
@@ -58,7 +62,6 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         const sessionEffect = devcontainerConfig
             ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt)
             : sessionManager.createSessionWithPresetEffect(worktreePath, presetId, initialPrompt);
-        // Execute the Effect and handle both success and failure cases
         const result = await Effect.runPromise(Effect.either(sessionEffect));
         if (result._tag === 'Left') {
             const errorMessage = formatErrorMessage(result.left);
@@ -97,23 +100,34 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }, 10);
     }, []);
     const startSessionForWorktree = useCallback(async (worktree, options) => {
-        let session = sessionManager.getSession(worktree.path);
-        if (!session) {
-            if (!options?.presetId && configReader.getSelectPresetOnStart()) {
-                setSelectedWorktree(worktree);
-                navigateWithClear('preset-selector');
-                return;
-            }
-            setView(options?.presetId ? 'creating-session-preset' : 'creating-session');
-            const result = await createSessionWithEffect(worktree.path, options?.presetId, options?.initialPrompt);
-            if (!result.success) {
-                setError(result.errorMessage);
-                navigateWithClear('menu');
+        // If a specific session is provided, navigate to it directly
+        if (options?.session) {
+            navigateToSession(options.session);
+            return;
+        }
+        // Check if there are running sessions for this worktree.
+        // Navigate to the first one found (matches old getSession(path) behavior).
+        // Skip when forceNew is set (S key — always create new session).
+        if (!options?.forceNew) {
+            const wtSessions = sessionManager.getSessionsForWorktree(worktree.path);
+            if (wtSessions.length > 0 && wtSessions[0]) {
+                navigateToSession(wtSessions[0]);
                 return;
             }
-            session = result.session;
         }
-        navigateToSession(session);
+        if (!options?.presetId && configReader.getSelectPresetOnStart()) {
+            setSelectedWorktree(worktree);
+            navigateWithClear('preset-selector');
+            return;
+        }
+        setView(options?.presetId ? 'creating-session-preset' : 'creating-session');
+        const result = await createSessionWithEffect(worktree.path, options?.presetId, options?.initialPrompt);
+        if (!result.success) {
+            setError(result.errorMessage);
+            navigateWithClear('menu');
+            return;
+        }
+        navigateToSession(result.session);
     }, [
         sessionManager,
         navigateWithClear,
@@ -228,54 +242,62 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setView('new-worktree');
         }
     };
-    const handleSelectWorktree = async (worktree) => {
-        // Check if this is the new worktree option
-        if (worktree.path === '') {
-            navigateWithClear('new-worktree');
-            return;
-        }
-        // Check if this is the delete worktree option
-        if (worktree.path === 'DELETE_WORKTREE') {
-            navigateWithClear('delete-worktree');
-            return;
-        }
-        // Check if this is the merge worktree option
-        if (worktree.path === 'MERGE_WORKTREE') {
-            navigateWithClear('merge-worktree');
-            return;
-        }
-        // Check if this is the configuration option
-        if (worktree.path === 'CONFIGURATION') {
-            setConfigScope('global');
-            navigateWithClear('configuration');
-            return;
-        }
-        // Check if this is the project configuration option
-        if (worktree.path === 'CONFIGURATION_PROJECT') {
-            setConfigScope('project');
-            navigateWithClear('configuration');
-            return;
-        }
-        // Check if this is the global configuration option
-        if (worktree.path === 'CONFIGURATION_GLOBAL') {
-            setConfigScope('global');
-            navigateWithClear('configuration');
-            return;
-        }
-        // Check if this is the exit application option
-        if (worktree.path === 'EXIT_APPLICATION') {
-            // In multi-project mode with a selected project, go back to project list
-            if (multiProject && selectedProject) {
-                handleBackToProjectList();
-            }
-            else {
-                // Only destroy all sessions when actually exiting the app
-                globalSessionOrchestrator.destroyAllSessions();
-                exit();
-            }
-            return;
+    const handleMenuAction = async (action) => {
+        switch (action.type) {
+            case 'newWorktree':
+                navigateWithClear('new-worktree');
+                return;
+            case 'newSession':
+                await startSessionForWorktree({
+                    path: action.worktreePath,
+                    branch: '',
+                    isMainWorktree: false,
+                    hasSession: true,
+                }, { forceNew: true });
+                return;
+            case 'renameSession':
+                setRenameTarget({
+                    id: action.session.id,
+                    name: action.session.sessionName,
+                });
+                navigateWithClear('rename-session');
+                return;
+            case 'killSession':
+                sessionManager.destroySession(action.sessionId);
+                setMenuKey(prev => prev + 1);
+                return;
+            case 'sessionActions':
+                setSessionActionsTarget({
+                    session: action.session,
+                    worktreePath: action.worktreePath,
+                });
+                navigateWithClear('session-actions');
+                return;
+            case 'deleteWorktree':
+                navigateWithClear('delete-worktree');
+                return;
+            case 'mergeWorktree':
+                navigateWithClear('merge-worktree');
+                return;
+            case 'configuration':
+                setConfigScope(action.scope);
+                navigateWithClear('configuration');
+                return;
+            case 'exit':
+                if (multiProject && selectedProject) {
+                    handleBackToProjectList();
+                }
+                else {
+                    globalSessionOrchestrator.destroyAllSessions();
+                    exit();
+                }
+                return;
+            case 'selectWorktree':
+                await startSessionForWorktree(action.worktree, {
+                    session: action.session,
+                });
+                return;
         }
-        await startSessionForWorktree(worktree);
     };
     const handlePresetSelected = async (presetId) => {
         if (!selectedWorktree)
@@ -430,6 +452,11 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         // Delete the worktrees sequentially using Effect
         let hasError = false;
         for (const path of worktreePaths) {
+            // Destroy any running sessions for this worktree
+            const wtSessions = sessionManager.getSessionsForWorktree(path);
+            for (const s of wtSessions) {
+                sessionManager.destroySession(s.id);
+            }
             const result = await Effect.runPromise(Effect.either(worktreeService.deleteWorktreeEffect(path, { deleteBranch })));
             if (result._tag === 'Left') {
                 // Handle error using pattern matching on _tag
@@ -495,7 +522,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         return (_jsx(Dashboard, { projectsDir: projectsDir, onSelectSession: handleSelectSessionFromDashboard, onSelectProject: handleSelectProject, error: error, onDismissError: () => setError(null), version: version }));
     }
     if (view === 'menu') {
-        return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onSelectWorktree: handleSelectWorktree, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));
+        return (_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, onMenuAction: handleMenuAction, onSelectRecentProject: handleSelectProject, error: error, onDismissError: () => setError(null), projectName: selectedProject?.name, multiProject: multiProject, version: version }, menuKey));
     }
     if (view === 'session' && activeSession) {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Session, { session: activeSession, sessionManager: sessionManager, onReturnToMenu: handleReturnToMenu }, activeSession.id) }));
@@ -530,6 +557,53 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     if (view === 'configuration') {
         return (_jsx(Configuration, { scope: configScope, onComplete: handleReturnToMenu }));
     }
+    if (view === 'rename-session' && renameTarget) {
+        return (_jsx(SessionRename, { currentName: renameTarget.name, onRename: name => {
+                const session = sessionManager.getSessionById(renameTarget.id);
+                if (session) {
+                    session.sessionName = name;
+                }
+                setRenameTarget(null);
+                handleReturnToMenu();
+            }, onCancel: () => {
+                setRenameTarget(null);
+                handleReturnToMenu();
+            } }));
+    }
+    if (view === 'session-actions' && sessionActionsTarget) {
+        const { session: targetSession, worktreePath } = sessionActionsTarget;
+        const label = targetSession.sessionName
+            ? `${worktreePath} : ${targetSession.sessionName}`
+            : `${worktreePath} #${targetSession.sessionNumber}`;
+        const handleSessionAction = async (action) => {
+            setSessionActionsTarget(null);
+            switch (action) {
+                case 'newSession':
+                    await startSessionForWorktree({
+                        path: worktreePath,
+                        branch: '',
+                        isMainWorktree: false,
+                        hasSession: true,
+                    }, { forceNew: true });
+                    return;
+                case 'rename':
+                    setRenameTarget({
+                        id: targetSession.id,
+                        name: targetSession.sessionName,
+                    });
+                    navigateWithClear('rename-session');
+                    return;
+                case 'kill':
+                    sessionManager.destroySession(targetSession.id);
+                    handleReturnToMenu();
+                    return;
+            }
+        };
+        return (_jsx(SessionActions, { sessionLabel: label, onSelect: handleSessionAction, onCancel: () => {
+                setSessionActionsTarget(null);
+                handleReturnToMenu();
+            } }));
+    }
     if (view === 'preset-selector') {
         return (_jsx(PresetSelector, { onSelect: handlePresetSelected, onCancel: handlePresetSelectorCancel }));
     }

package/dist/components/App.test.js

@@ -16,8 +16,11 @@ const mockSession = {
 class MockSessionManager {
     on = vi.fn((_, __) => this);
     off = vi.fn((_, __) => this);
-    getSession = vi.fn((_) => null);
+    getSessionById = vi.fn((_) => null);
+    getSessionsForWorktree = vi.fn((_) => []);
     getAllSessions = vi.fn(() => []);
+    destroySession = vi.fn((_) => { });
+    cancelAutoApproval = vi.fn((_, __) => { });
     createSessionWithPresetEffect = vi.fn((_, __) => Effect.succeed(mockSession));
     createSessionWithDevcontainerEffect = vi.fn((_, __) => Effect.succeed(mockSession));
 }
@@ -179,12 +182,7 @@ describe('App component loading state machine', () => {
         const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
         await waitForCondition(() => Boolean(menuProps));
         const menu = menuProps;
-        const selectPromise = Promise.resolve(menu.onSelectWorktree({
-            path: '',
-            branch: '',
-            isMainWorktree: false,
-            hasSession: false,
-        }));
+        const selectPromise = Promise.resolve(menu.onMenuAction({ type: 'newWorktree' }));
         await waitForCondition(() => Boolean(newWorktreeProps));
         const newWorktree = newWorktreeProps;
         const createPromise = Promise.resolve(newWorktree.onComplete({
@@ -210,12 +208,7 @@ describe('App component loading state machine', () => {
         expect(sessionManagers).toHaveLength(1);
         const sessionManager = sessionManagers[0];
         const menu = menuProps;
-        await Promise.resolve(menu.onSelectWorktree({
-            path: '',
-            branch: '',
-            isMainWorktree: false,
-            hasSession: false,
-        }));
+        await Promise.resolve(menu.onMenuAction({ type: 'newWorktree' }));
         await waitForCondition(() => Boolean(newWorktreeProps));
         await Promise.resolve(newWorktreeProps.onComplete({
             creationMode: 'prompt',
@@ -245,12 +238,7 @@ describe('App component loading state machine', () => {
         const { unmount } = render(_jsx(App, { version: "test" }));
         await waitForCondition(() => Boolean(menuProps));
         const sessionManager = sessionManagers[0];
-        await Promise.resolve(menuProps.onSelectWorktree({
-            path: '',
-            branch: '',
-            isMainWorktree: false,
-            hasSession: false,
-        }));
+        await Promise.resolve(menuProps.onMenuAction({ type: 'newWorktree' }));
         await waitForCondition(() => Boolean(newWorktreeProps));
         await Promise.resolve(newWorktreeProps.onComplete({
             creationMode: 'prompt',
@@ -278,12 +266,7 @@ describe('App component loading state machine', () => {
         const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
         await waitForCondition(() => Boolean(menuProps));
         const menu = menuProps;
-        const selectPromise = Promise.resolve(menu.onSelectWorktree({
-            path: 'DELETE_WORKTREE',
-            branch: '',
-            isMainWorktree: false,
-            hasSession: false,
-        }));
+        const selectPromise = Promise.resolve(menu.onMenuAction({ type: 'deleteWorktree' }));
         await waitForCondition(() => Boolean(deleteWorktreeProps));
         const deleteWorktree = deleteWorktreeProps;
         const deletePromise = Promise.resolve(deleteWorktree.onComplete(['/tmp/test'], true));
@@ -313,11 +296,14 @@ describe('App component loading state machine', () => {
             catch: (error) => error,
         }));
         const menu = menuProps;
-        const selectPromise = Promise.resolve(menu.onSelectWorktree({
-            path: '/project/worktree',
-            branch: 'feature',
-            isMainWorktree: false,
-            hasSession: false,
+        const selectPromise = Promise.resolve(menu.onMenuAction({
+            type: 'selectWorktree',
+            worktree: {
+                path: '/project/worktree',
+                branch: 'feature',
+                isMainWorktree: false,
+                hasSession: false,
+            },
         }));
         await flush();
         expect(lastFrame()).toContain('Starting devcontainer (this may take a moment)...');

package/dist/components/ConfigureCommand.js

@@ -32,7 +32,7 @@ const DEFAULT_COMMANDS = {
     claude: 'claude',
     gemini: 'gemini',
     codex: 'codex',
-    cursor: 'cursor',
+    cursor: 'agent',
     'github-copilot': 'copilot',
     cline: 'cline',
     opencode: 'opencode',

package/dist/components/Dashboard.js

@@ -12,7 +12,7 @@ import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../c
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { truncateString, calculateColumnPositions, assembleWorktreeLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
+import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
 import SearchableList from './SearchableList.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
@@ -208,7 +208,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
         let currentIndex = 0;
         // --- Active Sessions section ---
         if (sessionEntries.length > 0) {
-            // Build WorktreeItems for column alignment
+            // Build SessionItems for column alignment
             const sessionWorkItems = sessionEntries.map(entry => {
                 // Use enriched worktree if available (has git status)
                 const wt = enrichedWorktrees.find(w => w.path === entry.worktree.path) ||
@@ -278,7 +278,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
             filteredEntries.forEach(entry => {
                 const itemIndex = sessionEntries.indexOf(entry);
                 const workItem = sessionWorkItems[itemIndex];
-                const label = assembleWorktreeLabel(workItem, columns);
+                const label = assembleSessionLabel(workItem, columns);
                 const numberPrefix = !isSearchMode && currentIndex < 10 ? `${currentIndex} ❯ ` : '❯ ';
                 const project = {
                     path: entry.projectPath,

package/dist/components/Menu.d.ts

@@ -1,11 +1,11 @@
 import React from 'react';
-import { Worktree, GitProject } from '../types/index.js';
+import { GitProject, MenuAction } from '../types/index.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { SessionManager } from '../services/sessionManager.js';
 interface MenuProps {
     sessionManager: SessionManager;
     worktreeService: WorktreeService;
-    onSelectWorktree: (worktree: Worktree) => void;
+    onMenuAction: (action: MenuAction) => void;
     onSelectRecentProject?: (project: GitProject) => void;
     error?: string | null;
     onDismissError?: () => void;