ccmanager 0.0.1

package/dist/components/DeleteWorktree.js

@@ -0,0 +1,116 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { WorktreeService } from '../services/worktreeService.js';
+import Confirmation from './Confirmation.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const DeleteWorktree = ({ onComplete, onCancel, }) => {
+    const [worktrees, setWorktrees] = useState([]);
+    const [selectedIndices, setSelectedIndices] = useState(new Set());
+    const [focusedIndex, setFocusedIndex] = useState(0);
+    const [confirmMode, setConfirmMode] = useState(false);
+    useEffect(() => {
+        const worktreeService = new WorktreeService();
+        const allWorktrees = worktreeService.getWorktrees();
+        // Filter out main worktree - we shouldn't delete it
+        const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
+        setWorktrees(deletableWorktrees);
+    }, []);
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            onCancel();
+            return;
+        }
+        if (confirmMode) {
+            // Confirmation component handles input
+            return;
+        }
+        if (key.upArrow) {
+            setFocusedIndex(prev => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setFocusedIndex(prev => Math.min(worktrees.length - 1, prev + 1));
+        }
+        else if (input === ' ') {
+            // Toggle selection
+            setSelectedIndices(prev => {
+                const newSet = new Set(prev);
+                if (newSet.has(focusedIndex)) {
+                    newSet.delete(focusedIndex);
+                }
+                else {
+                    newSet.add(focusedIndex);
+                }
+                return newSet;
+            });
+        }
+        else if (key.return) {
+            if (selectedIndices.size > 0) {
+                setConfirmMode(true);
+            }
+        }
+        else if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+        }
+    });
+    if (worktrees.length === 0) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "yellow" }, "No worktrees available to delete."),
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to return to menu")));
+    }
+    if (confirmMode) {
+        const selectedWorktrees = Array.from(selectedIndices).map(index => worktrees[index]);
+        const handleConfirm = () => {
+            const selectedPaths = Array.from(selectedIndices).map(index => worktrees[index].path);
+            onComplete(selectedPaths);
+        };
+        const handleCancel = () => {
+            setConfirmMode(false);
+        };
+        const confirmMessage = (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true, color: "red" }, "\u26A0\uFE0F Delete Confirmation"),
+            React.createElement(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column" },
+                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.path,
+                    ")")))),
+            React.createElement(Text, { bold: true }, "This will also delete their branches. Are you sure?")));
+        return (React.createElement(Confirmation, { message: confirmMessage, onConfirm: handleConfirm, onCancel: handleCancel }));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "red" }, "Delete Worktrees")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Select worktrees to delete (Space to select, Enter to confirm):")),
+        worktrees.map((worktree, index) => {
+            const isSelected = selectedIndices.has(index);
+            const isFocused = index === focusedIndex;
+            const branchName = worktree.branch.replace('refs/heads/', '');
+            return (React.createElement(Box, { key: worktree.path },
+                React.createElement(Text, { color: isFocused ? 'green' : undefined, inverse: isFocused, dimColor: !isFocused && !isSelected },
+                    isSelected ? '[✓]' : '[ ]',
+                    " ",
+                    branchName,
+                    " (",
+                    worktree.path,
+                    ")")));
+        }),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, { dimColor: true },
+                "Controls: \u2191\u2193 Navigate, Space Select, Enter Confirm,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " Cancel"),
+            selectedIndices.size > 0 && (React.createElement(Text, { color: "yellow" },
+                selectedIndices.size,
+                " worktree",
+                selectedIndices.size > 1 ? 's' : '',
+                ' ',
+                "selected")))));
+};
+export default DeleteWorktree;

package/dist/components/Menu.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Worktree } from '../types/index.js';
+import { SessionManager } from '../services/sessionManager.js';
+interface MenuProps {
+    sessionManager: SessionManager;
+    onSelectWorktree: (worktree: Worktree) => void;
+}
+declare const Menu: React.FC<MenuProps>;
+export default Menu;

package/dist/components/Menu.js

