ccmanager 3.2.3 → 3.2.5

package/dist/components/Session.js

@@ -68,6 +68,21 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // These sequences leak as literal text when replaying buffered output
         return input.replace(/\x1B\](?:10|11);[^\x07\x1B]*(?:\x07|\x1B\\)/g, '');
     };
+    const normalizeLineEndings = (input) => {
+        // Ensure LF moves to column 0 to prevent cursor drift when ONLCR is disabled.
+        let normalized = '';
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if (char === '\n') {
+                const prev = i > 0 ? input[i - 1] : '';
+                if (prev !== '\r') {
+                    normalized += '\r';
+                }
+            }
+            normalized += char;
+        }
+        return normalized;
+    };
     useEffect(() => {
         if (!stdout)
             return;
@@ -79,6 +94,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             stdout.write('\x1b[>4m'); // Disable xterm modifyOtherKeys extensions
             stdout.write('\x1b[?1004l'); // Disable focus reporting
             stdout.write('\x1b[?2004l'); // Disable bracketed paste (can interfere with shortcuts)
+            stdout.write('\x1b[?7h'); // Re-enable auto-wrap
         };
         const sanitizeReplayBuffer = (input) => {
             // Remove terminal mode toggles emitted by Codex so replay doesn't re-enable them
@@ -91,6 +107,8 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         };
         // Reset modes immediately on entry in case a previous session left them on
         resetTerminalInputModes();
+        // Prevent line wrapping from drifting redraws in TUIs that rely on cursor-up clears.
+        stdout.write('\x1b[?7l');
         // Clear screen when entering session
         stdout.write('\x1B[2J\x1B[H');
         // Handle session restoration
@@ -101,7 +119,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                     const buffer = restoredSession.outputHistory[i];
                     if (!buffer)
                         continue;
-                    const str = sanitizeReplayBuffer(buffer.toString('utf8'));
+                    const str = normalizeLineEndings(sanitizeReplayBuffer(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
@@ -109,7 +127,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
                             .replace(/\x1B\[2J/g, '')
                             .replace(/\x1B\[H/g, '');
                         if (cleaned.length > 0) {
-                            stdout.write(cleaned);
+                            stdout.write(normalizeLineEndings(cleaned));
                         }
                     }
                     else {
@@ -144,7 +162,7 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         const handleSessionData = (activeSession, data) => {
             // Only handle data for our session
             if (activeSession.id === session.id && !isExiting) {
-                stdout.write(data);
+                stdout.write(normalizeLineEndings(data));
             }
         };
         const handleSessionExit = (exitedSession) => {

package/dist/services/__tests__/stateDetector.codex.test.js

@@ -54,6 +54,28 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for "Press enter to confirm or esc to cancel" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Press enter to confirm or esc to cancel',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should prioritize "Press enter to confirm" over busy state with esc interrupt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'esc to interrupt',
+            'Press enter to confirm or esc to cancel',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('should detect busy state for Esc to interrupt pattern', () => {
         // Arrange
         terminal = createMockTerminal([
@@ -94,4 +116,31 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for "Confirm with ... Enter" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal(['Some output', 'Confirm with Y Enter']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input for "Confirm with" pattern with longer text', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Confirm with Shift + Y Enter',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should prioritize "Confirm with ... Enter" over busy state', () => {
+        // Arrange
+        terminal = createMockTerminal(['Esc to interrupt', 'Confirm with Y Enter']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
 });

package/dist/services/__tests__/stateDetector.gemini.test.js

@@ -20,6 +20,18 @@ describe('GeminiStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect waiting_input when "Apply this change" prompt is present (without ?)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Some output from Gemini',
+                '│ Apply this change',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
         it('should detect waiting_input when "Allow execution?" prompt is present', () => {
             // Arrange
             terminal = createMockTerminal([
@@ -32,6 +44,18 @@ describe('GeminiStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect waiting_input when "Allow execution" prompt is present (without ?)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Command found: npm install',
+                '│ Allow execution',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
         it('should detect waiting_input when "Do you want to proceed?" prompt is present', () => {
             // Arrange
             terminal = createMockTerminal([
@@ -44,6 +68,40 @@ describe('GeminiStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect waiting_input when "Do you want to proceed" prompt is present (without ?)', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Changes detected',
+                '│ Do you want to proceed',
+                '│ > ',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "Waiting for user confirmation..." is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Processing...',
+                'Waiting for user confirmation...',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should prioritize "Waiting for user confirmation" over busy state', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Press ESC to cancel',
+                'Waiting for user confirmation...',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
         it('should detect waiting_input for multiline confirmation ending with "yes"', () => {
             // Arrange
             terminal = createMockTerminal([

package/dist/services/__tests__/stateDetector.github-copilot.test.js

@@ -19,6 +19,36 @@ describe('GitHubCopilotStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('detects waiting_input when "Confirm with ... Enter" pattern is present', () => {
+        // Arrange
+        terminal = createMockTerminal(['Some output', 'Confirm with Y Enter']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('detects waiting_input for "Confirm with" pattern with longer text', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            'Confirm with Shift + Y Enter',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('prioritizes "Confirm with ... Enter" over busy state', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Press Esc to cancel',
+            'Confirm with Y Enter',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('detects busy when "Esc to cancel" is present', () => {
         // Arrange
         terminal = createMockTerminal([

package/dist/services/bunTerminal.js

@@ -58,6 +58,37 @@ class BunTerminal {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "_terminal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_decoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new globalThis.TextDecoder('utf-8')
+        });
+        // Buffering to combine fragmented data chunks from the same event loop
+        Object.defineProperty(this, "_dataBuffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "_flushTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_syncOutputMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "onData", {
             enumerable: true,
             configurable: true,
@@ -93,29 +124,61 @@ class BunTerminal {
         this._cols = options.cols ?? 80;
         this._rows = options.rows ?? 24;
         this._process = file;
-        // Spawn the process with Bun's built-in terminal support
+        // Build environment with TERM variable (like node-pty does with 'name' option)
+        const env = {};
+        if (options.env) {
+            for (const [key, value] of Object.entries(options.env)) {
+                if (value !== undefined) {
+                    env[key] = value;
+                }
+            }
+        }
+        // Set TERM from the 'name' option (like node-pty does)
+        env['TERM'] = options.name || 'xterm-256color';
+        // Create a standalone Bun.Terminal instance for better control over termios settings
+        this._terminal = new Bun.Terminal({
+            cols: this._cols,
+            rows: this._rows,
+            data: (_terminal, data) => {
+                if (this._closed)
+                    return;
+                const str = typeof data === 'string'
+                    ? data
+                    : this._decoder.decode(data, { stream: true });
+                this._dataBuffer += str;
+                this._processBuffer();
+            },
+        });
+        // Match node-pty behavior by starting in raw mode (no canonical input/echo),
+        // while keeping Bun's output processing defaults intact.
+        this._terminal.setRawMode(true);
+        // Disable ONLCR in the PTY output flags to avoid double CRLF translation
+        // when forwarding PTY output to the real stdout TTY.
+        const ONLCR_FLAG = 0x0002;
+        this._terminal.outputFlags = this._terminal.outputFlags & ~ONLCR_FLAG;
+        // Keep Bun defaults for other termios flags.
+        // Spawn the process with the pre-configured terminal
         this._subprocess = Bun.spawn([file, ...args], {
             cwd: options.cwd ?? process.cwd(),
-            env: options.env,
-            terminal: {
-                cols: this._cols,
-                rows: this._rows,
-                data: (_terminal, data) => {
-                    if (!this._closed) {
-                        const str = typeof data === 'string'
-                            ? data
-                            : Buffer.from(data).toString('utf8');
-                        for (const listener of this._dataListeners) {
-                            listener(str);
-                        }
-                    }
-                },
-            },
+            env,
+            terminal: this._terminal,
         });
         this._pid = this._subprocess.pid;
         // Handle process exit
         this._subprocess.exited.then(exitCode => {
             if (!this._closed) {
+                this._closed = true;
+                // Clear any pending flush timer
+                if (this._flushTimer) {
+                    clearTimeout(this._flushTimer);
+                    this._flushTimer = null;
+                }
+                // Flush any remaining buffered data before exit
+                this._finalizeDecoder();
+                this._syncOutputMode = false;
+                // Temporarily unset _closed to allow final flush
+                this._closed = false;
+                this._flushBuffer();
                 this._closed = true;
                 for (const listener of this._exitListeners) {
                     listener({ exitCode });
@@ -123,6 +186,86 @@ class BunTerminal {
             }
         });
     }
+    _emitData(payload) {
+        if (payload.length === 0 || this._closed) {
+            return;
+        }
+        for (const listener of this._dataListeners) {
+            listener(payload);
+        }
+    }
+    _flushBuffer() {
+        if (this._dataBuffer.length === 0 || this._closed) {
+            return;
+        }
+        const bufferedData = this._dataBuffer;
+        this._dataBuffer = '';
+        this._emitData(bufferedData);
+    }
+    _finalizeDecoder() {
+        const remaining = this._decoder.decode(new Uint8Array(), { stream: false });
+        if (remaining.length > 0) {
+            this._dataBuffer += remaining;
+        }
+    }
+    _processBuffer() {
+        if (this._closed) {
+            return;
+        }
+        let madeProgress = true;
+        while (madeProgress) {
+            madeProgress = false;
+            if (this._syncOutputMode) {
+                const endIndex = this._dataBuffer.indexOf(BunTerminal.SYNC_OUTPUT_END);
+                if (endIndex !== -1) {
+                    const endOffset = endIndex + BunTerminal.SYNC_OUTPUT_END.length;
+                    const frame = this._dataBuffer.slice(0, endOffset);
+                    this._dataBuffer = this._dataBuffer.slice(endOffset);
+                    this._syncOutputMode = false;
+                    if (this._flushTimer) {
+                        clearTimeout(this._flushTimer);
+                        this._flushTimer = null;
+                    }
+                    this._emitData(frame);
+                    madeProgress = true;
+                    continue;
+                }
+                if (this._flushTimer) {
+                    clearTimeout(this._flushTimer);
+                }
+                this._flushTimer = setTimeout(() => {
+                    this._flushTimer = null;
+                    this._syncOutputMode = false;
+                    this._flushBuffer();
+                }, BunTerminal.SYNC_TIMEOUT_MS);
+                return;
+            }
+            const startIndex = this._dataBuffer.indexOf(BunTerminal.SYNC_OUTPUT_START);
+            if (startIndex !== -1) {
+                if (startIndex > 0) {
+                    const leading = this._dataBuffer.slice(0, startIndex);
+                    this._dataBuffer = this._dataBuffer.slice(startIndex);
+                    this._emitData(leading);
+                    madeProgress = true;
+                    continue;
+                }
+                this._syncOutputMode = true;
+                if (this._flushTimer) {
+                    clearTimeout(this._flushTimer);
+                    this._flushTimer = null;
+                }
+                madeProgress = true;
+                continue;
+            }
+            if (this._flushTimer) {
+                clearTimeout(this._flushTimer);
+            }
+            this._flushTimer = setTimeout(() => {
+                this._flushTimer = null;
+                this._flushBuffer();
+            }, BunTerminal.FLUSH_DELAY_MS);
+        }
+    }
     get pid() {
         return this._pid;
     }
@@ -136,32 +279,69 @@ class BunTerminal {
         return this._process;
     }
     write(data) {
-        if (this._closed || !this._subprocess?.terminal) {
+        if (this._closed || !this._terminal) {
             return;
         }
-        this._subprocess.terminal.write(data);
+        this._terminal.write(data);
     }
     resize(columns, rows) {
-        if (this._closed || !this._subprocess?.terminal) {
+        if (this._closed || !this._terminal) {
             return;
         }
         this._cols = columns;
         this._rows = rows;
-        this._subprocess.terminal.resize(columns, rows);
+        this._terminal.resize(columns, rows);
     }
     kill(_signal) {
         if (this._closed) {
             return;
         }
         this._closed = true;
-        if (this._subprocess?.terminal) {
-            this._subprocess.terminal.close();
+        // Clear any pending flush timer
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+        }
+        // Flush any remaining buffered data
+        this._finalizeDecoder();
+        this._syncOutputMode = false;
+        // Temporarily unset _closed to allow final flush
+        this._closed = false;
+        this._flushBuffer();
+        this._closed = true;
+        if (this._terminal) {
+            this._terminal.close();
         }
         if (this._subprocess) {
             this._subprocess.kill();
         }
     }
 }
+// Synchronized output escape sequences (used by Ink and other TUI frameworks)
+Object.defineProperty(BunTerminal, "SYNC_OUTPUT_START", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: '\x1b[?2026h'
+});
+Object.defineProperty(BunTerminal, "SYNC_OUTPUT_END", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: '\x1b[?2026l'
+});
+Object.defineProperty(BunTerminal, "FLUSH_DELAY_MS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 8
+}); // ~2 frames at 60fps for batching
+Object.defineProperty(BunTerminal, "SYNC_TIMEOUT_MS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 100
+}); // Timeout for sync mode
 /**
  * Spawn a new PTY process using Bun's built-in Terminal API.
  *

package/dist/services/stateDetector.js

@@ -63,10 +63,14 @@ export class GeminiStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
+        // Check for explicit user confirmation message - highest priority
+        if (lowerContent.includes('waiting for user confirmation')) {
+            return 'waiting_input';
+        }
         // Check for waiting prompts with box character
-        if (content.includes('│ Apply this change?') ||
-            content.includes('│ Allow execution?') ||
-            content.includes('│ Do you want to proceed?')) {
+        if (content.includes('│ Apply this change') ||
+            content.includes('│ Allow execution') ||
+            content.includes('│ Do you want to proceed')) {
             return 'waiting_input';
         }
         // Check for multiline confirmation prompts ending with "yes"
@@ -85,6 +89,11 @@ export class CodexStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
+        // Check for confirmation prompt patterns - highest priority
+        if (lowerContent.includes('press enter to confirm or esc to cancel') ||
+            /confirm with .+ enter/i.test(content)) {
+            return 'waiting_input';
+        }
         // Check for waiting prompts
         if (lowerContent.includes('allow command?') ||
             lowerContent.includes('[y/n]') ||
@@ -124,15 +133,19 @@ export class GitHubCopilotStateDetector extends BaseStateDetector {
     detectState(terminal, _currentState) {
         const content = this.getTerminalContent(terminal);
         const lowerContent = content.toLowerCase();
-        // Waiting prompt has priority 1
+        // Check for confirmation prompt pattern - highest priority
+        if (/confirm with .+ enter/i.test(content)) {
+            return 'waiting_input';
+        }
+        // Waiting prompt has priority 2
         if (lowerContent.includes('│ do you want')) {
             return 'waiting_input';
         }
-        // Busy state detection has priority 2
+        // Busy state detection has priority 3
         if (lowerContent.includes('esc to cancel')) {
             return 'busy';
         }
-        // Otherwise idle as priority 3
+        // Otherwise idle as priority 4
         return 'idle';
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.2.3",
+	"version": "3.2.5",
 	"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": "3.2.3",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.3",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.3",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.2.3",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.2.3"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.2.5",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.5",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.5",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.2.5",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.2.5"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",