ccmanager 4.1.8 → 4.1.10

package/dist/components/App.js

@@ -566,7 +566,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: message, color: "cyan" }) }));
     }
     if (view === 'merge-worktree') {
-        return (_jsxs(Box, { flexDirection: "column", children: [error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), _jsx(MergeWorktree, { onComplete: handleReturnToMenu, onCancel: handleReturnToMenu })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), _jsx(MergeWorktree, { projectPath: selectedProject?.path, onComplete: handleReturnToMenu, onCancel: handleReturnToMenu })] }));
     }
     if (view === 'configuration') {
         return (_jsx(Configuration, { scope: configScope, onComplete: handleReturnToMenu }));

package/dist/components/MergeWorktree.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 interface MergeWorktreeProps {
+    projectPath?: string;
     onComplete: () => void;
     onCancel: () => void;
 }

package/dist/components/MergeWorktree.js

@@ -9,7 +9,7 @@ import Confirmation, { SimpleConfirmation } from './Confirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 import { GitError } from '../types/errors.js';
 import { hasUncommittedChanges } from '../utils/gitUtils.js';
-const MergeWorktree = ({ onComplete, onCancel, }) => {
+const MergeWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [step, setStep] = useState('select-source');
     const [sourceBranch, setSourceBranch] = useState('');
     const [targetBranch, setTargetBranch] = useState('');
@@ -17,7 +17,6 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
     const [originalBranchItems, setOriginalBranchItems] = useState([]);
     const [operation, setOperation] = useState('merge');
     const [mergeError, setMergeError] = useState(null);
-    const [worktreeService] = useState(() => new WorktreeService());
     const [mergeConfig] = useState(() => configReader.getMergeConfig());
     const [isLoading, setIsLoading] = useState(true);
     const [loadError, setLoadError] = useState(null);
@@ -25,6 +24,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         let cancelled = false;
         const loadWorktrees = async () => {
             try {
+                const worktreeService = new WorktreeService(projectPath);
                 const loadedWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                 if (!cancelled) {
                     // Create branch items for selection
@@ -56,7 +56,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         return () => {
             cancelled = true;
         };
-    }, [worktreeService]);
+    }, [projectPath]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
@@ -85,6 +85,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             return;
         const performMerge = async () => {
             try {
+                const worktreeService = new WorktreeService(projectPath);
                 await Effect.runPromise(worktreeService.mergeWorktreeEffect(sourceBranch, targetBranch, operation, mergeConfig));
                 // Merge successful, check for uncommitted changes before asking about deletion
                 setStep('check-uncommitted');
@@ -101,14 +102,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             }
         };
         performMerge();
-    }, [
-        step,
-        sourceBranch,
-        targetBranch,
-        operation,
-        mergeConfig,
-        worktreeService,
-    ]);
+    }, [step, sourceBranch, targetBranch, operation, mergeConfig, projectPath]);
     // Check for uncommitted changes in source worktree when entering check-uncommitted step
     useEffect(() => {
         if (step !== 'check-uncommitted')
@@ -116,6 +110,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         const checkUncommitted = async () => {
             try {
                 // Find the worktree path for the source branch
+                const worktreeService = new WorktreeService(projectPath);
                 const worktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                 const sourceWorktree = worktrees.find(wt => wt.branch && wt.branch.replace('refs/heads/', '') === sourceBranch);
                 if (sourceWorktree && hasUncommittedChanges(sourceWorktree.path)) {
@@ -131,7 +126,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
             }
         };
         checkUncommitted();
-    }, [step, sourceBranch, worktreeService]);
+    }, [step, sourceBranch, projectPath]);
     if (isLoading) {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "cyan", children: "Loading worktrees..." }) }));
     }
