ccmanager 4.2.2 → 4.3.0

package/README.md

@@ -130,6 +130,7 @@ CCManager supports multiple AI coding assistants with tailored state detection f
 | Cline CLI | `cline` | [github.com/cline/cline](https://github.com/cline/cline) |
 | OpenCode | `opencode` | [opencode.ai/docs](https://opencode.ai/docs) |
 | Kimi CLI | `kimi` | [kimi-cli.com](https://www.kimi-cli.com/en/) |
+| MiniMax Code (MCode) | `mcode` | [npmjs.com/package/@minimax-ai/code](https://www.npmjs.com/package/@minimax-ai/code) |
 
 Each assistant has its own state detection strategy to properly track:
 - **Idle**: Ready for new input

package/dist/components/ConfigureCommand.js

@@ -22,6 +22,7 @@ const createStrategyItems = () => {
         cline: { label: 'Cline', value: 'cline' },
         opencode: { label: 'OpenCode', value: 'opencode' },
         kimi: { label: 'Kimi', value: 'kimi' },
+        mcode: { label: 'MiniMax Code', value: 'mcode' },
     };
     return Object.values(strategies);
 };
@@ -37,6 +38,7 @@ const DEFAULT_COMMANDS = {
     cline: 'cline',
     opencode: 'opencode',
     kimi: 'kimi',
+    mcode: 'mcode',
 };
 const formatDetectionStrategy = (strategy) => {
     const value = strategy || 'claude';
@@ -55,6 +57,8 @@ const formatDetectionStrategy = (strategy) => {
             return 'OpenCode';
         case 'kimi':
             return 'Kimi';
+        case 'mcode':
+            return 'MiniMax Code';
         default:
             return 'Claude';
     }

package/dist/services/stateDetector/claude.js

@@ -111,6 +111,14 @@ export class ClaudeStateDetector extends BaseStateDetector {
         if (fullLowerContent.includes('esc to cancel')) {
             return 'waiting_input';
         }
+        // Check for permission menus without question phrasing, e.g.
+        // "Claude in Chrome wants to navigate on example.com" with:
+        //   ❯ 1. Allow
+        //     2. Deny (esc)
+        // The numbered "Deny (esc)" option is the stable marker across variants.
+        if (/\d+\.\s*deny\s*\(esc\)/.test(fullLowerContent)) {
+            return 'waiting_input';
+        }
         // Content above the prompt box only for busy detection
         const abovePromptBox = this.getRecentContentAbovePromptBox(terminal, 30);
         const aboveLowerContent = abovePromptBox.toLowerCase();

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

@@ -237,6 +237,37 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
+        it('should detect waiting_input for Claude in Chrome permission prompt (Allow/Deny)', () => {
+            // Arrange - browser permission prompt without "Do you want" phrasing
+            terminal = createMockTerminal([
+                '──────────────────────────────',
+                ' Claude in Chrome wants to create a browser window and read your tabs',
+                '',
+                ' ❯ 1. Allow',
+                '   2. Deny (esc)',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input for Claude in Chrome navigation prompt (Allow all / Deny)', () => {
+            // Arrange - three-option variant with "Allow all actions" entry
+            terminal = createMockTerminal([
+                '──────────────────────────────',
+                ' Claude in Chrome wants to navigate on example.com',
+                '',
+                ' https://example.com/app',
+                '',
+                ' ❯ 1. Allow',
+                '   2. Allow all actions on example.com for this session',
+                '   3. Deny (esc)',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
         it('should prioritize "esc to cancel" over "esc to interrupt" when both above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([

package/dist/services/stateDetector/index.js

@@ -6,6 +6,7 @@ import { GitHubCopilotStateDetector } from './github-copilot.js';
 import { ClineStateDetector } from './cline.js';
 import { OpenCodeStateDetector } from './opencode.js';
 import { KimiStateDetector } from './kimi.js';
+import { MCodeStateDetector } from './mcode.js';
 export function createStateDetector(strategy = 'claude') {
     switch (strategy) {
         case 'claude':
@@ -24,6 +25,8 @@ export function createStateDetector(strategy = 'claude') {
             return new OpenCodeStateDetector();
         case 'kimi':
             return new KimiStateDetector();
+        case 'mcode':
+            return new MCodeStateDetector();
         default:
             return new ClaudeStateDetector();
     }

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

@@ -0,0 +1,12 @@
+import { SessionState, Terminal } from '../../types/index.js';
+import { BaseStateDetector } from './base.js';
+/**
+ * State detector for MiniMax Code (MCode).
+ * Command: mcode
+ * Installation: npm install -g @minimax-ai/code
+ */
+export declare class MCodeStateDetector extends BaseStateDetector {
+    detectState(terminal: Terminal, _currentState: SessionState): SessionState;
+    detectBackgroundTask(_terminal: Terminal): number;
+    detectTeamMembers(_terminal: Terminal): number;
+}

package/dist/services/stateDetector/mcode.js

@@ -0,0 +1,34 @@
+import { BaseStateDetector } from './base.js';
+/**
+ * State detector for MiniMax Code (MCode).
+ * Command: mcode
+ * Installation: npm install -g @minimax-ai/code
+ */
+export class MCodeStateDetector extends BaseStateDetector {
+    detectState(terminal, _currentState) {
+        const content = this.getTerminalContent(terminal, 30);
+        const lowerContent = content.toLowerCase();
+        // MCode exposes pending interactive decisions in its runtime status and
+        // renders the event marker in the transcript. These take precedence over
+        // an active turn because the user must act before that turn can continue.
+        if (lowerContent.includes('permission: pending') ||
+            lowerContent.includes('[permission] permission.ask') ||
+            lowerContent.includes('ask_user: pending') ||
+            lowerContent.includes('[ask_user] questionnaire.ask')) {
+            return 'waiting_input';
+        }
+        // Current releases include a turn id; the compact fallback is emitted
+        // while a turn is starting. Match the status field rather than ordinary
+        // assistant text so historical words such as "thinking" cannot look busy.
+        if (/\bturn:\s+(?:\S+\s+)?running\b/i.test(content)) {
+            return 'busy';
+        }
+        return 'idle';
+    }
+    detectBackgroundTask(_terminal) {
+        return 0;
+    }
+    detectTeamMembers(_terminal) {
+        return 0;
+    }
+}

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

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

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

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createStateDetector } from './index.js';
+import { MCodeStateDetector } from './mcode.js';
+import { createMockTerminal } from './testUtils.js';
+describe('MCodeStateDetector', () => {
+    let detector;
+    let terminal;
+    beforeEach(() => {
+        detector = new MCodeStateDetector();
+    });
+    it('detects the published MCode ready footer as idle', () => {
+        terminal = createMockTerminal([
+            '╭─ v0.1.2                         ● Ready ─╮',
+            '│ Start · @ file · / autocomplete        │',
+            '╰─────────────────────────────────────────╯',
+        ]);
+        expect(detector.detectState(terminal, 'busy')).toBe('idle');
+    });
+    it('is selected by the mcode strategy', () => {
+        expect(createStateDetector('mcode')).toBeInstanceOf(MCodeStateDetector);
+    });
+    it('detects an active runtime turn as busy', () => {
+        terminal = createMockTerminal([
+            'session: mvs_abc | turn: turn_123 running 3s | local-runtime',
+        ]);
+        expect(detector.detectState(terminal, 'idle')).toBe('busy');
+    });
+    it('detects the compact running status as busy', () => {
+        terminal = createMockTerminal(['session: mvs_abc | turn: running']);
+        expect(detector.detectState(terminal, 'idle')).toBe('busy');
+    });
+    it.each([
+        'permission: pending',
+        '[permission] permission.ask',
+        'ask_user: pending',
+        '[ask_user] questionnaire.ask',
+    ])('detects %s as waiting for input', marker => {
+        terminal = createMockTerminal([
+            'session: mvs_abc | turn: turn_123 running 3s',
+            marker,
+        ]);
+        expect(detector.detectState(terminal, 'busy')).toBe('waiting_input');
+    });
+    it('does not mistake historical thinking text for an active turn', () => {
+        terminal = createMockTerminal([
+            'Assistant: Thinking through the previous request...',
+            '╭─ v0.1.2                         ● Ready ─╮',
+        ]);
+        expect(detector.detectState(terminal, 'busy')).toBe('idle');
+    });
+    it('reports no background tasks or team members', () => {
+        terminal = createMockTerminal([]);
+        expect(detector.detectBackgroundTask(terminal)).toBe(0);
+        expect(detector.detectTeamMembers(terminal)).toBe(0);
+    });
+});

package/dist/types/index.d.ts

@@ -8,7 +8,7 @@ import type { Effect } from 'effect';
 import type { GitError, FileSystemError, ProcessError } from './errors.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' | 'opencode' | 'kimi';
+export type StateDetectionStrategy = 'claude' | 'gemini' | 'codex' | 'cursor' | 'github-copilot' | 'cline' | 'opencode' | 'kimi' | 'mcode';
 export interface Worktree {
     path: string;
     branch?: string;

package/dist/utils/presetPrompt.js

@@ -22,7 +22,8 @@ export const getPromptInjectionMethod = (preset) => {
     if (strategy === 'claude' ||
         strategy === 'codex' ||
         strategy === 'cursor' ||
-        strategy === 'cline') {
+        strategy === 'cline' ||
+        strategy === 'mcode') {
         return 'final-arg';
     }
     return 'stdin';

package/dist/utils/presetPrompt.test.js

@@ -49,6 +49,12 @@ describe('presetPrompt', () => {
             method: 'flag',
         });
     });
+    it('uses the final argument for MCode presets', () => {
+        expect(preparePresetLaunch({ command: 'mcode', args: [], detectionStrategy: 'mcode' }, 'fix the failing tests')).toEqual({
+            args: ['fix the failing tests'],
+            method: 'final-arg',
+        });
+    });
     describe('describePromptInjection', () => {
         it('describes final-arg for claude', () => {
             expect(describePromptInjection({
@@ -98,6 +104,12 @@ describe('presetPrompt', () => {
                 detectionStrategy: 'kimi',
             })).toContain('-p');
         });
+        it('describes final-arg for MCode', () => {
+            expect(describePromptInjection({
+                command: 'mcode',
+                detectionStrategy: 'mcode',
+            })).toContain('final command argument');
+        });
     });
     describe('getPromptInjectionMethod', () => {
         it('returns final-arg for claude', () => {
@@ -148,6 +160,12 @@ describe('presetPrompt', () => {
                 detectionStrategy: 'kimi',
             })).toBe('flag');
         });
+        it('returns final-arg for MCode', () => {
+            expect(getPromptInjectionMethod({
+                command: 'mcode',
+                detectionStrategy: 'mcode',
+            })).toBe('final-arg');
+        });
         it('falls back to claude strategy when detectionStrategy is not set', () => {
             expect(getPromptInjectionMethod({ command: 'claude' })).toBe('final-arg');
         });

package/package.json

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