@@ -0,0 +1,154 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { WorktreeService } from '../services/worktreeService.js';
+import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
+const Menu = ({ sessionManager, onSelectWorktree }) => {
+    const [worktrees, setWorktrees] = useState([]);
+    const [sessions, setSessions] = useState([]);
+    const [items, setItems] = useState([]);
+    useEffect(() => {
+        // Load worktrees
+        const worktreeService = new WorktreeService();
+        const loadedWorktrees = worktreeService.getWorktrees();
+        setWorktrees(loadedWorktrees);
+        // Update sessions
+        const updateSessions = () => {
+            const allSessions = sessionManager.getAllSessions();
+            setSessions(allSessions);
+            // Update worktree session status
+            loadedWorktrees.forEach(wt => {
+                wt.hasSession = allSessions.some(s => s.worktreePath === wt.path);
+            });
+        };
+        updateSessions();
+        // Listen for session changes
+        const handleSessionChange = () => updateSessions();
+        sessionManager.on('sessionCreated', handleSessionChange);
+        sessionManager.on('sessionDestroyed', handleSessionChange);
+        sessionManager.on('sessionStateChanged', handleSessionChange);
+        return () => {
+            sessionManager.off('sessionCreated', handleSessionChange);
+            sessionManager.off('sessionDestroyed', handleSessionChange);
+            sessionManager.off('sessionStateChanged', handleSessionChange);
+        };
+    }, [sessionManager]);
+    useEffect(() => {
+        // Build menu items
+        const menuItems = worktrees.map(wt => {
+            const session = sessions.find(s => s.worktreePath === wt.path);
+            let status = '';
+            if (session) {
+                status = ` [${getStatusDisplay(session.state)}]`;
+            }
+            const branchName = wt.branch.replace('refs/heads/', '');
+            const isMain = wt.isMainWorktree ? ' (main)' : '';
+            return {
+                label: `${branchName}${isMain}${status}`,
+                value: wt.path,
+                worktree: wt,
+            };
+        });
+        // Add menu options
+        menuItems.push({
+            label: '─────────────',
+            value: 'separator',
+        });
+        menuItems.push({
+            label: `${MENU_ICONS.NEW_WORKTREE} New Worktree`,
+            value: 'new-worktree',
+        });
+        menuItems.push({
+            label: `${MENU_ICONS.MERGE_WORKTREE} Merge Worktree`,
+            value: 'merge-worktree',
+        });
+        menuItems.push({
+            label: `${MENU_ICONS.DELETE_WORKTREE} Delete Worktree`,
+            value: 'delete-worktree',
+        });
+        menuItems.push({
+            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configure Shortcuts`,
+            value: 'configure-shortcuts',
+        });
+        menuItems.push({
+            label: `${MENU_ICONS.EXIT} Exit`,
+            value: 'exit',
+        });
+        setItems(menuItems);
+    }, [worktrees, sessions]);
+    const handleSelect = (item) => {
+        if (item.value === 'separator') {
+            // Do nothing for separator
+        }
+        else if (item.value === 'new-worktree') {
+            // Handle in parent component
+            onSelectWorktree({
+                path: '',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.value === 'merge-worktree') {
+            // Handle in parent component - use special marker
+            onSelectWorktree({
+                path: 'MERGE_WORKTREE',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.value === 'delete-worktree') {
+            // Handle in parent component - use special marker
+            onSelectWorktree({
+                path: 'DELETE_WORKTREE',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.value === 'configure-shortcuts') {
+            // Handle in parent component - use special marker
+            onSelectWorktree({
+                path: 'CONFIGURE_SHORTCUTS',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.value === 'exit') {
+            // Handle in parent component - use special marker
+            onSelectWorktree({
+                path: 'EXIT_APPLICATION',
+                branch: '',
+                isMainWorktree: false,
+                hasSession: false,
+            });
+        }
+        else if (item.worktree) {
+            onSelectWorktree(item.worktree);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            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(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, { dimColor: true },
+                "Status: ",
+                STATUS_ICONS.BUSY,
+                " ",
+                STATUS_LABELS.BUSY,
+                ' ',
+                STATUS_ICONS.WAITING,
+                " ",
+                STATUS_LABELS.WAITING,
+                " ",
+                STATUS_ICONS.IDLE,
+                ' ',
+                STATUS_LABELS.IDLE),
+            React.createElement(Text, { dimColor: true }, "Controls: \u2191\u2193 Navigate Enter Select"))));
+};
+export default Menu;

package/dist/components/MergeWorktree.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface MergeWorktreeProps {
+    onComplete: (sourceBranch: string, targetBranch: string, deleteAfterMerge: boolean, useRebase: boolean) => void;
+    onCancel: () => void;
+}
+declare const MergeWorktree: React.FC<MergeWorktreeProps>;
+export default MergeWorktree;

package/dist/components/MergeWorktree.js

@@ -0,0 +1,142 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { WorktreeService } from '../services/worktreeService.js';
+import Confirmation from './Confirmation.js';
+import { shortcutManager } from '../services/shortcutManager.js';
+const MergeWorktree = ({ onComplete, onCancel, }) => {
+    const [step, setStep] = useState('select-source');
+    const [sourceBranch, setSourceBranch] = useState('');
+    const [targetBranch, setTargetBranch] = useState('');
+    const [branchItems, setBranchItems] = useState([]);
+    const [useRebase, setUseRebase] = useState(false);
+    const [operationFocused, setOperationFocused] = useState(false);
+    useEffect(() => {
+        const worktreeService = new WorktreeService();
+        const loadedWorktrees = worktreeService.getWorktrees();
+        // Create branch items for selection
+        const items = loadedWorktrees.map(wt => ({
+            label: wt.branch.replace('refs/heads/', '') +
+                (wt.isMainWorktree ? ' (main)' : ''),
+            value: wt.branch.replace('refs/heads/', ''),
+        }));
+        setBranchItems(items);
+    }, []);
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+            return;
+        }
+        if (step === 'select-operation') {
+            if (key.leftArrow || key.rightArrow) {
+                const newOperationFocused = !operationFocused;
+                setOperationFocused(newOperationFocused);
+                setUseRebase(newOperationFocused);
+            }
+            else if (key.return) {
+                setStep('confirm-merge');
+            }
+        }
+    });
+    const handleSelectSource = (item) => {
+        setSourceBranch(item.value);
+        // Filter out the selected source branch for target selection
+        const filteredItems = branchItems.filter(b => b.value !== item.value);
+        setBranchItems(filteredItems);
+        setStep('select-target');
+    };
+    const handleSelectTarget = (item) => {
+        setTargetBranch(item.value);
+        setStep('select-operation');
+    };
+    if (step === 'select-source') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Merge Worktree")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Select the source branch to merge:")),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectSource, isFocused: true }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press ",
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
+    if (step === 'select-target') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Merge Worktree")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Merging from: ",
+                    React.createElement(Text, { color: "yellow" }, sourceBranch))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Select the target branch to merge into:")),
+            React.createElement(SelectInput, { items: branchItems, onSelect: handleSelectTarget, isFocused: true }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press ",
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
+    if (step === 'select-operation') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Select Operation")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Choose how to integrate ",
+                    React.createElement(Text, { color: "yellow" }, sourceBranch),
+                    ' ',
+                    "into ",
+                    React.createElement(Text, { color: "yellow" }, targetBranch),
+                    ":")),
+            React.createElement(Box, null,
+                React.createElement(Box, { marginRight: 2 },
+                    React.createElement(Text, { color: !operationFocused ? 'green' : 'white', inverse: !operationFocused },
+                        ' ',
+                        "Merge",
+                        ' ')),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: operationFocused ? 'blue' : 'white', inverse: operationFocused },
+                        ' ',
+                        "Rebase",
+                        ' '))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Use \u2190 \u2192 to navigate, Enter to select,",
+                    ' ',
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
+    if (step === 'confirm-merge') {
+        const confirmMessage = (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" },
+                    "Confirm ",
+                    useRebase ? 'Rebase' : 'Merge')),
+            React.createElement(Text, null,
+                useRebase ? 'Rebase' : 'Merge',
+                ' ',
+                React.createElement(Text, { color: "yellow" }, sourceBranch),
+                ' ',
+                useRebase ? 'onto' : 'into',
+                ' ',
+                React.createElement(Text, { color: "yellow" }, targetBranch),
+                "?")));
+        return (React.createElement(Confirmation, { message: confirmMessage, onConfirm: () => setStep('delete-confirm'), onCancel: onCancel }));
+    }
+    if (step === 'delete-confirm') {
+        const deleteMessage = (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Delete Source Branch?")),
+            React.createElement(Text, null,
+                "Delete the merged branch ",
+                React.createElement(Text, { color: "yellow" }, sourceBranch),
+                ' ',
+                "and its worktree?")));
+        return (React.createElement(Confirmation, { message: deleteMessage, onConfirm: () => onComplete(sourceBranch, targetBranch, true, useRebase), onCancel: () => onComplete(sourceBranch, targetBranch, false, useRebase) }));
+    }
+    return null;
+};
+export default MergeWorktree;

package/dist/components/NewWorktree.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface NewWorktreeProps {
+    onComplete: (path: string, branch: string) => void;
+    onCancel: () => void;
+}
+declare const NewWorktree: React.FC<NewWorktreeProps>;
+export default NewWorktree;

package/dist/components/NewWorktree.js

@@ -0,0 +1,49 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { shortcutManager } from '../services/shortcutManager.js';
+const NewWorktree = ({ onComplete, onCancel }) => {
+    const [step, setStep] = useState('path');
+    const [path, setPath] = useState('');
+    const [branch, setBranch] = useState('');
+    useInput((input, key) => {
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
+        }
+    });
+    const handlePathSubmit = (value) => {
+        if (value.trim()) {
+            setPath(value.trim());
+            setStep('branch');
+        }
+    };
+    const handleBranchSubmit = (value) => {
+        if (value.trim()) {
+            setBranch(value.trim());
+            onComplete(path, value.trim());
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Create New Worktree")),
+        step === 'path' ? (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Enter worktree path (relative to repository root):")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })))) : (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Enter branch name for worktree at ",
+                    React.createElement(Text, { color: "cyan" }, path),
+                    ":")),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "cyan" }, '> '),
+                React.createElement(TextInput, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Press ",
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel"))));
+};
+export default NewWorktree;

package/dist/components/Session.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Session as SessionType } from '../types/index.js';
+import { SessionManager } from '../services/sessionManager.js';
+interface SessionProps {
+    session: SessionType;
+    sessionManager: SessionManager;
+    onReturnToMenu: () => void;
+}
+declare const Session: React.FC<SessionProps>;
+export default Session;

package/dist/components/Session.js

@@ -0,0 +1,121 @@
+import { useEffect, useState } from 'react';
+import { useStdout } from 'ink';
+import { shortcutManager } from '../services/shortcutManager.js';
+const Session = ({ session, sessionManager, onReturnToMenu, }) => {
+    const { stdout } = useStdout();
+    const [isExiting, setIsExiting] = useState(false);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        // Clear screen when entering session
+        stdout.write('\x1B[2J\x1B[H');
+        // Handle session restoration
+        const handleSessionRestore = (restoredSession) => {
+            if (restoredSession.id === session.id) {
+                // Replay all buffered output, but skip the initial clear if present
+                for (let i = 0; i < restoredSession.outputHistory.length; i++) {
+                    const buffer = restoredSession.outputHistory[i];
+                    if (!buffer)
+                        continue;
+                    const str = buffer.toString('utf8');
+                    // Skip clear screen sequences at the beginning
+                    if (i === 0 && (str.includes('\x1B[2J') || str.includes('\x1B[H'))) {
+                        // Skip this buffer or remove the clear sequence
+                        const cleaned = str
+                            .replace(/\x1B\[2J/g, '')
+                            .replace(/\x1B\[H/g, '');
+                        if (cleaned.length > 0) {
+                            stdout.write(Buffer.from(cleaned, 'utf8'));
+                        }
+                    }
+                    else {
+                        stdout.write(buffer);
+                    }
+                }
+            }
+        };
+        // Listen for restore event first
+        sessionManager.on('sessionRestore', handleSessionRestore);
+        // Mark session as active (this will trigger the restore event)
+        sessionManager.setSessionActive(session.worktreePath, true);
+        // Listen for session data events
+        const handleSessionData = (activeSession, data) => {
+            // Only handle data for our session
+            if (activeSession.id === session.id && !isExiting) {
+                stdout.write(data);
+            }
+        };
+        const handleSessionExit = (exitedSession) => {
+            if (exitedSession.id === session.id) {
+                setIsExiting(true);
+                // Don't call onReturnToMenu here - App component handles it
+            }
+        };
+        sessionManager.on('sessionData', handleSessionData);
+        sessionManager.on('sessionExit', handleSessionExit);
+        // Handle terminal resize
+        const handleResize = () => {
+            session.process.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+        };
+        stdout.on('resize', handleResize);
+        // Set up raw input handling
+        const stdin = process.stdin;
+        // Store original stdin state
+        const originalIsRaw = stdin.isRaw;
+        const originalIsPaused = stdin.isPaused();
+        // Configure stdin for PTY passthrough
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        const handleStdinData = (data) => {
+            if (isExiting)
+                return;
+            // Check for return to menu shortcut
+            const returnToMenuShortcut = shortcutManager.getShortcuts().returnToMenu;
+            const shortcutCode = shortcutManager.getShortcutCode(returnToMenuShortcut);
+            if (shortcutCode && data === shortcutCode) {
+                // Disable focus reporting mode before returning to menu
+                if (stdout) {
+                    stdout.write('\x1b[?1004l');
+                }
+                // Restore stdin state before returning to menu
+                stdin.removeListener('data', handleStdinData);
+                stdin.setRawMode(false);
+                stdin.pause();
+                onReturnToMenu();
+                return;
+            }
+            // Pass all other input directly to the PTY
+            session.process.write(data);
+        };
+        stdin.on('data', handleStdinData);
+        return () => {
+            // Remove listener first to prevent any race conditions
+            stdin.removeListener('data', handleStdinData);
+            // Disable focus reporting mode that might have been enabled by the PTY
+            if (stdout) {
+                stdout.write('\x1b[?1004l');
+            }
+            // Restore stdin to its original state
+            if (stdin.isTTY) {
+                stdin.setRawMode(originalIsRaw || false);
+                if (originalIsPaused) {
+                    stdin.pause();
+                }
+                else {
+                    stdin.resume();
+                }
+            }
+            // Mark session as inactive
+            sessionManager.setSessionActive(session.worktreePath, false);
+            // Remove event listeners
+            sessionManager.off('sessionRestore', handleSessionRestore);
+            sessionManager.off('sessionData', handleSessionData);
+            sessionManager.off('sessionExit', handleSessionExit);
+            stdout.off('resize', handleResize);
+        };
+    }, [session, sessionManager, stdout, onReturnToMenu, isExiting]);
+    // Return null to render nothing (PTY output goes directly to stdout)
+    return null;
+};
+export default Session;

package/dist/constants/statusIcons.d.ts

@@ -0,0 +1,18 @@
+export declare const STATUS_ICONS: {
+    readonly BUSY: "●";
+    readonly WAITING: "◐";
+    readonly IDLE: "○";
+};
+export declare const STATUS_LABELS: {
+    readonly BUSY: "Busy";
+    readonly WAITING: "Waiting";
+    readonly IDLE: "Idle";
+};
+export declare const MENU_ICONS: {
+    readonly NEW_WORKTREE: "⊕";
+    readonly MERGE_WORKTREE: "⇄";
+    readonly DELETE_WORKTREE: "✕";
+    readonly CONFIGURE_SHORTCUTS: "⌨";
+    readonly EXIT: "⏻";
+};
+export declare const getStatusDisplay: (status: "busy" | "waiting_input" | "idle") => string;

package/dist/constants/statusIcons.js

@@ -0,0 +1,27 @@
+export const STATUS_ICONS = {
+    BUSY: '●',
+    WAITING: '◐',
+    IDLE: '○',
+};
+export const STATUS_LABELS = {
+    BUSY: 'Busy',
+    WAITING: 'Waiting',
+    IDLE: 'Idle',
+};
+export const MENU_ICONS = {
+    NEW_WORKTREE: '⊕',
+    MERGE_WORKTREE: '⇄',
+    DELETE_WORKTREE: '✕',
+    CONFIGURE_SHORTCUTS: '⌨',
+    EXIT: '⏻',
+};
+export const getStatusDisplay = (status) => {
+    switch (status) {
+        case 'busy':
+            return `${STATUS_ICONS.BUSY} ${STATUS_LABELS.BUSY}`;
+        case 'waiting_input':
+            return `${STATUS_ICONS.WAITING} ${STATUS_LABELS.WAITING}`;
+        case 'idle':
+            return `${STATUS_ICONS.IDLE} ${STATUS_LABELS.IDLE}`;
+    }
+};