feat: merge bun support and CLI path detection improvements

Merges feature/bun-support-claude-cli-detection branch with:
- Bun runtime detection and CLI discovery
- HAPPY_CLAUDE_PATH env var override
- PATH fallback from tiann's PR slopus#83 (stdio suppression, existence check)
- Source detection (npm, Bun, Homebrew, native installer)

Detection priority:
  HAPPY_CLAUDE_PATH > PATH > npm > Bun > Homebrew > native

Also fixes test issues:
- apiSession.test.ts: vi.hoisted pattern for mock hoisting
- claudeLocal.test.ts: check spawn args instead of array mutation
- runtime.test.ts: ESM imports instead of require()

Credit: @tiann (slopus#83)

Author: ahundt

scripts/claude_version_utils.cjs

@@ -9,6 +9,7 @@
  *    - macOS/Linux: curl -fsSL https://claude.ai/install.sh | bash
  *    - PowerShell:  irm https://claude.ai/install.ps1 | iex
  *    - Windows CMD: curl -fsSL https://claude.ai/install.cmd | cmd
+ * 4. PATH fallback: bun, pnpm, or any other package manager
  */
 
 const { execSync } = require('child_process');
@@ -57,13 +58,22 @@ function findClaudeInPath() {
     try {
         // Cross-platform: 'where' on Windows, 'which' on Unix
         const command = process.platform === 'win32' ? 'where claude' : 'which claude';
-        const claudePath = execSync(command, { encoding: 'utf8' })
-            .trim()
-            .split('\n')[0]; // Take first match
+        // stdio suppression for cleaner execution (from tiann/PR#83)
+        const result = execSync(command, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
 
-        const resolvedPath = resolvePathSafe(claudePath);
+        const claudePath = result.split('\n')[0].trim(); // Take first match
+        if (!claudePath) return null;
 
-        if (resolvedPath && fs.existsSync(resolvedPath)) {
+        // Check existence BEFORE resolving (from tiann/PR#83)
+        if (!fs.existsSync(claudePath)) return null;
+
+        // Resolve with fallback to original path (from tiann/PR#83)
+        const resolvedPath = resolvePathSafe(claudePath) || claudePath;
+
+        if (resolvedPath) {
             // Detect source from BOTH original PATH entry and resolved path
             // Original path tells us HOW user accessed it (context)
             // Resolved path tells us WHERE it actually lives (content)
@@ -370,15 +380,22 @@ function findLatestVersionBinary(versionsDir, binaryName = null) {
 
 /**
  * Find path to globally installed Claude Code CLI
- * Priority: PATH (user preference) > npm > Bun > Homebrew > Native
+ * Priority: HAPPY_CLAUDE_PATH env var > PATH > npm > Bun > Homebrew > Native
  * @returns {{path: string, source: string}|null} Path and source, or null if not found
  */
 function findGlobalClaudeCliPath() {
-    // 1. Check PATH first (respects user's choice)
+    // 1. Environment variable (explicit override)
+    const envPath = process.env.HAPPY_CLAUDE_PATH;
+    if (envPath && fs.existsSync(envPath)) {
+        const resolved = resolvePathSafe(envPath) || envPath;
+        return { path: resolved, source: 'HAPPY_CLAUDE_PATH' };
+    }
+
+    // 2. Check PATH (respects user's shell config)
     const pathResult = findClaudeInPath();
     if (pathResult) return pathResult;
 
-    // 2. Fall back to package manager detection
+    // 3. Fall back to package manager detection
     const npmPath = findNpmGlobalCliPath();
     if (npmPath) return { path: npmPath, source: 'npm' };
 

scripts/claude_version_utils.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
 import {
   findGlobalClaudeCliPath,
   findClaudeInPath,
@@ -335,4 +336,37 @@ describe('Claude Version Utils - Cross-Platform Detection', () => {
       });
     });
   });
+});
+
+describe('HAPPY_CLAUDE_PATH env var', () => {
+  const testClaudePath = '/tmp/test-claude-path';
+
+  beforeEach(() => {
+    // Create mock executable
+    fs.writeFileSync(testClaudePath, '#!/bin/bash\necho "mock"');
+    fs.chmodSync(testClaudePath, 0o755);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testClaudePath)) fs.unlinkSync(testClaudePath);
+    delete process.env.HAPPY_CLAUDE_PATH;
+  });
+
+  it('should use HAPPY_CLAUDE_PATH when set', () => {
+    process.env.HAPPY_CLAUDE_PATH = testClaudePath;
+    const result = findGlobalClaudeCliPath();
+    expect(result?.source).toBe('HAPPY_CLAUDE_PATH');
+    expect(result?.path).toBe(testClaudePath);
+  });
+
+  it('should fall back to auto-discovery when env var not set', () => {
+    const result = findGlobalClaudeCliPath();
+    expect(result?.source).not.toBe('HAPPY_CLAUDE_PATH');
+  });
+
+  it('should ignore env var if path does not exist', () => {
+    process.env.HAPPY_CLAUDE_PATH = '/nonexistent/path/claude';
+    const result = findGlobalClaudeCliPath();
+    expect(result?.source).not.toBe('HAPPY_CLAUDE_PATH');
+  });
 });

src/api/apiSession.test.ts

@@ -1,8 +1,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { ApiSessionClient } from './apiSession';
 
-// Mock socket.io client before all tests
-const mockIo = vi.fn();
+// Mock socket.io client - use vi.hoisted to ensure mock is available at hoist time
+const { mockIo } = vi.hoisted(() => ({
+    mockIo: vi.fn()
+}));
+
 vi.mock('socket.io-client', () => ({
     io: mockIo
 }));

src/claude/claudeLocal.test.ts

@@ -169,8 +169,9 @@ describe('claudeLocal --continue handling', () => {
             claudeArgs
         });
 
-        // claudeArgs should be modified to remove --continue
-        expect(claudeArgs).not.toContain('--continue');
-        expect(claudeArgs).toContain('--other-flag');
+        // Verify spawn was called without --continue (it gets converted to --resume)
+        const spawnArgs = mockSpawn.mock.calls[0][1];
+        expect(spawnArgs).not.toContain('--continue');
+        expect(spawnArgs).toContain('--other-flag');
     });
 });

