Fix possible issues introduced by #107

bin/happy-dev.mjs

@@ -9,15 +9,15 @@ import { homedir } from 'os';
 const hasNoWarnings = process.execArgv.includes('--no-warnings');
 const hasNoDeprecation = process.execArgv.includes('--no-deprecation');
 
+// Set development environment variables
+process.env.HAPPY_HOME_DIR = join(homedir(), '.happy-dev');
+process.env.HAPPY_VARIANT = 'dev';
+
 if (!hasNoWarnings || !hasNoDeprecation) {
   // Re-execute with the flags
   const __filename = fileURLToPath(import.meta.url);
   const scriptPath = join(dirname(__filename), '../dist/index.mjs');
 
-  // Set development environment variables
-  process.env.HAPPY_HOME_DIR = join(homedir(), '.happy-dev');
-  process.env.HAPPY_VARIANT = 'dev';
-
   try {
     execFileSync(
       process.execPath,
@@ -33,9 +33,5 @@ if (!hasNoWarnings || !hasNoDeprecation) {
   }
 } else {
   // Already have the flags, import normally
-  // Set development environment variables
-  process.env.HAPPY_HOME_DIR = join(homedir(), '.happy-dev');
-  process.env.HAPPY_VARIANT = 'dev';
-
   await import('../dist/index.mjs');
 }

docs/bug-fix-plan-2025-01-15-athundt.md

@@ -149,7 +149,6 @@ describe('claudeLocal --continue handling', () => {
             addListener: vi.fn(),
             removeListener: vi.fn(),
             kill: vi.fn(),
-            on: vi.fn(),
             stdout: { on: vi.fn() },
             stderr: { on: vi.fn() },
             stdin: { on: vi.fn(), end: vi.fn() }

scripts/__tests__/ripgrep_launcher.test.ts

@@ -89,6 +89,18 @@ describe('Ripgrep Launcher Runtime Compatibility', () => {
             expect(content).toContain('brew install ripgrep');
             expect(content).toContain('winget install BurntSushi.ripgrep');
             expect(content).toContain('Search functionality unavailable');
+            expect(content).toContain('Missing arguments: expected JSON-encoded argv');
         }).not.toThrow();
     });
-});
+
+    it('does not treat signal termination as success', () => {
+        expect(() => {
+            const fs = require('fs');
+            const path = require('path');
+            const content = fs.readFileSync(path.join(__dirname, '../ripgrep_launcher.cjs'), 'utf8');
+
+            expect(content).not.toContain('result.status || 0');
+            expect(content).toContain('result.signal');
+        }).not.toThrow();
+    });
+}); 

scripts/claude_version_utils.cjs

