ccmanager 4.0.4 → 4.1.1

package/dist/components/Confirmation.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { Key } from 'ink';
 export interface ConfirmationOption {
     label: string;
     value: string;
@@ -14,9 +15,7 @@ interface ConfirmationProps {
     hint?: React.ReactNode;
     onCancel?: () => void;
     onEscape?: () => void;
-    onCustomInput?: (input: string, key: {
-        [key: string]: boolean;
-    }) => boolean;
+    onCustomInput?: (input: string, key: Key) => boolean;
 }
 /**
  * Reusable confirmation component with SelectInput UI pattern

package/dist/components/PresetSelector.test.js

@@ -60,6 +60,10 @@ const makeKey = (overrides = {}) => ({
     backspace: false,
     delete: false,
     meta: false,
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false,
     ...overrides,
 });
 describe('PresetSelector component', () => {

package/dist/components/Session.js

@@ -65,23 +65,11 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         stdout.write('\x1b[?7l');
         // Clear screen when entering session
         stdout.write('\x1B[2J\x1B[H');
-        // Handle session restoration by writing all buffered output at once.
-        // This is faster than chunk-by-chunk replay and preserves scrollback.
-        const handleSessionRestore = (restoredSession) => {
+        // Restore the current terminal state from the headless xterm snapshot.
+        const handleSessionRestore = (restoredSession, restoreSnapshot) => {
             if (restoredSession.id === session.id) {
-                if (restoredSession.outputHistory.length === 0)
-                    return;
-                // Concatenate all history buffers and write at once for better performance
-                const allHistory = Buffer.concat(restoredSession.outputHistory);
-                const historyStr = allHistory.toString('utf8');
-                // Normalize the output
-                const normalized = normalizeLineEndings(historyStr);
-                // Remove leading clear screen sequences to avoid double-clear
-                const cleaned = normalized
-                    .replace(/^\x1B\[2J/g, '')
-                    .replace(/^\x1B\[H/g, '');
-                if (cleaned.length > 0) {
-                    stdout.write(cleaned);
+                if (restoreSnapshot.length > 0) {
+                    stdout.write(restoreSnapshot);
                 }
             }
         };
@@ -102,8 +90,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         };
         sessionManager.on('sessionData', handleSessionData);
         sessionManager.on('sessionExit', handleSessionExit);
-        // Mark session as active (this will trigger the restore event)
-        sessionManager.setSessionActive(session.id, true);
         // Immediately resize the PTY and terminal to current dimensions
         // This fixes rendering issues when terminal width changed while in menu
         // https://github.com/kbwo/ccmanager/issues/2
@@ -120,6 +106,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         catch {
             /* empty */
         }
