ccmanager 3.2.10 → 3.3.0

package/dist/components/ConfigureCommand.js

@@ -19,6 +19,7 @@ const createStrategyItems = () => {
             value: 'github-copilot',
         },
         cline: { label: 'Cline', value: 'cline' },
+        opencode: { label: 'OpenCode', value: 'opencode' },
     };
     return Object.values(strategies);
 };
@@ -35,6 +36,10 @@ const formatDetectionStrategy = (strategy) => {
             return 'Cursor';
         case 'github-copilot':
             return 'GitHub Copilot CLI';
+        case 'cline':
+            return 'Cline';
+        case 'opencode':
+            return 'OpenCode';
         default:
             return 'Claude';
     }

package/dist/services/sessionManager.js

@@ -12,6 +12,7 @@ import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
 import { logger } from '../utils/logger.js';
 import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
+import { getTerminalScreenContent } from '../utils/screenCapture.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -41,20 +42,9 @@ export class SessionManager extends EventEmitter {
         return detectedState;
     }
     getTerminalContent(session) {
-        const buffer = session.terminal.buffer.active;
-        const lines = [];
-        // Start from the bottom and work our way up
-        for (let i = buffer.length - 1; i >= 0 && lines.length < TERMINAL_CONTENT_MAX_LINES; i--) {
-            const line = buffer.getLine(i);
-            if (line) {
-                const text = line.translateToString(true);
-                // Skip empty lines at the bottom
-                if (lines.length > 0 || text.trim() !== '') {
-                    lines.unshift(text);
-                }
-            }
-        }
-        return lines.join('\n');
+        // Use the new screen capture utility that correctly handles
+        // both normal and alternate screen buffers
+        return getTerminalScreenContent(session.terminal, TERMINAL_CONTENT_MAX_LINES);
     }
     handleAutoApproval(session) {
         // Cancel any existing verification before starting a new one

package/dist/services/stateDetector/index.js

@@ -4,6 +4,7 @@ import { CodexStateDetector } from './codex.js';
 import { CursorStateDetector } from './cursor.js';
 import { GitHubCopilotStateDetector } from './github-copilot.js';
 import { ClineStateDetector } from './cline.js';
+import { OpenCodeStateDetector } from './opencode.js';
 export function createStateDetector(strategy = 'claude') {
     switch (strategy) {
         case 'claude':
@@ -18,6 +19,8 @@ export function createStateDetector(strategy = 'claude') {
             return new GitHubCopilotStateDetector();
         case 'cline':
             return new ClineStateDetector();
+        case 'opencode':
+            return new OpenCodeStateDetector();
         default:
             return new ClaudeStateDetector();
     }

package/dist/services/stateDetector/opencode.d.ts

@@ -0,0 +1,5 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+export declare class OpenCodeStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+}

package/dist/services/stateDetector/opencode.js

@@ -0,0 +1,17 @@
+import { BaseStateDetector } from './base.js';
+export class OpenCodeStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal);
+        // Check for waiting input state - permission required prompt
+        // The triangle symbol (△) indicates permission is required
+        if (content.includes('△ Permission required')) {
+            return 'waiting_input';
+        }
+        // Check for busy state - "esc interrupt" pattern indicates active processing
+        if (/esc.*interrupt/i.test(content)) {
+            return 'busy';
+        }
+        // Otherwise idle
+        return 'idle';
+    }
+}

package/dist/services/stateDetector/opencode.test.d.ts

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