@@ -131,7 +131,9 @@ function detectSourceFromPath(resolvedPath) {
     // Windows-specific detection (detect by path patterns, not current platform)
     if (normalizedPath.includes('appdata') || normalizedPath.includes('program files') || normalizedPath.endsWith('.exe')) {
         // Windows npm
-        if (normalizedPath.includes('appdata') && normalizedPath.includes('npm') && normalizedPath.includes('node_modules')) {
+        if (normalizedPath.includes('appdata') && normalizedPath.includes('npm') && normalizedPath.includes('node_modules') &&
+            normalizedPath.includes('@anthropic-ai') && normalizedPath.includes('claude-code') &&
+            !normalizedPath.includes('.claude-code-')) {
             return 'npm';
         }
 

scripts/claude_version_utils.test.ts

@@ -32,9 +32,9 @@ describe('Claude Version Utils - Cross-Platform Detection', () => {
         expect(result).toBe('npm');
       });
 
-      it('should detect npm with different scoped packages', () => {
+      it('should not classify unrelated scoped npm packages as npm', () => {
         const result = detectSourceFromPath('C:/Users/test/AppData/Roaming/npm/node_modules/@babel/core/cli.js');
-        expect(result).toBe('npm');
+        expect(result).toBe('PATH');
       });
 
       it('should detect npm through Homebrew', () => {

scripts/env-wrapper.cjs

@@ -51,6 +51,15 @@ if (!variant || !VARIANTS[variant]) {
   process.exit(1);
 }
 
+if (!command) {
+  console.error('Usage: node scripts/env-wrapper.js <stable|dev> <command> [...args]');
+  console.error('');
+  console.error('Examples:');
+  console.error('  node scripts/env-wrapper.js stable daemon start');
+  console.error('  node scripts/env-wrapper.js dev auth login');
+  process.exit(1);
+}
+
 const config = VARIANTS[variant];
 
 // Create home directory if it doesn't exist

scripts/ripgrep_launcher.cjs

@@ -40,7 +40,7 @@ function findSystemRipgrep() {
         try {
             const result = execFileSync(cmd, args, {
                 encoding: 'utf8',
-                stdio: 'ignore'
+                stdio: ['ignore', 'pipe', 'ignore']
             });
 
             if (result) {
@@ -93,7 +93,9 @@ function createRipgrepWrapper(binaryPath) {
                 stdio: 'inherit',
                 cwd: process.cwd()
             });
-            return result.status || 0;
+            if (typeof result.status === 'number') return result.status;
+            if (result.signal) return 1;
+            return 0;
         }
     };
 }
@@ -170,6 +172,11 @@ const args = process.argv.slice(2);
 // Parse the JSON-encoded arguments
 let parsedArgs;
 try {
+    if (!args[0]) {
+        console.error('Missing arguments: expected JSON-encoded argv as the first parameter.');
+        console.error('Example: node scripts/ripgrep_launcher.cjs \'["--version"]\'');
+        process.exit(1);
+    }
     parsedArgs = JSON.parse(args[0]);
 } catch (error) {
     console.error('Failed to parse arguments:', error.message);
@@ -183,4 +190,4 @@ try {
 } catch (error) {
     console.error('Ripgrep error:', error.message);
     process.exit(1);
-}
+}

scripts/test-continue-fix.sh

@@ -14,14 +14,19 @@ echo
 echo "2. Testing session finder with current directory..."
 node -e "
 const { resolve, join } = require('path');
-const { readdirSync, statSync, readFileSync } = require('fs');
+const { readdirSync, statSync, readFileSync, existsSync } = require('fs');
 const { homedir } = require('os');
 
 const workingDirectory = process.cwd();
 const projectId = resolve(workingDirectory).replace(/[\\\\\\/\.:]/g, '-');
 const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
 const projectDir = join(claudeConfigDir, 'projects', projectId);
 
+if (!existsSync(projectDir)) {
+    console.log('ERROR: Project directory does not exist:', projectDir);
+    process.exit(1);
+}
+
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\$/i;
 
 const files = readdirSync(projectDir)

src/api/api.test.ts

@@ -176,64 +176,74 @@ describe('Api server error handling', () => {
             connectionState.reset();
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-            // Mock axios to return 500 error
-            mockPost.mockRejectedValue({
-                response: { status: 500 },
-                isAxiosError: true
-            });
-
-            const result = await api.getOrCreateSession({
-                tag: 'test-tag',
-                metadata: testMetadata,
-                state: null
-            });
-
-            expect(result).toBeNull();
-            expect(consoleSpy).toHaveBeenCalledWith(
-                expect.stringContaining('⚠️  Happy server unreachable')
-            );
-            consoleSpy.mockRestore();
+            try {
+                // Mock axios to return 500 error
+                mockPost.mockRejectedValue({
+                    response: { status: 500 },
+                    isAxiosError: true
+                });
+
+                const result = await api.getOrCreateSession({
+                    tag: 'test-tag',
+                    metadata: testMetadata,
+                    state: null
+                });
+
+                expect(result).toBeNull();
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('⚠️  Happy server unreachable')
+                );
+            } finally {
+                consoleSpy.mockRestore();
+            }
         });
 
         it('should return null when server returns 503 Service Unavailable', async () => {
             connectionState.reset();
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-            // Mock axios to return 503 error
-            mockPost.mockRejectedValue({
-                response: { status: 503 },
-                isAxiosError: true
-            });
-
-            const result = await api.getOrCreateSession({
-                tag: 'test-tag',
-                metadata: testMetadata,
-                state: null
-            });
-
-            expect(result).toBeNull();
-            expect(consoleSpy).toHaveBeenCalledWith(
-                expect.stringContaining('⚠️  Happy server unreachable')
-            );
-            consoleSpy.mockRestore();
+            try {
+                // Mock axios to return 503 error
+                mockPost.mockRejectedValue({
+                    response: { status: 503 },
+                    isAxiosError: true
+                });
+
+                const result = await api.getOrCreateSession({
+                    tag: 'test-tag',
+                    metadata: testMetadata,
+                    state: null
+                });
+
+                expect(result).toBeNull();
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('⚠️  Happy server unreachable')
+                );
+            } finally {
+                consoleSpy.mockRestore();
+            }
         });
 
         it('should re-throw non-connection errors', async () => {
-            // Mock axios to throw a different type of error (e.g., authentication error)
-            const authError = new Error('Invalid API key');
-            (authError as any).code = 'UNAUTHORIZED';
-            mockPost.mockRejectedValue(authError);
-
-            await expect(
-                api.getOrCreateSession({ tag: 'test-tag', metadata: testMetadata, state: null })
-            ).rejects.toThrow('Failed to get or create session: Invalid API key');
-
-            // Should not show the offline mode message
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-            expect(consoleSpy).not.toHaveBeenCalledWith(
-                expect.stringContaining('⚠️  Happy server unreachable')
-            );
-            consoleSpy.mockRestore();
+
+            try {
+                // Mock axios to throw a different type of error (e.g., authentication error)
+                const authError = new Error('Invalid API key');
+                (authError as any).code = 'UNAUTHORIZED';
+                mockPost.mockRejectedValue(authError);
+
+                await expect(
+                    api.getOrCreateSession({ tag: 'test-tag', metadata: testMetadata, state: null })
+                ).rejects.toThrow('Failed to get or create session: Invalid API key');
+
+                // Should not show the offline mode message
+                expect(consoleSpy).not.toHaveBeenCalledWith(
+                    expect.stringContaining('⚠️  Happy server unreachable')
+                );
+            } finally {
+                consoleSpy.mockRestore();
+            }
         });
     });
 
@@ -310,4 +320,4 @@ describe('Api server error handling', () => {
             consoleSpy.mockRestore();
         });
     });
