ccmanager 3.1.5 → 3.2.2

package/bin/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const PACKAGE_SCOPE = "@kodaikabasawa";
+const PACKAGE_NAME = "ccmanager";
+const BINARY_NAME = "ccmanager";
+
+const PLATFORM_PACKAGES = {
+	"darwin-arm64": `${PACKAGE_SCOPE}/${PACKAGE_NAME}-darwin-arm64`,
+	"darwin-x64": `${PACKAGE_SCOPE}/${PACKAGE_NAME}-darwin-x64`,
+	"linux-arm64": `${PACKAGE_SCOPE}/${PACKAGE_NAME}-linux-arm64`,
+	"linux-x64": `${PACKAGE_SCOPE}/${PACKAGE_NAME}-linux-x64`,
+	"win32-x64": `${PACKAGE_SCOPE}/${PACKAGE_NAME}-win32-x64`,
+};
+
+function getPlatformKey() {
+	const platform = process.platform;
+	const arch = process.arch;
+	return `${platform}-${arch}`;
+}
+
+function getBinaryName() {
+	return process.platform === "win32" ? `${BINARY_NAME}.exe` : BINARY_NAME;
+}
+
+function getBinaryPath() {
+	const platformKey = getPlatformKey();
+	const platformPackage = PLATFORM_PACKAGES[platformKey];
+	const binaryName = getBinaryName();
+
+	if (!platformPackage) {
+		console.error(`Unsupported platform: ${platformKey}`);
+		console.error(
+			`Supported platforms: ${Object.keys(PLATFORM_PACKAGES).join(", ")}`,
+		);
+		process.exit(1);
+	}
+
+	// Try to resolve from platform-specific package (installed via optionalDependencies)
+	try {
+		const packagePath = dirname(
+			require.resolve(`${platformPackage}/package.json`),
+		);
+		const binaryPath = join(packagePath, "bin", binaryName);
+		if (existsSync(binaryPath)) {
+			return binaryPath;
+		}
+	} catch {
+		// Platform package not installed, continue to fallback
+	}
+
+	// Fallback: check if binary was downloaded by postinstall script
+	const fallbackPath = join(__dirname, binaryName);
+	if (existsSync(fallbackPath)) {
+		return fallbackPath;
+	}
+
+	console.error(`Could not find ${BINARY_NAME} binary for ${platformKey}`);
+	console.error("Please try reinstalling the package:");
+	console.error(`  npm install -g ${PACKAGE_NAME}`);
+	process.exit(1);
+}
+
+try {
+	const binaryPath = getBinaryPath();
+	const args = process.argv.slice(2);
+
+	execFileSync(binaryPath, args, {
+		stdio: "inherit",
+		env: process.env,
+	});
+} catch (error) {
+	if (error.status !== undefined) {
+		process.exit(error.status);
+	}
+	console.error("Failed to execute ccmanager:", error.message);
+	process.exit(1);
+}

package/dist/cli.test.js

