Error: --session-id cannot be used with --continue or --resume

// In claudeLocal.ts (around line 35, after startFrom initial check)

// Convert --continue to --resume with last session
if (!startFrom && opts.claudeArgs?.includes('--continue')) {
    const lastSession = claudeFindLastSession(opts.path);
    if (lastSession) {
        startFrom = lastSession;
        logger.debug(`[ClaudeLocal] Converting --continue to --resume ${lastSession}`);
    } else {
        logger.debug('[ClaudeLocal] No sessions found for --continue, creating new session');
    }
    // Remove --continue from claudeArgs since we're handling it
    opts.claudeArgs = opts.claudeArgs?.filter(arg => arg !== '--continue');
}

// Then existing logic:
if (startFrom) {
    args.push('--resume', startFrom);  // Will continue the found session
} else {
    args.push('--session-id', newSessionId!);  // New session
}

try {
    this.socket.connect();
} catch (error) {
    console.log('⚠️  Cannot connect to Happy server - continuing in local mode');
    logger.debug('[API] Socket connection failed:', error);
    // Don't throw - continue without socket
}

} catch (error) {
    if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
        console.log('⚠️  Happy server unreachable - working in offline mode');
        return null; // Let caller handle fallback
    }
    throw error; // Re-throw other errors
}

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { claudeLocal } from './claudeLocal';

describe('claudeLocal --continue handling', () => {
    let mockSpawn: any;
    let onSessionFound: any;

    beforeEach(() => {
        mockSpawn = vi.fn();
        vi.mock('child_process', () => ({
            spawn: mockSpawn
        }));
        onSessionFound = vi.fn();
        mockSpawn.mockReturnValue({
            stdio: [null, null, null, null],
            on: vi.fn(),
            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() }
        });
    });

    it('should pass --continue to Claude without --session-id when user requests continue', async () => {
        await claudeLocal({
            abort: new AbortController().signal,
            sessionId: null,
            path: '/tmp',
            onSessionFound,
            claudeArgs: ['--continue'] // User wants to continue last session
        });

        // Verify spawn was called with --continue but WITHOUT --session-id
        expect(mockSpawn).toHaveBeenCalled();
        const spawnArgs = mockSpawn.mock.calls[0][2];

        // Should contain --continue
        expect(spawnArgs).toContain('--continue');

        // Should NOT contain --session-id (this was causing the conflict)
        expect(spawnArgs).not.toContain('--session-id');

        // Should notify about continue
        expect(onSessionFound).toHaveBeenCalledWith('continue-pending');
    });

    it('should add --session-id for normal new sessions', async () => {
        await claudeLocal({
            abort: new AbortController().signal,
            sessionId: null,
            path: '/tmp',
            onSessionFound,
            claudeArgs: [] // No session flags - new session
        });

        // Verify spawn was called with --session-id for new sessions
        expect(mockSpawn).toHaveBeenCalled();
        const spawnArgs = mockSpawn.mock.calls[0][2];
        expect(spawnArgs).toContain('--session-id');
        expect(spawnArgs).not.toContain('--continue');
    });

    it('should handle --resume with session ID without conflict', async () => {
        await claudeLocal({
            abort: new AbortController().signal,
            sessionId: 'existing-session-123',
            path: '/tmp',
            onSessionFound,
            claudeArgs: [] // No --continue
        });

        // Should use --resume with session ID
        const spawnArgs = mockSpawn.mock.calls[0][2];
        expect(spawnArgs).toContain('--resume');
        expect(spawnArgs).toContain('existing-session-123');
        expect(spawnArgs).not.toContain('--session-id');
    });
});

import { describe, it, expect } from 'vitest';
import { ApiSessionClient } from './apiSession';

describe('ApiSessionClient connection handling', () => {
    it('should handle socket connection failure gracefully', async () => {
        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});

        // Mock socket.connect() to throw
        const mockSocket = {
            connect: vi.fn(() => { throw new Error('ECONNREFUSED'); }),
            on: vi.fn()
        };

        // Should not throw
        expect(() => {
            new ApiSessionClient('fake-token', { id: 'test' } as any);
        }).not.toThrow();

        // Should show user-friendly message
        expect(consoleSpy).toHaveBeenCalledWith(
            '⚠️  Cannot connect to Happy server - continuing in local mode'
        );

        consoleSpy.mockRestore();
    });
});

import { describe, it, expect, vi } from 'vitest';
import { Api } from './api';

describe('Api server error handling', () => {
    it('should return null when Happy server is unreachable', async () => {
        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});

        // Mock axios to throw connection error
        vi.mock('axios', () => ({
            default: {
                post: vi.fn(() => Promise.reject({ code: 'ECONNREFUSED' }))
            }
        }));

        const api = new Api('fake-key');
        const result = await api.getOrCreateSession({ machineId: 'test' });

        expect(result).toBeNull();
        expect(consoleSpy).toHaveBeenCalledWith(
            '⚠️  Happy server unreachable - working in offline mode'
        );

        consoleSpy.mockRestore();
    });
});