@@ -197,6 +192,7 @@ const MergeWorktree = ({ onComplete, onCancel, }) => {
         return (_jsx(SimpleConfirmation, { message: deleteMessage, onConfirm: async () => {
                 try {
                     // Find the worktree path for the source branch
+                    const worktreeService = new WorktreeService(projectPath);
                     const worktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                     const sourceWorktree = worktrees.find(wt => wt.branch &&
                         wt.branch.replace('refs/heads/', '') === sourceBranch);

package/dist/components/MergeWorktree.test.js

@@ -40,6 +40,61 @@ describe('MergeWorktree - Effect Integration', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
+    it('should pass projectPath to WorktreeService when provided', async () => {
+        const projectPath = '/test/project';
+        const mockWorktrees = [
+            {
+                path: '/test/project/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+            {
+                path: '/test/project/feature',
+                branch: 'feature-1',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        const mockEffect = Effect.succeed(mockWorktrees);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: vi.fn(() => mockEffect),
+            };
+        });
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        render(_jsx(MergeWorktree, { projectPath: projectPath, onComplete: onComplete, onCancel: onCancel }));
+        await new Promise(resolve => setTimeout(resolve, 50));
+        expect(WorktreeService).toHaveBeenCalledWith(projectPath);
+    });
+    it('should use undefined when projectPath not provided', async () => {
+        const mockWorktrees = [
+            {
+                path: '/test/main',
+                branch: 'main',
+                isMainWorktree: true,
+                hasSession: false,
+            },
+            {
+                path: '/test/feature',
+                branch: 'feature-1',
+                isMainWorktree: false,
+                hasSession: false,
+            },
+        ];
+        const mockEffect = Effect.succeed(mockWorktrees);
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: vi.fn(() => mockEffect),
+            };
+        });
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        render(_jsx(MergeWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        await new Promise(resolve => setTimeout(resolve, 50));
+        expect(WorktreeService).toHaveBeenCalledWith(undefined);
+    });
     it('should load worktrees using Effect-based method', async () => {
         // GIVEN: Mock worktrees returned by Effect
         const mockWorktrees = [

package/dist/services/sessionManager.d.ts

@@ -18,6 +18,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private autoApprovalDisabledWorktrees;
     private restoringSessions;
     private bufferedRestoreData;
+    private restoreRefreshTimers;
+    private restoreRefreshDeadlines;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -39,6 +41,10 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private createTerminal;
     private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
+    private scheduleRestoreRefresh;
+    private armRestoreRefreshTimer;
+    private cancelRestoreRefresh;
+    private fireRestoreRefresh;
     private createSessionInternal;
     /**
      * Create session with command preset using Effect-based error handling

package/dist/services/sessionManager.js

@@ -21,6 +21,15 @@ const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
 const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
+// Claude Code's Ink-based renderer sometimes splits a single UI redraw across
+// multiple PTY writes with short time gaps. If we snapshot between chunks, the
+// resulting viewport can miss rows (e.g. empty middle area while the top/bottom
+// chrome already rendered). Re-emit the snapshot after the PTY output has been
+// quiet for this long so late chunks are accounted for.
+const RESTORE_REFRESH_QUIET_MS = 120;
+// Cap on how long we wait for quiet before forcing the refresh, so continuous
+// streaming output (e.g. a long busy turn) still produces an updated snapshot.
+const RESTORE_REFRESH_MAX_WAIT_MS = 400;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -28,6 +37,8 @@ export class SessionManager extends EventEmitter {
     autoApprovalDisabledWorktrees = new Set();
     restoringSessions = new Set();
     bufferedRestoreData = new Map();
+    restoreRefreshTimers = new Map();
+    restoreRefreshDeadlines = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -205,7 +216,7 @@ export class SessionManager extends EventEmitter {
             data.includes('\x1b[3J') ||
             data.includes('\x1bc'));
     }
-    getRestoreSnapshot(session) {
+    getRestoreSnapshot(session, options = {}) {
         const activeBuffer = session.terminal.buffer.active;
         if (activeBuffer.type !== 'normal') {
             return session.serializer.serialize({
@@ -217,6 +228,22 @@ export class SessionManager extends EventEmitter {
         if (bufferLength === 0) {
             return '';
         }
+        // While the session is busy, cursor-addressed status-box redraws can push
+        // stale frames into scrollback (e.g. Claude's spinner + token stats line).
+        // Those ghost rows render as duplicated status bars when replayed, so
+        // restore only the viewport during busy state. Refresh re-emits also
+        // bypass scrollback to avoid duplicating history into real-terminal
+        // scrollback on top of the initial emit.
+        const isBusy = session.stateMutex.getSnapshot().state === 'busy';
+        if (options.viewportOnly || isBusy) {
+            const snapshot = session.serializer.serialize({
+                scrollback: 0,
+                excludeAltBuffer: true,
+            });
+            const cursorRow = normalBuffer.cursorY + 1;
+            const cursorCol = normalBuffer.cursorX + 1;
+            return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
+        }
         const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
         const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
         const rangeEnd = bufferLength - 1;
@@ -231,6 +258,56 @@ export class SessionManager extends EventEmitter {
         const cursorCol = normalBuffer.cursorX + 1;
         return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
     }
+    scheduleRestoreRefresh(session) {
+        this.restoreRefreshDeadlines.set(session.id, Date.now() + RESTORE_REFRESH_MAX_WAIT_MS);
+        this.armRestoreRefreshTimer(session);
+    }
+    armRestoreRefreshTimer(session) {
+        const deadline = this.restoreRefreshDeadlines.get(session.id);
+        if (deadline === undefined) {
+            return;
+        }
+        const existing = this.restoreRefreshTimers.get(session.id);
+        if (existing !== undefined) {
+            clearTimeout(existing);
+            this.restoreRefreshTimers.delete(session.id);
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            this.fireRestoreRefresh(session);
+            return;
+        }
+        const delay = Math.min(RESTORE_REFRESH_QUIET_MS, remaining);
+        const timer = setTimeout(() => this.fireRestoreRefresh(session), delay);
+        this.restoreRefreshTimers.set(session.id, timer);
+    }
+    cancelRestoreRefresh(session) {
+        const existing = this.restoreRefreshTimers.get(session.id);
+        if (existing !== undefined) {
+            clearTimeout(existing);
+            this.restoreRefreshTimers.delete(session.id);
+        }
+        this.restoreRefreshDeadlines.delete(session.id);
+    }
+    fireRestoreRefresh(session) {
+        this.restoreRefreshTimers.delete(session.id);
+        this.restoreRefreshDeadlines.delete(session.id);
+        if (!session.isActive) {
+            return;
+        }
+        const snapshot = this.getRestoreSnapshot(session, { viewportOnly: true });
+        if (snapshot.length > 0) {
+            // \x1b[2J: clear the viewport before repainting — without this, a
+            //   refresh snapshot shorter than the already-displayed content leaves
+            //   a "ghost tail" of pre-refresh rows at the bottom.
+            // \x1b[?7h / \x1b[?7l: Session.tsx disables auto-wrap (DECAWM) after
+            //   the initial restore, but SerializeAddon omits row separators for
+            //   wrapped lines and relies on DECAWM to advance to the next row
+            //   (see PR #276). Re-enable auto-wrap just for the snapshot write so
+            //   wrapped viewport rows don't overlap, then restore the TUI default.
+            this.emit('sessionRestore', session, `\x1b[?7h\x1b[2J\x1b[H${snapshot}\x1b[?7l`);
+        }
+    }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
         const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
@@ -334,6 +411,12 @@ export class SessionManager extends EventEmitter {
                     session.terminal.buffer.normal.baseY;
             }
             session.lastActivity = new Date();
+            // If a restore-refresh is pending, each incoming chunk resets the
+            // quiet timer so the follow-up snapshot only fires after Claude's
+            // multi-chunk redraw has settled.
+            if (this.restoreRefreshDeadlines.has(session.id)) {
+                this.armRestoreRefreshTimer(session);
+            }
             // Only emit data events when session is active
             if (session.isActive) {
                 if (this.restoringSessions.has(session.id)) {
@@ -493,10 +576,12 @@ export class SessionManager extends EventEmitter {
                         }
                     }
                 }
+                this.scheduleRestoreRefresh(session);
             }
             else {
                 this.restoringSessions.delete(session.id);
                 this.bufferedRestoreData.delete(session.id);
+                this.cancelRestoreRefresh(session);
             }
         }
     }
@@ -571,6 +656,7 @@ export class SessionManager extends EventEmitter {
             this.waitingWithBottomBorder.delete(sessionId);
             this.restoringSessions.delete(sessionId);
             this.bufferedRestoreData.delete(sessionId);
+            this.cancelRestoreRefresh(session);
             this.emit('sessionDestroyed', session);
         }
     }
@@ -624,6 +710,7 @@ export class SessionManager extends EventEmitter {
                 }
                 this.sessions.delete(sessionId);
                 this.waitingWithBottomBorder.delete(sessionId);
+                this.cancelRestoreRefresh(session);
                 this.emit('sessionDestroyed', session);
             },
             catch: (error) => {

package/dist/services/sessionManager.test.js

@@ -782,6 +782,7 @@ describe('SessionManager', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            await session.stateMutex.update(data => ({ ...data, state: 'idle' }));
             const normalBuffer = session.terminal.buffer.normal;
             normalBuffer.baseY = 260;
             normalBuffer.length = 300;
@@ -803,6 +804,32 @@ describe('SessionManager', () => {
             });
             expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
         });
+        it('should emit a viewport-only restore snapshot while session is busy', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.baseY = 260;
+            normalBuffer.length = 300;
+            normalBuffer.cursorY = 7;
+            normalBuffer.cursorX = 11;
+            session.restoreScrollbackBaseLine = 120;
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31mbusy-viewport\u001b[0m');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
+            expect(serializeMock).toHaveBeenCalledWith({
+                scrollback: 0,
+                excludeAltBuffer: true,
+            });
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mbusy-viewport\u001b[0m\u001b[8;12H');
+        });
         it('should keep viewport-only restore behavior for alternate screen sessions', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -872,6 +899,90 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(eventOrder).toEqual(['restore', 'data']);
         });
+        it('should re-emit a viewport-only snapshot after the PTY quiet period', async () => {
+            vi.useFakeTimers();
+            try {
+                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                    id: '1',
+                    name: 'Main',
+                    command: 'claude',
+                });
+                vi.mocked(spawn).mockReturnValue(mockPty);
+                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+                session.terminal.buffer.normal.length = 1;
+                const serializeMock = vi
+                    .spyOn(session.serializer, 'serialize')
+                    .mockReturnValue('snap');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+                await vi.advanceTimersByTimeAsync(50);
+                mockPty.emit('data', 'late-chunk');
+                await vi.advanceTimersByTimeAsync(50);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+                await vi.advanceTimersByTimeAsync(120);
+                expect(restoreHandler).toHaveBeenCalledTimes(2);
+                expect(restoreHandler.mock.calls[1]?.[1]).toMatch(/^\u001b\[\?7h\u001b\[2J\u001b\[Hsnap.*\u001b\[\?7l$/);
+                expect(serializeMock).toHaveBeenLastCalledWith({
+                    scrollback: 0,
+                    excludeAltBuffer: true,
+                });
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should force a refresh at the max-wait deadline even while data keeps streaming', async () => {
+            vi.useFakeTimers();
+            try {
+                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                    id: '1',
+                    name: 'Main',
+                    command: 'claude',
+                });
+                vi.mocked(spawn).mockReturnValue(mockPty);
+                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+                session.terminal.buffer.normal.length = 1;
+                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+                for (let elapsed = 0; elapsed < 400; elapsed += 50) {
+                    await vi.advanceTimersByTimeAsync(50);
+                    mockPty.emit('data', 'chunk');
+                }
+                expect(restoreHandler).toHaveBeenCalledTimes(2);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('should cancel a scheduled refresh when the session is deactivated', async () => {
+            vi.useFakeTimers();
+            try {
+                vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                    id: '1',
+                    name: 'Main',
+                    command: 'claude',
+                });
+                vi.mocked(spawn).mockReturnValue(mockPty);
+                const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+                session.terminal.buffer.normal.length = 1;
+                vi.spyOn(session.serializer, 'serialize').mockReturnValue('snap');
+                const restoreHandler = vi.fn();
+                sessionManager.on('sessionRestore', restoreHandler);
+                sessionManager.setSessionActive(session.id, true);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+                sessionManager.setSessionActive(session.id, false);
+                await vi.advanceTimersByTimeAsync(500);
+                expect(restoreHandler).toHaveBeenCalledTimes(1);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.8",
+	"version": "4.1.10",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.8",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.8",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.8",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.8",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.8"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.10",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.10",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.10",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.10",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.10"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",