+        // Mark session as active after resizing so the restore snapshot matches
+        // the current terminal dimensions.
+        sessionManager.setSessionActive(session.id, true);
         // Handle terminal resize
         const handleResize = () => {
             const cols = process.stdout.columns || 80;

package/dist/components/Session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Session.test.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+const testState = vi.hoisted(() => ({
+    stdout: null,
+}));
+class MockStdout extends EventEmitter {
+    write = vi.fn();
+}
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useStdout: vi.fn(() => ({ stdout: testState.stdout })),
+    };
+});
+import Session from './Session.js';
+describe('Session', () => {
+    const originalColumns = process.stdout.columns;
+    const originalRows = process.stdout.rows;
+    const originalIsTTY = process.stdin.isTTY;
+    beforeEach(() => {
+        testState.stdout = new MockStdout();
+        Object.defineProperty(process.stdout, 'columns', {
+            value: 120,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdout, 'rows', {
+            value: 40,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: false,
+            configurable: true,
+        });
+    });
+    afterEach(() => {
+        testState.stdout = null;
+        Object.defineProperty(process.stdout, 'columns', {
+            value: originalColumns,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdout, 'rows', {
+            value: originalRows,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: originalIsTTY,
+            configurable: true,
+        });
+        vi.restoreAllMocks();
+    });
+    it('resizes before activating and writes restore snapshots verbatim', async () => {
+        const listeners = new Map();
+        const processResize = vi.fn();
+        const processWrite = vi.fn();
+        const terminalResize = vi.fn();
+        const setSessionActive = vi.fn((sessionId, active) => {
+            if (sessionId === session.id && active) {
+                for (const handler of listeners.get('sessionRestore') ?? []) {
+                    handler(session, '\nrestored');
+                }
+            }
+        });
+        const session = {
+            id: 'session-1',
+            process: {
+                write: processWrite,
+                resize: processResize,
+            },
+            terminal: {
+                resize: terminalResize,
+            },
+            stateMutex: {
+                getSnapshot: () => ({ state: 'idle' }),
+            },
+        };
+        const sessionManager = {
+            on: vi.fn((event, handler) => {
+                const handlers = listeners.get(event) ?? new Set();
+                handlers.add(handler);
+                listeners.set(event, handlers);
+                return sessionManager;
+            }),
+            off: vi.fn((event, handler) => {
+                listeners.get(event)?.delete(handler);
+                return sessionManager;
+            }),
+            setSessionActive,
+            cancelAutoApproval: vi.fn(),
+        };
+        render(_jsx(Session, { session: session, sessionManager: sessionManager, onReturnToMenu: vi.fn() }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(processResize).toHaveBeenCalledWith(120, 40);
+        expect(terminalResize).toHaveBeenCalledWith(120, 40);
+        expect(processResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
+        expect(terminalResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
+        expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\nrestored');
+    });
+});

package/dist/services/sessionManager.autoApproval.test.js

@@ -52,16 +52,31 @@ vi.mock('./config/configReader.js', () => ({
         setAutoApprovalEnabled: vi.fn(),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },
                 },
+                loadAddon: vi.fn(),
+                resize: vi.fn(),
                 write: vi.fn(),
             };
         }),

package/dist/services/sessionManager.d.ts

@@ -35,6 +35,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private updateSessionState;
     constructor();
     private createTerminal;
+    private getRestoreSnapshot;
     private createSessionInternal;
     /**
      * Create session with command preset using Effect-based error handling

package/dist/services/sessionManager.effect.test.js

@@ -33,17 +33,32 @@ vi.mock('./config/configReader.js', () => ({
         getStatusHooks: vi.fn(() => ({})),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 // Mock Terminal
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },
                 },
+                loadAddon: vi.fn(),
+                resize: vi.fn(),
                 write: vi.fn(),
             };
         }),

package/dist/services/sessionManager.js

@@ -1,6 +1,7 @@
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
+import { SerializeAddon } from '@xterm/addon-serialize';
 import { spawn as childSpawn } from 'child_process';
 import { configReader } from './config/configReader.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
@@ -17,6 +18,7 @@ import { injectTeammateMode } from '../utils/commandArgs.js';
 import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
+const TERMINAL_SCROLLBACK_LINES = 5000;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -192,14 +194,22 @@ export class SessionManager extends EventEmitter {
         return new Terminal({
             cols: process.stdout.columns || 80,
             rows: process.stdout.rows || 24,
+            scrollback: TERMINAL_SCROLLBACK_LINES,
             allowProposedApi: true,
             logLevel: 'off',
         });
     }
+    getRestoreSnapshot(session) {
+        return session.serializer.serialize({
+            scrollback: 0,
+        });
+    }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
         const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
         const terminal = this.createTerminal();
+        const serializer = new SerializeAddon();
+        terminal.loadAddon(serializer);
         const detectionStrategy = options.detectionStrategy ?? 'claude';
         const stateDetector = createStateDetector(detectionStrategy);
         const session = {
@@ -212,10 +222,10 @@ export class SessionManager extends EventEmitter {
             lastAccessedAt: Date.now(),
             process: ptyProcess,
             output: [],
-            outputHistory: [],
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            serializer,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
@@ -291,24 +301,6 @@ export class SessionManager extends EventEmitter {
         session.process.onData((data) => {
             // Write data to virtual terminal
             session.terminal.write(data);
-            // Check for screen clear escape sequence (e.g., from /clear command)
-            // When detected, clear the output history to prevent replaying old content on restore
-            // This helps avoid excessive scrolling when restoring sessions with large output history
-            if (data.includes('\x1B[2J')) {
-                session.outputHistory = [];
-            }
-            // Store in output history as Buffer
-            const buffer = Buffer.from(data, 'utf8');
-            session.outputHistory.push(buffer);
-            // Limit memory usage - keep max 10MB of output history
-            const MAX_HISTORY_SIZE = 10 * 1024 * 1024; // 10MB
-            let totalSize = session.outputHistory.reduce((sum, buf) => sum + buf.length, 0);
-            while (totalSize > MAX_HISTORY_SIZE && session.outputHistory.length > 0) {
-                const removed = session.outputHistory.shift();
-                if (removed) {
-                    totalSize -= removed.length;
-                }
-            }
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
@@ -479,9 +471,9 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             if (active) {
                 session.lastAccessedAt = Date.now();
-                // Emit a restore event with the output history if available
-                if (session.outputHistory.length > 0) {
-                    this.emit('sessionRestore', session);
+                const restoreSnapshot = this.getRestoreSnapshot(session);
+                if (restoreSnapshot.length > 0) {
+                    this.emit('sessionRestore', session, restoreSnapshot);
                 }
             }
         }

package/dist/services/sessionManager.test.js

@@ -37,19 +37,38 @@ vi.mock('./config/configReader.js', () => ({
         setAutoApprovalEnabled: vi.fn(),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 // Mock Terminal
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(function () {
                             return null;
                         }),
                     },
                 },
+                loadAddon: vi.fn(function () {
+                    return undefined;
+                }),
+                resize: vi.fn(function () {
+                    return undefined;
+                }),
                 write: vi.fn(function () {
                     return undefined;
                 }),
@@ -740,63 +759,37 @@ describe('SessionManager', () => {
             expect(session.isPrimaryCommand).toBe(false);
         });
     });
-    describe('clearHistoryOnClear', () => {
-        it('should clear output history when screen clear escape sequence is detected', async () => {
-            // Setup
+    describe('session restore snapshots', () => {
+        it('should emit serialized terminal output when activating a session', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate some data output
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            // Verify output history has data
-            expect(session.outputHistory.length).toBe(2);
-            // Simulate screen clear escape sequence
-            mockPty.emit('data', '\x1B[2J');
-            // Verify output history was cleared and only contains the clear sequence
-            expect(session.outputHistory.length).toBe(1);
-            expect(session.outputHistory[0]?.toString()).toBe('\x1B[2J');
-        });
-        it('should not clear output history for normal data', async () => {
-            // Setup
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31mrestored\u001b[0m');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
+            expect(serializeMock).toHaveBeenCalledWith({ scrollback: 0 });
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m');
+        });
+        it('should skip restore event when serialized output is empty', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
-            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate normal data output without screen clear
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            mockPty.emit('data', 'Even more data');
-            // Verify output history contains all data
-            expect(session.outputHistory.length).toBe(3);
-        });
-        it('should clear history when screen clear is part of larger data chunk', async () => {
-            // Setup
-            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                id: '1',
-                name: 'Main',
-                command: 'claude',
-            });
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate some data output
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            // Simulate screen clear as part of larger data chunk (e.g., from /clear command)
-            mockPty.emit('data', 'prefix\x1B[2Jsuffix');
-            // Verify output history was cleared and only contains the new chunk
-            expect(session.outputHistory.length).toBe(1);
-            expect(session.outputHistory[0]?.toString()).toBe('prefix\x1B[2Jsuffix');
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
+            expect(restoreHandler).not.toHaveBeenCalled();
         });
     });
     describe('static methods', () => {

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { IPty } from '../services/bunTerminal.js';
 import type pkg from '@xterm/headless';
+import type { SerializeAddon } from '@xterm/addon-serialize';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 import type { StateDetector } from '../services/stateDetector/types.js';
@@ -25,10 +26,10 @@ export interface Session {
     lastAccessedAt: number;
     process: IPty;
     output: string[];
-    outputHistory: Buffer[];
     lastActivity: Date;
     isActive: boolean;
     terminal: Terminal;
+    serializer: SerializeAddon;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;

package/dist/utils/hookExecutor.test.js

@@ -382,8 +382,8 @@ describe('hookExecutor Integration Tests', () => {
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -441,8 +441,8 @@ describe('hookExecutor Integration Tests', () => {
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -498,8 +498,8 @@ describe('hookExecutor Integration Tests', () => {
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -557,8 +557,8 @@ describe('hookExecutor Integration Tests', () => {
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,

package/dist/utils/worktreeUtils.test.js

@@ -129,10 +129,10 @@ describe('prepareSessionItems', () => {
         lastAccessedAt: Date.now(),
         process: {},
         output: [],
-        outputHistory: [],
         lastActivity: new Date(),
         isActive: true,
         terminal: {},
+        serializer: {},
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
         presetName: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.0.4",
+	"version": "4.1.1",
 	"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.0.4",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.0.4",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.0.4",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.0.4",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.0.4"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.1",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.1",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.1",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.1",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",
@@ -68,6 +68,7 @@
 	},
 	"prettier": "@vdemedes/prettier-config",
 	"dependencies": {
+		"@xterm/addon-serialize": "^0.14.0",
 		"@xterm/headless": "^6.0.0",
 		"effect": "^3.18.2",
 		"ink": "^6.6.0",