package/dist/services/stateDetector/opencode.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { OpenCodeStateDetector } from './opencode.js';
+import { createMockTerminal } from './testUtils.js';
+describe('OpenCodeStateDetector', () => {
+    let detector;
+    let terminal;
+    beforeEach(() => {
+        detector = new OpenCodeStateDetector();
+    });
+    it('should detect waiting_input state for "△ Permission required" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Some output',
+            '△ Permission required',
+            'Press Enter to allow',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect busy state for "esc interrupt" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'Press esc to interrupt',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for "ESC INTERRUPT" (uppercase)', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'Processing...',
+            'PRESS ESC TO INTERRUPT',
+            'Working...',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect busy state for "Esc to interrupt" pattern', () => {
+        // Arrange
+        terminal = createMockTerminal(['Processing...', 'Esc to interrupt']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('busy');
+    });
+    it('should detect idle state when no patterns match', () => {
+        // Arrange
+        terminal = createMockTerminal(['Normal output', 'Some message', 'Ready']);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('idle');
+    });
+    it('should prioritize waiting_input over busy when both patterns present', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'esc to interrupt',
+            '△ Permission required',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should detect waiting_input with full permission prompt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            'opencode v0.1.0',
+            '',
+            '△ Permission required',
+            'The AI wants to execute a shell command',
+            '',
+            'Press Enter to allow, Esc to deny',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+});

package/dist/types/index.d.ts

@@ -4,7 +4,7 @@ import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 export type Terminal = InstanceType<typeof pkg.Terminal>;
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'pending_auto_approval';
-export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode';
 export interface Worktree {
     path: string;
     branch?: string;

package/dist/utils/screenCapture.d.ts

@@ -0,0 +1,36 @@
+import type { Terminal } from '@xterm/headless';
+export interface ScreenState {
+    timestamp: string;
+    bufferType: 'normal' | 'alternate';
+    cursorX: number;
+    cursorY: number;
+    cols: number;
+    rows: number;
+    lines: string[];
+}
+/**
+ * Captures the current screen state of the terminal.
+ * This correctly handles both normal and alternate screen buffers,
+ * capturing only the visible screen content (not scrollback history).
+ *
+ * @param terminal - The xterm terminal instance
+ * @returns The current screen state including all visible lines
+ */
+export declare function captureScreen(terminal: Terminal): ScreenState;
+/**
+ * Formats the screen state into a human-readable string.
+ *
+ * @param state - The screen state to format
+ * @returns Formatted string representation of the screen state
+ */
+export declare function formatScreenState(state: ScreenState): string;
+/**
+ * Gets the terminal content as a single string.
+ * This is a convenience function that captures the screen and returns
+ * just the lines joined together.
+ *
+ * @param terminal - The xterm terminal instance
+ * @param maxLines - Optional maximum number of lines to return (from the bottom)
+ * @returns The terminal content as a string
+ */
+export declare function getTerminalScreenContent(terminal: Terminal, maxLines?: number): string;

package/dist/utils/screenCapture.js

@@ -0,0 +1,70 @@
+function lineToString(line, cols) {
+    if (!line) {
+        return '';
+    }
+    return line.translateToString(true, 0, cols);
+}
+/**
+ * Captures the current screen state of the terminal.
+ * This correctly handles both normal and alternate screen buffers,
+ * capturing only the visible screen content (not scrollback history).
+ *
+ * @param terminal - The xterm terminal instance
+ * @returns The current screen state including all visible lines
+ */
+export function captureScreen(terminal) {
+    const buffer = terminal.buffer.active;
+    const lines = [];
+    // Capture only the visible screen area (terminal.rows lines)
+    // This works correctly for both normal and alternate screen buffers
+    for (let y = 0; y < terminal.rows; y++) {
+        const line = buffer.getLine(y);
+        lines.push(lineToString(line, terminal.cols));
+    }
+    return {
+        timestamp: new Date().toISOString(),
+        bufferType: buffer.type,
+        cursorX: buffer.cursorX,
+        cursorY: buffer.cursorY,
+        cols: terminal.cols,
+        rows: terminal.rows,
+        lines,
+    };
+}
+/**
+ * Formats the screen state into a human-readable string.
+ *
+ * @param state - The screen state to format
+ * @returns Formatted string representation of the screen state
+ */
+export function formatScreenState(state) {
+    const separator = '-'.repeat(state.cols);
+    let output = `\n[${state.timestamp}] Buffer: ${state.bufferType} | Cursor: (${state.cursorX}, ${state.cursorY}) | Size: ${state.cols}x${state.rows}\n${separator}\n`;
+    for (const line of state.lines) {
+        output += line + '\n';
+    }
+    output += `${separator}\n\n`;
+    return output;
+}
+/**
+ * Gets the terminal content as a single string.
+ * This is a convenience function that captures the screen and returns
+ * just the lines joined together.
+ *
+ * @param terminal - The xterm terminal instance
+ * @param maxLines - Optional maximum number of lines to return (from the bottom)
+ * @returns The terminal content as a string
+ */
+export function getTerminalScreenContent(terminal, maxLines) {
+    const state = captureScreen(terminal);
+    let lines = state.lines;
+    // Trim empty lines from the bottom
+    while (lines.length > 0 && lines[lines.length - 1]?.trim() === '') {
+        lines.pop();
+    }
+    // If maxLines is specified, take only the last maxLines
+    if (maxLines !== undefined && lines.length > maxLines) {
+        lines = lines.slice(-maxLines);
+    }
+    return lines.join('\n');
+}

package/package.json

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