@@ -5,12 +5,11 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-// Check if node-pty native module is available
-function isNodePtyAvailable() {
+// Check if Bun.Terminal API is available (requires Bun v1.3.5+)
+function isBunTerminalAvailable() {
     try {
-        // Use eval to bypass linter's require() check
-        new Function('return require("node-pty")')();
-        return true;
+        // Check if Bun.Terminal is available
+        return typeof Bun !== 'undefined' && typeof Bun.spawn === 'function';
     }
     catch {
         return false;
@@ -25,7 +24,7 @@ describe('CLI', () => {
         process.env = originalEnv;
     });
     describe('--multi-project flag', () => {
-        it.skipIf(!isNodePtyAvailable())('should exit with error when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
+        it.skipIf(!isBunTerminalAvailable())('should exit with error when CCMANAGER_MULTI_PROJECT_ROOT is not set', async () => {
             // Ensure the env var is not set
             delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
             // Create a wrapper script that mocks TTY
@@ -33,11 +32,11 @@ describe('CLI', () => {
 				process.stdin.isTTY = true;
 				process.stdout.isTTY = true;
 				process.stderr.isTTY = true;
-				process.argv = ['node', 'cli.js', '--multi-project'];
+				process.argv = ['bun', 'cli.js', '--multi-project'];
 				import('./cli.js');
 			`;
             const result = await new Promise(resolve => {
-                const proc = spawn('node', ['--input-type=module', '-e', wrapperScript], {
+                const proc = spawn('bun', ['-e', wrapperScript], {
                     cwd: path.join(__dirname, '../dist'),
                     env: { ...process.env },
                     stdio: ['pipe', 'pipe', 'pipe'],
@@ -54,12 +53,12 @@ describe('CLI', () => {
             expect(result.stderr).toContain('CCMANAGER_MULTI_PROJECT_ROOT environment variable must be set');
             expect(result.stderr).toContain('export CCMANAGER_MULTI_PROJECT_ROOT=/path/to/projects');
         });
-        it.skipIf(!isNodePtyAvailable())('should not check for env var when --multi-project is not used', async () => {
+        it.skipIf(!isBunTerminalAvailable())('should not check for env var when --multi-project is not used', async () => {
             // Ensure the env var is not set
             delete process.env['CCMANAGER_MULTI_PROJECT_ROOT'];
             const result = await new Promise(resolve => {
                 const cliPath = path.join(__dirname, '../dist/cli.js');
-                const proc = spawn('node', [cliPath, '--help'], {
+                const proc = spawn('bun', [cliPath, '--help'], {
                     env: { ...process.env },
                     stdio: ['pipe', 'pipe', 'pipe'],
                 });

package/dist/components/App.test.js

@@ -95,10 +95,12 @@ vi.mock('../services/configurationManager.js', () => ({
     configurationManager: configurationManagerMock,
 }));
 vi.mock('../services/worktreeService.js', () => ({
-    WorktreeService: vi.fn().mockImplementation(() => ({
-        createWorktreeEffect: (...args) => createWorktreeEffectMock(...args),
-        deleteWorktreeEffect: (...args) => deleteWorktreeEffectMock(...args),
-    })),
+    WorktreeService: vi.fn(function () {
+        return {
+            createWorktreeEffect: (...args) => createWorktreeEffectMock(...args),
+            deleteWorktreeEffect: (...args) => deleteWorktreeEffectMock(...args),
+        };
+    }),
 }));
 vi.mock('./Menu.js', createInkMock('Menu View', props => (menuProps = props)));
 vi.mock('./ProjectList.js', createInkMock('Project List View', () => { }));

package/dist/components/DeleteWorktree.test.js

@@ -5,7 +5,13 @@ import { Effect } from 'effect';
 import DeleteWorktree from './DeleteWorktree.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
-vi.mock('../services/worktreeService.js');
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn(function () {
+        return {
+            getWorktreesEffect: vi.fn(),
+        };
+    }),
+}));
 vi.mock('../services/shortcutManager.js', () => ({
     shortcutManager: {
         matchesShortcut: vi.fn(),
@@ -52,9 +58,11 @@ describe('DeleteWorktree - Effect Integration', () => {
         ];
         const mockEffect = Effect.succeed(mockWorktrees);
         const mockGetWorktreesEffect = vi.fn(() => mockEffect);
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getWorktreesEffect: mockGetWorktreesEffect,
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: mockGetWorktreesEffect,
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered
@@ -77,9 +85,11 @@ describe('DeleteWorktree - Effect Integration', () => {
         });
         const mockEffect = Effect.fail(mockError);
         const mockGetWorktreesEffect = vi.fn(() => mockEffect);
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getWorktreesEffect: mockGetWorktreesEffect,
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: mockGetWorktreesEffect,
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered
@@ -111,9 +121,11 @@ describe('DeleteWorktree - Effect Integration', () => {
         ];
         const mockEffect = Effect.succeed(mockWorktrees);
         const mockGetWorktreesEffect = vi.fn(() => mockEffect);
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getWorktreesEffect: mockGetWorktreesEffect,
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: mockGetWorktreesEffect,
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered

package/dist/components/Menu.recent-projects.test.js

@@ -5,6 +5,28 @@ import { Effect } from 'effect';
 import Menu from './Menu.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { projectManager } from '../services/projectManager.js';
+// Mock bunTerminal to avoid native module issues in tests
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
+}));
+// Mock @xterm/headless
+vi.mock('@xterm/headless', () => ({
+    default: {
+        Terminal: vi.fn().mockImplementation(function () {
+            return {
+                buffer: {
+                    active: {
+                        length: 0,
+                        getLine: vi.fn(),
+                    },
+                },
+                write: vi.fn(),
+            };
+        }),
+    },
+}));
 // Import the actual component code but skip the useInput hook
 vi.mock('ink', async () => {
     const actual = await vi.importActual('ink');

package/dist/components/Menu.test.js

@@ -4,9 +4,11 @@ import Menu from './Menu.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-// Mock node-pty to avoid native module issues in tests
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Mock bunTerminal to avoid native module issues in tests
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 // Mock ink to avoid stdin issues
 vi.mock('ink', async () => {

package/dist/components/MergeWorktree.test.js

@@ -5,7 +5,13 @@ import { Effect } from 'effect';
 import MergeWorktree from './MergeWorktree.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { GitError } from '../types/errors.js';
-vi.mock('../services/worktreeService.js');
+vi.mock('../services/worktreeService.js', () => ({
+    WorktreeService: vi.fn(function () {
+        return {
+            getWorktreesEffect: vi.fn(),
+        };
+    }),
+}));
 vi.mock('../services/shortcutManager.js', () => ({
     shortcutManager: {
         matchesShortcut: vi.fn(),
@@ -52,9 +58,11 @@ describe('MergeWorktree - Effect Integration', () => {
         ];
         const mockEffect = Effect.succeed(mockWorktrees);
         const mockGetWorktreesEffect = vi.fn(() => mockEffect);
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getWorktreesEffect: mockGetWorktreesEffect,
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getWorktreesEffect: mockGetWorktreesEffect,
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         // WHEN: Component is rendered

package/dist/components/NewWorktree.test.js

@@ -2,9 +2,11 @@ import React from 'react';
 import { render } from 'ink-testing-library';
 import NewWorktree from './NewWorktree.js';
 import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-// Mock node-pty to avoid native module issues in tests
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Mock bunTerminal to avoid native module issues in tests
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 // Mock ink to avoid stdin issues
 vi.mock('ink', async () => {
@@ -60,7 +62,9 @@ vi.mock('../hooks/useSearchMode.js', () => ({
 }));
 // Mock WorktreeService
 vi.mock('../services/worktreeService.js', () => ({
-    WorktreeService: vi.fn(),
+    WorktreeService: vi.fn(function () {
+        return {};
+    }),
 }));
 describe('NewWorktree component Effect integration', () => {
     beforeEach(() => {
@@ -73,14 +77,16 @@ describe('NewWorktree component Effect integration', () => {
         const { Effect } = await import('effect');
         const { WorktreeService } = await import('../services/worktreeService.js');
         // Mock WorktreeService to return Effects that never resolve (simulating loading)
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => Effect.async(() => {
-                // Never resolves to simulate loading state
-            })),
-            getDefaultBranchEffect: vi.fn(() => Effect.async(() => {
-                // Never resolves to simulate loading state
-            })),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.async(() => {
+                    // Never resolves to simulate loading state
+                })),
+                getDefaultBranchEffect: vi.fn(() => Effect.async(() => {
+                    // Never resolves to simulate loading state
+                })),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         const { lastFrame } = render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -100,10 +106,12 @@ describe('NewWorktree component Effect integration', () => {
             stdout: '',
         });
         // Mock WorktreeService to fail with GitError
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => Effect.fail(gitError)),
-            getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.fail(gitError)),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         const { lastFrame } = render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -122,10 +130,12 @@ describe('NewWorktree component Effect integration', () => {
         // Mock WorktreeService to succeed with both Effects
         const getAllBranchesSpy = vi.fn(() => Effect.succeed(mockBranches));
         const getDefaultBranchSpy = vi.fn(() => Effect.succeed(mockDefaultBranch));
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: getAllBranchesSpy,
-            getDefaultBranchEffect: getDefaultBranchSpy,
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: getAllBranchesSpy,
+                getDefaultBranchEffect: getDefaultBranchSpy,
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -146,10 +156,12 @@ describe('NewWorktree component Effect integration', () => {
             stdout: '',
         });
         // Mock WorktreeService - branches succeed, default branch fails
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => Effect.succeed(['main', 'develop'])),
-            getDefaultBranchEffect: vi.fn(() => Effect.fail(gitError)),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed(['main', 'develop'])),
+                getDefaultBranchEffect: vi.fn(() => Effect.fail(gitError)),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         const { lastFrame } = render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -171,10 +183,12 @@ describe('NewWorktree component Effect integration', () => {
             copySessionData: true,
         });
         // Mock WorktreeService to return empty branch list
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => Effect.succeed([])),
-            getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed([])),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         const { lastFrame } = render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -199,10 +213,12 @@ describe('NewWorktree component Effect integration', () => {
         const mockBranches = ['main', 'feature-1', 'develop'];
         const mockDefaultBranch = 'main';
         // Mock WorktreeService to succeed
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => Effect.succeed(mockBranches)),
-            getDefaultBranchEffect: vi.fn(() => Effect.succeed(mockDefaultBranch)),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed(mockBranches)),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed(mockDefaultBranch)),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         const { lastFrame } = render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
@@ -226,13 +242,15 @@ describe('NewWorktree component Effect integration', () => {
         });
         // Track Effect execution
         let effectExecuted = false;
-        vi.mocked(WorktreeService).mockImplementation(() => ({
-            getAllBranchesEffect: vi.fn(() => {
-                effectExecuted = true;
-                return Effect.fail(gitError);
-            }),
-            getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
-        }));
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => {
+                    effectExecuted = true;
+                    return Effect.fail(gitError);
+                }),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed('main')),
+            };
+        });
         const onComplete = vi.fn();
         const onCancel = vi.fn();
         render(React.createElement(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));

package/dist/components/ProjectList.recent-projects.test.js

@@ -4,9 +4,11 @@ import { expect, describe, it, vi, beforeEach, afterEach } from 'vitest';
 import ProjectList from './ProjectList.js';
 import { projectManager } from '../services/projectManager.js';
 import { Effect } from 'effect';
-// Mock node-pty to avoid native module loading issues
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Mock bunTerminal to avoid native module loading issues
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 // Mock ink to avoid stdin.ref issues
 vi.mock('ink', async () => {

package/dist/components/ProjectList.test.js

@@ -1,9 +1,11 @@
 import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock node-pty to avoid native module loading issues
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+// Mock bunTerminal to avoid native module loading issues
+vi.mock('../services/bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 // Import the actual component code but skip the useInput hook
 vi.mock('ink', async () => {
@@ -224,6 +226,8 @@ describe('ProjectList', () => {
                     backspace: false,
                     delete: false,
                     meta: false,
+                    home: false,
+                    end: false,
                 });
             });
             // Wait a bit for state update
@@ -262,6 +266,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Force rerender with search active and query
             rerender(React.createElement(ProjectList, { projectsDir: "/projects", onSelectProject: mockOnSelectProject, error: null, onDismissError: mockOnDismissError }));
@@ -299,6 +305,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Wait a bit for state update
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -322,6 +330,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Wait a bit for state update
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -358,6 +368,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Wait a bit for state update
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -399,6 +411,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Wait a bit for state update
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -422,6 +436,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             // Wait a bit for state update
             await new Promise(resolve => setTimeout(resolve, 50));
@@ -464,6 +480,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             await new Promise(resolve => setTimeout(resolve, 50));
             // Exit search mode with Enter (keeping filter)
@@ -482,6 +500,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             await new Promise(resolve => setTimeout(resolve, 50));
             // Now press ESC outside search mode to clear filter
@@ -500,6 +520,8 @@ describe('ProjectList', () => {
                 backspace: false,
                 delete: false,
                 meta: false,
+                home: false,
+                end: false,
             });
             await new Promise(resolve => setTimeout(resolve, 50));
             // Force rerender

package/dist/services/bunTerminal.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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.
+ */
+/**
+ * Interface for disposable resources.
+ */
+export interface IDisposable {
+    dispose(): void;
+}
+/**
+ * Exit event data for PTY process.
+ */
+export interface IExitEvent {
+    exitCode: number;
+    signal?: number | string;
+}
+/**
+ * Options for spawning a new PTY process.
+ */
+export interface IPtyForkOptions {
+    name: string;
+    cols?: number;
+    rows?: number;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}
+/**
+ * Interface for interacting with a pseudo-terminal (PTY) instance.
+ */
+export interface IPty {
+    readonly pid: number;
+    readonly cols: number;
+    readonly rows: number;
+    readonly process: string;
+    readonly onData: (listener: (data: string) => void) => IDisposable;
+    readonly onExit: (listener: (event: IExitEvent) => void) => IDisposable;
+    write(data: string): void;
+    resize(columns: number, rows: number): void;
+    kill(signal?: string): void;
+}
+/**
+ * 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 declare function spawn(file: string, args: string[], options: IPtyForkOptions): IPty;

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,6 +1,6 @@
 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();
@@ -9,8 +9,10 @@ let verifyResolve = null;
 const verifyNeedsPermissionMock = vi.fn(() => Effect.promise(() => new Promise(resolve => {
     verifyResolve = resolve;
 })));
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+vi.mock('./bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 vi.mock('./stateDetector.js', () => ({
     createStateDetector: () => ({ detectState: detectStateMock }),
@@ -51,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', () => ({

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

package/dist/services/sessionManager.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
 import { exec } from 'child_process';

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

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { SessionManager } from './sessionManager.js';
-import { spawn } from 'node-pty';
+import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(),
+vi.mock('./bunTerminal.js', () => ({
+    spawn: vi.fn(function () {
+        return null;
+    }),
 }));
 vi.mock('./configurationManager.js', () => ({
     configurationManager: {

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 {

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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';

package/dist/utils/hookExecutor.test.js

@@ -16,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', () => {
@@ -273,16 +277,18 @@ describe('hookExecutor Integration Tests', () => {
                 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: {
@@ -325,16 +331,18 @@ describe('hookExecutor Integration Tests', () => {
                 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: {
@@ -375,16 +383,18 @@ describe('hookExecutor Integration Tests', () => {
                 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: {
@@ -427,13 +437,15 @@ describe('hookExecutor Integration Tests', () => {
                 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.1.5",
+	"version": "3.2.2",
 	"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.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"
 	},
 	"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"
+	}
 }