ccmanager 3.1.4 → 3.2.1

package/dist/services/bunTerminal.js

@@ -0,0 +1,175 @@
+/**
+ * BunTerminal - A wrapper around Bun's built-in Terminal API
+ * that provides an interface compatible with the IPty interface.
+ *
+ * This replaces @skitee3000/bun-pty to avoid native library issues
+ * when running compiled Bun binaries.
+ */
+/**
+ * BunTerminal class that wraps Bun's built-in Terminal API.
+ */
+class BunTerminal {
+    constructor(file, args, options) {
+        Object.defineProperty(this, "_pid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "_cols", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_process", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_dataListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_exitListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_subprocess", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "onData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (listener) => {
+                this._dataListeners.push(listener);
+                return {
+                    dispose: () => {
+                        const index = this._dataListeners.indexOf(listener);
+                        if (index !== -1) {
+                            this._dataListeners.splice(index, 1);
+                        }
+                    },
+                };
+            }
+        });
+        Object.defineProperty(this, "onExit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (listener) => {
+                this._exitListeners.push(listener);
+                return {
+                    dispose: () => {
+                        const index = this._exitListeners.indexOf(listener);
+                        if (index !== -1) {
+                            this._exitListeners.splice(index, 1);
+                        }
+                    },
+                };
+            }
+        });
+        this._cols = options.cols ?? 80;
+        this._rows = options.rows ?? 24;
+        this._process = file;
+        // Spawn the process with Bun's built-in terminal support
+        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);
+                        }
+                    }
+                },
+            },
+        });
+        this._pid = this._subprocess.pid;
+        // Handle process exit
+        this._subprocess.exited.then(exitCode => {
+            if (!this._closed) {
+                this._closed = true;
+                for (const listener of this._exitListeners) {
+                    listener({ exitCode });
+                }
+            }
+        });
+    }
+    get pid() {
+        return this._pid;
+    }
+    get cols() {
+        return this._cols;
+    }
+    get rows() {
+        return this._rows;
+    }
+    get process() {
+        return this._process;
+    }
+    write(data) {
+        if (this._closed || !this._subprocess?.terminal) {
+            return;
+        }
+        this._subprocess.terminal.write(data);
+    }
+    resize(columns, rows) {
+        if (this._closed || !this._subprocess?.terminal) {
+            return;
+        }
+        this._cols = columns;
+        this._rows = rows;
+        this._subprocess.terminal.resize(columns, rows);
+    }
+    kill(_signal) {
+        if (this._closed) {
+            return;
+        }
+        this._closed = true;
+        if (this._subprocess?.terminal) {
+            this._subprocess.terminal.close();
+        }
+        if (this._subprocess) {
+            this._subprocess.kill();
+        }
+    }
+}
+/**
+ * Spawn a new PTY process using Bun's built-in Terminal API.
+ *
+ * @param file - The command to execute
+ * @param args - Arguments to pass to the command
+ * @param options - PTY fork options
+ * @returns An IPty instance
+ */
+export function spawn(file, args, options) {
+    return new BunTerminal(file, args, options);
+}

package/dist/services/sessionManager.autoApproval.test.js

@@ -1,12 +1,18 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { STATE_CHECK_INTERVAL_MS, STATE_PERSISTENCE_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect } from 'effect';
 const detectStateMock = vi.fn();
