ccmanager 3.2.2 → 3.2.4

package/dist/cli.js

@@ -5,6 +5,7 @@ import meow from 'meow';
 import App from './components/App.js';
 import { worktreeConfigManager } from './services/worktreeConfigManager.js';
 import { globalSessionOrchestrator } from './services/globalSessionOrchestrator.js';
+const version = typeof CCMANAGER_VERSION !== 'undefined' ? CCMANAGER_VERSION : 'dev';
 const cli = meow(`
 	Usage
 	  $ ccmanager
@@ -22,6 +23,7 @@ const cli = meow(`
 	  $ ccmanager --devc-up-command "devcontainer up --workspace-folder ." --devc-exec-command "devcontainer exec --workspace-folder ."
 `, {
     importMeta: import.meta,
+    version: version,
     flags: {
         multiProject: {
             type: 'boolean',

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/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/package.json

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