src/utils/__tests__/runtime.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getRuntime, isNode, isBun, isDeno } from '../runtime';
 
 describe('Runtime Detection', () => {
     beforeEach(() => {
@@ -8,7 +9,6 @@ describe('Runtime Detection', () => {
     it('detects Node.js runtime correctly', () => {
         // Test actual runtime detection
         if (process.versions.node && !process.versions.bun && !process.versions.deno) {
-            const { getRuntime, isNode, isBun, isDeno } = require('../runtime.js');
             expect(getRuntime()).toBe('node');
             expect(isNode()).toBe(true);
             expect(isBun()).toBe(false);
@@ -18,7 +18,6 @@ describe('Runtime Detection', () => {
 
     it('detects Bun runtime correctly', () => {
         if (process.versions.bun) {
-            const { getRuntime, isNode, isBun, isDeno } = require('../runtime.js');
             expect(getRuntime()).toBe('bun');
             expect(isNode()).toBe(false);
             expect(isBun()).toBe(true);
@@ -28,7 +27,6 @@ describe('Runtime Detection', () => {
 
     it('detects Deno runtime correctly', () => {
         if (process.versions.deno) {
-            const { getRuntime, isNode, isBun, isDeno } = require('../runtime.js');
             expect(getRuntime()).toBe('deno');
             expect(isNode()).toBe(false);
             expect(isBun()).toBe(false);
@@ -37,13 +35,11 @@ describe('Runtime Detection', () => {
     });
 
     it('returns valid runtime type', () => {
-        const { getRuntime } = require('../runtime.js');
         const runtime = getRuntime();
         expect(['node', 'bun', 'deno', 'unknown']).toContain(runtime);
     });
 
     it('provides consistent predicate functions', () => {
-        const { getRuntime, isNode, isBun, isDeno } = require('../runtime.js');
         const runtime = getRuntime();
 
         // Only one should be true
@@ -57,13 +53,11 @@ describe('Runtime Detection', () => {
     });
 
     it('handles edge cases gracefully', () => {
-        const { getRuntime } = require('../runtime.js');
-
         // Should not throw
         expect(() => getRuntime()).not.toThrow();
 
         // Should return string
         const runtime = getRuntime();
         expect(typeof runtime).toBe('string');
     });
-});
+});