-const verifyNeedsPermissionMock = vi.fn(() => Effect.succeed({ needsPermission: false }));
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Create a deferred promise pattern for controllable mock
+let verifyResolve = null;
+const verifyNeedsPermissionMock = vi.fn(() => Effect.promise(() => new Promise(resolve => {
+    verifyResolve = resolve;
+})));
+vi.mock('./bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 vi.mock('./stateDetector.js', () => ({
     createStateDetector: () => ({ detectState: detectStateMock }),
@@ -47,15 +53,17 @@ vi.mock('./configurationManager.js', () => ({
 }));
 vi.mock('@xterm/headless', () => ({
     default: {
-        Terminal: vi.fn().mockImplementation(() => ({
-            buffer: {
-                active: {
-                    length: 0,
-                    getLine: vi.fn(),
+        Terminal: vi.fn().mockImplementation(function () {
+            return {
+                buffer: {
+                    active: {
+                        length: 0,
+                        getLine: vi.fn(),
+                    },
                 },
-            },
-            write: vi.fn(),
-        })),
+                write: vi.fn(),
+            };
+        }),
     },
 }));
 vi.mock('./autoApprovalVerifier.js', () => ({
@@ -70,6 +78,7 @@ describe('SessionManager - Auto Approval Recovery', () => {
         vi.useFakeTimers();
         detectStateMock.mockReset();
         verifyNeedsPermissionMock.mockClear();
+        verifyResolve = null;
         mockPtyInstances = new Map();
         eventEmitters = new Map();
         spawn.mockImplementation((_command, _args, options) => {
@@ -124,36 +133,52 @@ describe('SessionManager - Auto Approval Recovery', () => {
     it('re-enables auto approval after leaving waiting_input', async () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         // Simulate a prior auto-approval failure
-        session.autoApprovalFailed = true;
-        // First waiting_input cycle (auto-approval suppressed)
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3);
-        expect(session.state).toBe('waiting_input');
-        expect(session.autoApprovalFailed).toBe(true);
-        // Transition back to busy should reset the failure flag
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3);
-        expect(session.state).toBe('busy');
-        expect(session.autoApprovalFailed).toBe(false);
-        // Next waiting_input should trigger pending_auto_approval
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
-        expect(session.state).toBe('pending_auto_approval');
-        await Promise.resolve(); // allow handleAutoApproval promise to resolve
+        await session.stateMutex.update(data => ({
+            ...data,
+            autoApprovalFailed: true,
+        }));
+        // First waiting_input cycle (auto-approval suppressed) (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
+        expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(true);
+        // Transition back to busy should reset the failure flag (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(false);
+        // Next waiting_input should trigger pending_auto_approval (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // State should now be pending_auto_approval (waiting for verification)
+        expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
+        // Resolve the verification (needsPermission: false means auto-approve)
+        expect(verifyResolve).not.toBeNull();
+        verifyResolve({ needsPermission: false });
+        await Promise.resolve(); // allow handleAutoApproval promise to resolve
     });
     it('cancels auto approval when user input is detected', async () => {
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const abortController = new AbortController();
-        session.state = 'pending_auto_approval';
-        session.autoApprovalAbortController = abortController;
-        session.pendingState = 'pending_auto_approval';
-        session.pendingStateStart = Date.now();
+        await session.stateMutex.update(data => ({
+            ...data,
+            state: 'pending_auto_approval',
+            autoApprovalAbortController: abortController,
+            pendingState: 'pending_auto_approval',
+            pendingStateStart: Date.now(),
+        }));
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
         sessionManager.cancelAutoApproval(session.worktreePath, 'User pressed a key');
+        // Wait for async mutex update to complete (use vi.waitFor for proper async handling)
+        await vi.waitFor(() => {
+            const stateData = session.stateMutex.getSnapshot();
+            expect(stateData.autoApprovalAbortController).toBeUndefined();
+        });
+        const stateData = session.stateMutex.getSnapshot();
         expect(abortController.signal.aborted).toBe(true);
-        expect(session.autoApprovalAbortController).toBeUndefined();
-        expect(session.autoApprovalFailed).toBe(true);
-        expect(session.state).toBe('waiting_input');
-        expect(session.pendingState).toBeUndefined();
+        expect(stateData.autoApprovalAbortController).toBeUndefined();
+        expect(stateData.autoApprovalFailed).toBe(true);
+        expect(stateData.state).toBe('waiting_input');
+        expect(stateData.pendingState).toBeUndefined();
         expect(handler).toHaveBeenCalledWith(session);
         sessionManager.off('sessionStateChanged', handler);
     });
@@ -163,19 +188,26 @@ describe('SessionManager - Auto Approval Recovery', () => {
         expect(mockPty).toBeDefined();
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
-        // Advance to pending_auto_approval state
-        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
-        expect(session.state).toBe('pending_auto_approval');
+        // Advance to pending_auto_approval state (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // State should be pending_auto_approval (waiting for verification)
+        expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
+        expect(verifyNeedsPermissionMock).toHaveBeenCalled();
+        // Resolve the verification (needsPermission: false means auto-approve)
+        expect(verifyResolve).not.toBeNull();
+        verifyResolve({ needsPermission: false });
         // Wait for handleAutoApproval promise chain to fully resolve
         await vi.waitFor(() => {
-            expect(session.state).toBe('busy');
+            expect(session.stateMutex.getSnapshot().state).toBe('busy');
         });
-        expect(session.pendingState).toBeUndefined();
-        expect(session.pendingStateStart).toBeUndefined();
+        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
+        expect(session.stateMutex.getSnapshot().pendingStateStart).toBeUndefined();
         // Verify Enter key was sent to approve
         expect(mockPty.write).toHaveBeenCalledWith('\r');
-        // Verify sessionStateChanged was emitted
-        expect(handler).toHaveBeenCalledWith(expect.objectContaining({ state: 'busy' }));
+        // Verify sessionStateChanged was emitted with session containing state=busy
+        const lastCall = handler.mock.calls[handler.mock.calls.length - 1];
+        expect(lastCall).toBeDefined();
+        expect(lastCall[0].stateMutex.getSnapshot().state).toBe('busy');
         sessionManager.off('sessionStateChanged', handler);
     });
 });

package/dist/services/sessionManager.effect.test.js

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { Effect, Either } from 'effect';
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
-// 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', () => ({
@@ -24,15 +26,17 @@ 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().mockImplementation(function () {
+            return {
+                buffer: {
+                    active: {
+                        length: 0,
+                        getLine: vi.fn(),
+                    },
                 },
-            },
-            write: vi.fn(),
-        })),
+                write: vi.fn(),
+            };
+        }),
     },
 }));
 // Create a mock IPty class
@@ -110,7 +114,7 @@ describe('SessionManager Effect-based Operations', () => {
             const session = await Effect.runPromise(effect);
             expect(session).toBeDefined();
             expect(session.worktreePath).toBe('/test/worktree');
-            expect(session.state).toBe('busy');
+            expect(session.stateMutex.getSnapshot().state).toBe('busy');
         });
         it('should return Effect that fails with ConfigError when preset not found', async () => {
             // Setup mocks - both return null/undefined