ccmanager 3.1.4 → 3.2.1

package/dist/services/sessionManager.test.js

@@ -1,16 +1,22 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { Effect } from 'effect';
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import { exec } from 'child_process';
-// Mock node-pty
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Mock bunTerminal
+vi.mock('./bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 // Mock child_process
 vi.mock('child_process', () => ({
-    exec: vi.fn(),
-    execFile: vi.fn(),
+    exec: vi.fn(function () {
+        return null;
+    }),
+    execFile: vi.fn(function () {
+        return null;
+    }),
 }));
 // Mock configuration manager
 vi.mock('./configurationManager.js', () => ({
@@ -29,20 +35,28 @@ vi.mock('./configurationManager.js', () => ({
 // Mock Terminal
 vi.mock('@xterm/headless', () => ({
     default: {
-        Terminal: vi.fn().mockImplementation(() => ({
-            buffer: {
-                active: {
-                    length: 0,
-                    getLine: vi.fn(),
+        Terminal: vi.fn(function () {
+            return {
+                buffer: {
+                    active: {
+                        length: 0,
+                        getLine: vi.fn(function () {
+                            return null;
+                        }),
+                    },
                 },
-            },
-            write: vi.fn(),
-        })),
+                write: vi.fn(function () {
+                    return undefined;
+                }),
+            };
+        }),
     },
 }));
 // Mock worktreeService
 vi.mock('./worktreeService.js', () => ({
-    WorktreeService: vi.fn(),
+    WorktreeService: vi.fn(function () {
+        return {};
+    }),
 }));
 // Create a mock IPty class
 class MockPty extends EventEmitter {
@@ -705,13 +719,20 @@ describe('SessionManager', () => {
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {
+            // Helper to create mock session with stateMutex
+            const createMockSession = (id, state) => ({
+                id,
+                stateMutex: {
+                    getSnapshot: () => ({ state }),
+                },
+            });
             it('should count sessions by state', () => {
                 const sessions = [
-                    { id: '1', state: 'idle' },
-                    { id: '2', state: 'busy' },
-                    { id: '3', state: 'busy' },
-                    { id: '4', state: 'waiting_input' },
-                    { id: '5', state: 'idle' },
+                    createMockSession('1', 'idle'),
+                    createMockSession('2', 'busy'),
+                    createMockSession('3', 'busy'),
+                    createMockSession('4', 'waiting_input'),
+                    createMockSession('5', 'idle'),
                 ];
                 const counts = SessionManager.getSessionCounts(sessions);
                 expect(counts.idle).toBe(2);
@@ -728,9 +749,9 @@ describe('SessionManager', () => {
             });
             it('should handle sessions with single state', () => {
                 const sessions = [
-                    { id: '1', state: 'busy' },
-                    { id: '2', state: 'busy' },
-                    { id: '3', state: 'busy' },
+                    createMockSession('1', 'busy'),
+                    createMockSession('2', 'busy'),
+                    createMockSession('3', 'busy'),
                 ];
                 const counts = SessionManager.getSessionCounts(sessions);
                 expect(counts.idle).toBe(0);

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
-import { IPty } from 'node-pty';
+import type { IPty } from '../services/bunTerminal.js';
 import type pkg from '@xterm/headless';
 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';
@@ -16,7 +17,6 @@ export interface Session {
     id: string;
     worktreePath: string;
     process: IPty;
-    state: SessionState;
     output: string[];
     outputHistory: Buffer[];
     lastActivity: Date;
@@ -27,11 +27,12 @@ export interface Session {
     commandConfig: CommandConfig | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
-    pendingState: SessionState | undefined;
-    pendingStateStart: number | undefined;
-    autoApprovalFailed: boolean;
-    autoApprovalReason?: string;
-    autoApprovalAbortController?: AbortController;
+    /**
+     * Mutex-protected session state data.
+     * Access via stateMutex.runExclusive() or stateMutex.update() to ensure thread-safe operations.
+     * Contains: state, pendingState, pendingStateStart, autoApprovalFailed, autoApprovalReason, autoApprovalAbortController
+     */
+    stateMutex: Mutex<SessionStateData>;
 }
 export interface AutoApprovalResponse {
     needsPermission: boolean;

package/dist/utils/hookExecutor.test.js

@@ -7,6 +7,7 @@ import { join } from 'path';
 import { configurationManager } from '../services/configurationManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
+import { Mutex, createInitialSessionStateData } from './mutex.js';
 // Mock the configurationManager
 vi.mock('../services/configurationManager.js', () => ({
     configurationManager: {
@@ -15,7 +16,11 @@ vi.mock('../services/configurationManager.js', () => ({
 }));
 // Mock the WorktreeService
 vi.mock('../services/worktreeService.js', () => ({
-    WorktreeService: vi.fn(),
+    WorktreeService: vi.fn(function () {
+        return {
+            getWorktreesEffect: vi.fn(),
+        };
+    }),
 }));
 // Note: This file contains integration tests that execute real commands
 describe('hookExecutor Integration Tests', () => {
@@ -262,29 +267,28 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
-            vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktreesEffect: vi.fn(() => Effect.succeed([
-                    {
-                        path: tmpDir,
-                        branch: 'test-branch',
-                        isMainWorktree: false,
-                        hasSession: true,
-                    },
-                ])),
-            }));
+            vi.mocked(WorktreeService).mockImplementation(function () {
+                return {
+                    getWorktreesEffect: vi.fn(() => Effect.succeed([
+                        {
+                            path: tmpDir,
+                            branch: 'test-branch',
+                            isMainWorktree: false,
+                            hasSession: true,
+                        },
+                    ])),
+                };
+            });
             // Configure mock to return a hook that writes to a file with delay
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
                 busy: {
@@ -317,29 +321,28 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
-            vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktreesEffect: vi.fn(() => Effect.succeed([
-                    {
-                        path: tmpDir,
-                        branch: 'test-branch',
-                        isMainWorktree: false,
-                        hasSession: true,
-                    },
-                ])),
-            }));
+            vi.mocked(WorktreeService).mockImplementation(function () {
+                return {
+                    getWorktreesEffect: vi.fn(() => Effect.succeed([
+                        {
+                            path: tmpDir,
+                            branch: 'test-branch',
+                            isMainWorktree: false,
+                            hasSession: true,
+                        },
+                    ])),
+                };
+            });
             // Configure mock to return a hook that fails
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
                 busy: {
@@ -370,29 +373,28 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to return a worktree with the tmpDir path
-            vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktreesEffect: vi.fn(() => Effect.succeed([
-                    {
-                        path: tmpDir,
-                        branch: 'test-branch',
-                        isMainWorktree: false,
-                        hasSession: true,
-                    },
-                ])),
-            }));
+            vi.mocked(WorktreeService).mockImplementation(function () {
+                return {
+                    getWorktreesEffect: vi.fn(() => Effect.succeed([
+                        {
+                            path: tmpDir,
+                            branch: 'test-branch',
+                            isMainWorktree: false,
+                            hasSession: true,
+                        },
+                    ])),
+                };
+            });
             // Configure mock to return a disabled hook
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
                 busy: {
@@ -425,26 +427,25 @@ describe('hookExecutor Integration Tests', () => {
                 terminal: {},
                 output: [],
                 outputHistory: [],
-                state: 'idle',
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 commandConfig: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
-                pendingState: undefined,
-                pendingStateStart: undefined,
                 lastActivity: new Date(),
                 isActive: true,
-                autoApprovalFailed: false,
+                stateMutex: new Mutex(createInitialSessionStateData()),
             };
             // Mock WorktreeService to fail with GitError
-            vi.mocked(WorktreeService).mockImplementation(() => ({
-                getWorktreesEffect: vi.fn(() => Effect.fail(new GitError({
-                    command: 'git worktree list --porcelain',
-                    exitCode: 128,
-                    stderr: 'not a git repository',
-                }))),
-            }));
+            vi.mocked(WorktreeService).mockImplementation(function () {
+                return {
+                    getWorktreesEffect: vi.fn(() => Effect.fail(new GitError({
+                        command: 'git worktree list --porcelain',
+                        exitCode: 128,
+                        stderr: 'not a git repository',
+                    }))),
+                };
+            });
             // Configure mock to return a hook that should execute despite worktree query failure
             vi.mocked(configurationManager.getStatusHooks).mockReturnValue({
                 busy: {

package/dist/utils/mutex.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A simple mutex implementation for protecting shared state.
+ * Provides exclusive access to wrapped data through async locking.
+ */
+export declare class Mutex<T> {
+    private data;
+    private locked;
+    private waitQueue;
+    constructor(initialData: T);
+    /**
+     * Acquire the lock. Returns a promise that resolves when the lock is acquired.
+     */
+    private acquire;
+    /**
+     * Release the lock, allowing the next waiter to proceed.
+     */
+    private release;
+    /**
+     * Run a function with exclusive access to the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns updated data or a promise of updated data
+     * @returns Promise that resolves with the function's return value
+     */
+    runExclusive<R>(fn: (data: T) => R | Promise<R>): Promise<R>;
+    /**
+     * Run a function with exclusive access and update the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns the updated data
+     */
+    update(fn: (data: T) => T | Promise<T>): Promise<void>;
+    /**
+     * Get a snapshot of the current data without acquiring the lock.
+     * Use with caution - this does not guarantee consistency.
+     * Prefer runExclusive for reads that need to be consistent with writes.
+     */
+    getSnapshot(): T;
+}
+/**
+ * Interface for the session state data protected by mutex.
+ */
+export interface SessionStateData {
+    state: import('../types/index.js').SessionState;
+    pendingState: import('../types/index.js').SessionState | undefined;
+    pendingStateStart: number | undefined;
+    autoApprovalFailed: boolean;
+    autoApprovalReason: string | undefined;
+    autoApprovalAbortController: AbortController | undefined;
+}
+/**
+ * Create initial session state data with default values.
+ */
+export declare function createInitialSessionStateData(): SessionStateData;

package/dist/utils/mutex.js

@@ -0,0 +1,104 @@
+/**
+ * A simple mutex implementation for protecting shared state.
+ * Provides exclusive access to wrapped data through async locking.
+ */
+export class Mutex {
+    constructor(initialData) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "locked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "waitQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.data = initialData;
+    }
+    /**
+     * Acquire the lock. Returns a promise that resolves when the lock is acquired.
+     */
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return;
+        }
+        return new Promise(resolve => {
+            this.waitQueue.push(resolve);
+        });
+    }
+    /**
+     * Release the lock, allowing the next waiter to proceed.
+     */
+    release() {
+        const next = this.waitQueue.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+    /**
+     * Run a function with exclusive access to the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns updated data or a promise of updated data
+     * @returns Promise that resolves with the function's return value
+     */
+    async runExclusive(fn) {
+        await this.acquire();
+        try {
+            const result = await fn(this.data);
+            return result;
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Run a function with exclusive access and update the protected data.
+     * The lock is acquired before the function runs and released after it completes.
+     *
+     * @param fn - Function that receives the current data and returns the updated data
+     */
+    async update(fn) {
+        await this.acquire();
+        try {
+            this.data = await fn(this.data);
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Get a snapshot of the current data without acquiring the lock.
+     * Use with caution - this does not guarantee consistency.
+     * Prefer runExclusive for reads that need to be consistent with writes.
+     */
+    getSnapshot() {
+        return this.data;
+    }
+}
+/**
+ * Create initial session state data with default values.
+ */
+export function createInitialSessionStateData() {
+    return {
+        state: 'busy',
+        pendingState: undefined,
+        pendingStateStart: undefined,
+        autoApprovalFailed: false,
+        autoApprovalReason: undefined,
+        autoApprovalAbortController: undefined,
+    };
+}

package/dist/utils/worktreeUtils.js

@@ -71,7 +71,9 @@ export function extractBranchParts(branchName) {
 export function prepareWorktreeItems(worktrees, sessions) {
     return worktrees.map(wt => {
         const session = sessions.find(s => s.worktreePath === wt.path);
-        const status = session ? ` [${getStatusDisplay(session.state)}]` : '';
+        const status = session
+            ? ` [${getStatusDisplay(session.stateMutex.getSnapshot().state)}]`
+            : '';
         const fullBranchName = wt.branch
             ? wt.branch.replace('refs/heads/', '')
             : 'detached';

package/dist/utils/worktreeUtils.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { generateWorktreeDirectory, extractBranchParts, truncateString, prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from './worktreeUtils.js';
 import { execSync } from 'child_process';
+import { Mutex, createInitialSessionStateData } from './mutex.js';
 // Mock child_process module
 vi.mock('child_process');
 describe('generateWorktreeDirectory', () => {
@@ -121,7 +122,6 @@ describe('prepareWorktreeItems', () => {
     const mockSession = {
         id: 'test-session',
         worktreePath: '/path/to/worktree',
-        state: 'idle',
         process: {},
         output: [],
         outputHistory: [],
@@ -133,9 +133,10 @@ describe('prepareWorktreeItems', () => {
         commandConfig: undefined,
         detectionStrategy: 'claude',
         devcontainerConfig: undefined,
-        pendingState: undefined,
-        pendingStateStart: undefined,
-        autoApprovalFailed: false,
+        stateMutex: new Mutex({
+            ...createInitialSessionStateData(),
+            state: 'idle',
+        }),
     };
     it('should prepare basic worktree without git status', () => {
         const items = prepareWorktreeItems([mockWorktree], []);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.1.4",
+	"version": "3.2.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -17,41 +17,40 @@
 		"cli"
 	],
 	"bin": {
-		"ccmanager": "dist/cli.js"
+		"ccmanager": "bin/cli.js"
 	},
 	"type": "module",
-	"engines": {
-		"node": ">=22"
-	},
 	"scripts": {
-		"build": "tsc",
-		"dev": "tsc --watch",
-		"start": "node dist/cli.js",
+		"build": "bun run tsc",
+		"build:binary": "bun run scripts/build-binaries.ts",
+		"build:binary:native": "bun run scripts/build-binaries.ts --target=native",
+		"build:binary:all": "bun run scripts/build-binaries.ts --target=all",
+		"dev": "bun run tsc --watch",
+		"start": "bun dist/cli.js",
 		"test": "vitest --run",
-		"lint": "eslint src",
-		"lint:fix": "eslint src --fix",
-		"typecheck": "tsc --noEmit",
-		"prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build",
-		"prepare": "npm run build"
+		"lint": "bun run eslint src",
+		"lint:fix": "bun run eslint src --fix",
+		"typecheck": "bun run tsc --noEmit",
+		"prepublishOnly": "bun run lint && bun run typecheck && bun run test && bun run build",
+		"prepare": "bun run build",
+		"publish:packages": "bun run scripts/publish-packages.ts",
+		"publish:packages:dry": "bun run scripts/publish-packages.ts --dry-run"
 	},
 	"files": [
-		"dist"
+		"dist",
+		"bin"
 	],
-	"dependencies": {
-		"@xterm/headless": "^5.5.0",
-		"effect": "^3.18.2",
-		"ink": "^4.1.0",
-		"ink-select-input": "^5.0.0",
-		"ink-text-input": "^5.0.1",
-		"meow": "^11.0.0",
-		"node-pty": "^1.0.0",
-		"react": "^18.2.0",
-		"strip-ansi": "^7.1.0"
+	"optionalDependencies": {
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.2.1",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.2.1",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.2.1",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.2.1",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.2.1"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",
 		"@sindresorhus/tsconfig": "^3.0.1",
-		"@types/node": "^20.0.0",
+		"@types/bun": "latest",
 		"@types/react": "^18.0.32",
 		"@typescript-eslint/eslint-plugin": "^8.33.1",
 		"@typescript-eslint/parser": "^8.33.1",
@@ -62,11 +61,22 @@
 		"eslint-plugin-prettier": "^5.4.1",
 		"eslint-plugin-react": "^7.32.2",
 		"eslint-plugin-react-hooks": "^5.2.0",
-		"ink-testing-library": "^3.0.0",
+		"ink-testing-library": "4.0.0",
 		"prettier": "^3.0.0",
-		"ts-node": "^10.9.1",
 		"typescript": "^5.0.3",
-		"vitest": "^3.2.2"
+		"vitest": "^4.0.16"
 	},
-	"prettier": "@vdemedes/prettier-config"
+	"prettier": "@vdemedes/prettier-config",
+	"dependencies": {
+		"@xterm/headless": "^5.5.0",
+		"effect": "^3.18.2",
+		"ink": "5.2.1",
+		"ink-select-input": "^6.0.0",
+		"ink-text-input": "^6.0.0",
+		"meow": "^11.0.0",
+		"react": "18.3.1",
+		"react-devtools-core": "^4.19.1",
+		"react-dom": "18.3.1",
+		"strip-ansi": "^7.1.0"
+	}
 }