-});
+});

src/api/apiMachine.ts

@@ -102,14 +102,30 @@ export class ApiMachineClient {
     }: MachineRpcHandlers) {
         // Register spawn session handler
         this.rpcHandlerManager.registerHandler('spawn-happy-session', async (params: any) => {
-            const { directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables } = params || {};
-            logger.debug(`[API MACHINE] Spawning session with params: ${JSON.stringify(params)}`);
+            const { directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables, profileId } = params || {};
+            const envKeys = environmentVariables && typeof environmentVariables === 'object'
+                ? Object.keys(environmentVariables as Record<string, unknown>)
+                : [];
+            const maxEnvKeysToLog = 20;
+            const envKeySample = envKeys.slice(0, maxEnvKeysToLog);
+            logger.debug('[API MACHINE] Spawning session', {
+                directory,
+                sessionId,
+                machineId,
+                agent,
+                approvedNewDirectoryCreation,
+                profileId,
+                hasToken: !!token,
+                environmentVariableCount: envKeys.length,
+                environmentVariableKeySample: envKeySample,
+                environmentVariableKeysTruncated: envKeys.length > maxEnvKeysToLog,
+            });
 
             if (!directory) {
                 throw new Error('Directory is required');
             }
 
-            const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables });
+            const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation, agent, token, environmentVariables, profileId });
 
             switch (result.type) {
                 case 'success':
@@ -327,4 +343,4 @@ export class ApiMachineClient {
             logger.debug('[API MACHINE] Socket closed');
         }
     }
-}
+}

src/api/apiSession.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { ApiSessionClient } from './apiSession';
+import type { RawJSONLines } from '@/claude/types';
 
 // Use vi.hoisted to ensure mock function is available when vi.mock factory runs
 const { mockIo } = vi.hoisted(() => ({
@@ -20,10 +21,12 @@ describe('ApiSessionClient connection handling', () => {
 
         // Mock socket.io client
         mockSocket = {
+            connected: false,
             connect: vi.fn(),
             on: vi.fn(),
             off: vi.fn(),
-            disconnect: vi.fn()
+            disconnect: vi.fn(),
+            emit: vi.fn(),
         };
 
         mockIo.mockReturnValue(mockSocket);
@@ -65,8 +68,32 @@ describe('ApiSessionClient connection handling', () => {
         expect(mockSocket.on).toHaveBeenCalledWith('error', expect.any(Function));
     });
 
+    it('emits messages even when disconnected (socket.io will buffer)', () => {
+        mockSocket.connected = false;
+
+        const client = new ApiSessionClient('fake-token', mockSession);
+
+        const payload: RawJSONLines = {
+            type: 'user',
+            uuid: 'test-uuid',
+            message: {
+                content: 'hello',
+            },
+        } as const;
+
+        client.sendClaudeSessionMessage(payload);
+
+        expect(mockSocket.emit).toHaveBeenCalledWith(
+            'message',
+            expect.objectContaining({
+                sid: mockSession.id,
+                message: expect.any(String),
+            })
+        );
+    });
+
     afterEach(() => {
         consoleSpy.mockRestore();
         vi.restoreAllMocks();
     });
-});
+});