happy-coder 0.1.7 → 0.1.10

package/dist/commands/start.test.js

@@ -1,307 +0,0 @@
-/**
- * End-to-end integration test for handy-cli bin/dev.js
- *
- * This test demonstrates how to properly spawn and control the CLI process
- * for integration testing using promise-based approach for deterministic results.
- */
-import { authGetToken, getOrCreateSecretKey } from '#auth/auth';
-import { SessionService } from '#session/service';
-import { SocketClient } from '#socket/client';
-import { getConfig } from '#utils/config';
-import { expect } from 'chai';
-import { execSync, spawn } from 'node:child_process';
-import { join } from 'node:path';
-describe('CLI bin/dev.js Integration <-> server <-> mocked client', function () {
-    this.timeout(30_000); // 30 second timeout for integration tests
-    let cliProcess = null;
-    const projectRoot = process.cwd();
-    const binPath = join(projectRoot, 'bin', 'dev.js');
-    // Clean up Claude sessions before each test
-    beforeEach(() => {
-        // Remove any existing Claude sessions for the playground project
-        const claudeProjectPath = process.env.HOME + '/.claude/projects/-Users-kirilldubovitskiy-projects-handy-cli-claude-cli-playground-project';
-        try {
-            execSync(`rm -rf "${claudeProjectPath}"`, { stdio: 'ignore' });
-        }
-        catch {
-            // Ignore errors if directory doesn't exist
-        }
-    });
-    afterEach(() => {
-        // Clean up any running processes
-        if (cliProcess && !cliProcess.killed) {
-            cliProcess.kill('SIGINT');
-            cliProcess = null;
-        }
-    });
-    it('Sanity check: should show version with --version flag', (done) => {
-        const outputs = [];
-        let processExited = false;
-        cliProcess = spawn('node', [binPath, '--version'], {
-            cwd: projectRoot,
-            env: { ...process.env },
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        cliProcess.stdout?.on('data', (data) => {
-            outputs.push(data.toString());
-        });
-        cliProcess.on('exit', (code, _signal) => {
-            processExited = true;
-            // Should exit successfully
-            expect(code).to.equal(0);
-            // Should show version
-            const output = outputs.join('');
-            expect(output).to.match(/\d+\.\d+\.\d+/); // Matches semantic version
-            done();
-        });
-        cliProcess.on('error', (error) => {
-            done(error);
-        });
-        // Set a timeout in case process doesn't exit
-        setTimeout(() => {
-            if (!processExited) {
-                cliProcess?.kill('SIGTERM');
-                done(new Error('CLI process did not exit within timeout'));
-            }
-        }, 5000);
-    });
-    /**
-     * Run our bin/dev.js start command and respond to a single client messages
-     * that lists files in the directory of the playground project
-     * with a single file hello-world.js
-     *
-     * This test is a bit more complex, because we need to:
-     * 1. Spawn the CLI process in a playground directory with a single hello-world.js
-     * 2. Wait for the CLI process to start
-     * 3. We by default send a message to claude code to show current directory
-     *      to make sure we are in the expected project + sanity check our system.
-     * 4. Extract the session ID from the CLI process output
-     * 5. Create a test client and connect to the server
-     * 6. Assert client recieves current directory within 5 seconds
-     * 7. The client sends a message asking to list files in the toy directory
-     * 8. Wait for the response to contain the hello-world.js file for 10 seconds
-     * 9. Disconnect the test client
-     * 8. Clean up the CLI process
-     */
-    it('should run start command and respond to client messages', async () => {
-        console.log('=== Starting End-to-End Test ===');
-        const playgroundPath = join(projectRoot, 'claude-cli-playground-project');
-        // Create a promise-based test runner
-        const testResult = await new Promise((resolve, reject) => {
-            let sessionId = null;
-            let testCompleted = false;
-            const cleanup = () => {
-                if (cliProcess && !cliProcess.killed) {
-                    cliProcess.kill('SIGINT');
-                    cliProcess = null;
-                }
-            };
-            const completeTest = (error) => {
-                if (testCompleted)
-                    return;
-                testCompleted = true;
-                cleanup();
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            };
-            // Overall test timeout
-            const testTimeout = setTimeout(() => {
-                completeTest(new Error('Test timeout: Did not complete within 30 seconds'));
-            }, 30_000);
-            console.log('Step 1: Spawning CLI process...');
-            cliProcess = spawn('node', [binPath, 'start'], {
-                cwd: playgroundPath,
-                env: { ...process.env },
-                stdio: ['pipe', 'pipe', 'pipe']
-            });
-            cliProcess.stdout?.on('data', (data) => {
-                const output = data.toString();
-                console.log('CLI stdout:', output);
-                // Parse session ID from output
-                const sessionMatch = output.match(/Session created: ([a-zA-Z0-9-]+)/);
-                if (sessionMatch) {
-                    sessionId = sessionMatch[1];
-                    console.log('Step 2: Extracted session ID:', sessionId);
-                }
-                // Look for ready signal
-                if (output.includes('Handy CLI is running') && sessionId) {
-                    console.log('Step 3: CLI is ready with session ID!');
-                    clearTimeout(testTimeout);
-                    createTestClient(sessionId)
-                        .then(() => completeTest())
-                        .catch(completeTest);
-                }
-            });
-            cliProcess.stderr?.on('data', (data) => {
-                const error = data.toString();
-                // Only log real errors, not warnings
-                if (!error.includes('ExperimentalWarning') && !error.includes('DeprecationWarning')) {
-                    console.log('CLI stderr:', error);
-                }
-            });
-            cliProcess.on('exit', (code, signal) => {
-                console.log(`CLI process exited with code ${code} and signal ${signal}`);
-                if (!testCompleted) {
-                    completeTest(new Error(`CLI exited unexpectedly with code ${code}`));
-                }
-            });
-            cliProcess.on('error', (error) => {
-                console.log('CLI process error:', error);
-                completeTest(error);
-            });
-        });
-        async function createTestClient(sessionId) {
-            return new Promise((resolve, reject) => {
-                const runTestClient = async () => {
-                    try {
-                        console.log('Step 4: Creating test client...');
-                        // Get auth token
-                        const config = getConfig();
-                        // This key would normally be read from the QR code from the terminal
-                        const secret = await getOrCreateSecretKey();
-                        const authToken = await authGetToken(config.serverUrl, secret);
-                        console.log('Auth token obtained');
-                        // Use the parsed session ID
-                        const session = { id: sessionId };
-                        const sessionService = new SessionService(config.serverUrl, authToken);
-                        console.log('Using session:', session.id);
-                        console.log('Step 5: Connecting test client...');
-                        const socketClient = new SocketClient({
-                            authToken,
-                            serverUrl: config.serverUrl,
-                            socketPath: config.socketPath,
-                        });
-                        let cwdResponseReceived = false;
-                        let fileListResponseReceived = false;
-                        let messageSent = false;
-                        // Listen for updates
-                        // eslint-disable-next-line complexity
-                        socketClient.on('update', (update) => {
-                            console.log('Received update type:', update.content?.t, 'for session:', update.content?.sid);
-                            // Check if this is for our session
-                            if (update.content.t === 'new-message' && update.content.sid === session.id) {
-                                try {
-                                    // Handle nested decryption structure
-                                    let decryptedContent;
-                                    if (typeof update.content.c === 'object' && update.content.c.c && update.content.c.t === 'encrypted') {
-                                        // Nested encrypted structure
-                                        decryptedContent = sessionService.decryptContent(update.content.c.c);
-                                    }
-                                    else if (typeof update.content.c === 'string') {
-                                        decryptedContent = sessionService.decryptContent(update.content.c);
-                                    }
-                                    else {
-                                        // Already decrypted object
-                                        decryptedContent = update.content.c;
-                                    }
-                                    console.log('Decrypted content type:', decryptedContent?.type, 'data type:', decryptedContent?.data?.type);
-                                    // Check if it's a Claude response
-                                    if (typeof decryptedContent === 'object' &&
-                                        decryptedContent !== null &&
-                                        'type' in decryptedContent &&
-                                        decryptedContent.type === 'claude-response') {
-                                        const responseData = JSON.stringify(decryptedContent).toLowerCase();
-                                        console.log('Checking response - cwdResponseReceived:', cwdResponseReceived, 'includes playground:', responseData.includes('claude-cli-playground-project'));
-                                        // Step 6: Check for current working directory (initial command)
-                                        if (!cwdResponseReceived && responseData.includes('claude-cli-playground-project')) {
-                                            console.log('Step 6: Received current working directory response within 5 seconds!');
-                                            cwdResponseReceived = true;
-                                            // Now send the client message to list files
-                                            if (!messageSent) {
-                                                messageSent = true;
-                                                console.log('Step 7: Sending client message to list files...');
-                                                sessionService.sendMessage(session.id, {
-                                                    content: 'ls',
-                                                    type: 'text-input'
-                                                }).then(() => {
-                                                    console.log('Client message sent successfully');
-                                                }).catch((error) => {
-                                                    console.error('Failed to send client message:', error);
-                                                    reject(error);
-                                                });
-                                            }
-                                        }
-                                        // Step 8: Check for hello-world.js in file listing
-                                        if (cwdResponseReceived && messageSent) {
-                                            // Log tool results to debug
-                                            if (decryptedContent.data?.type === 'user' && decryptedContent.data?.message?.content) {
-                                                // Check tool results in user messages
-                                                const toolResults = decryptedContent.data.message.content.filter((c) => c.type === 'tool_result');
-                                                // eslint-disable-next-line max-depth
-                                                if (toolResults.length > 0) {
-                                                    console.log('Tool results found:', JSON.stringify(toolResults));
-                                                    // Check if any tool result contains hello-world.js
-                                                    const hasHelloWorld = toolResults.some((result) => result.content && result.content.toLowerCase().includes('hello-world.js'));
-                                                    // eslint-disable-next-line max-depth
-                                                    if (hasHelloWorld) {
-                                                        console.log('Step 8: Found hello-world.js in tool results!');
-                                                        fileListResponseReceived = true;
-                                                        socketClient.disconnect();
-                                                        console.log('=== Test Completed Successfully ===');
-                                                        // Give the CLI time to shut down gracefully
-                                                        setTimeout(() => {
-                                                            if (cliProcess && !cliProcess.killed) {
-                                                                cliProcess.kill('SIGINT'); // Use SIGINT for graceful shutdown
-                                                            }
-                                                        }, 100);
-                                                        resolve();
-                                                    }
-                                                }
-                                            }
-                                            // Also check in the full response
-                                            if (responseData.includes('hello-world.js')) {
-                                                console.log('Step 8: Found hello-world.js in response!');
-                                                fileListResponseReceived = true;
-                                                socketClient.disconnect();
-                                                console.log('=== Test Completed Successfully ===');
-                                                // Give the CLI time to shut down gracefully
-                                                setTimeout(() => {
-                                                    if (cliProcess && !cliProcess.killed) {
-                                                        cliProcess.kill('SIGINT'); // Use SIGINT for graceful shutdown
-                                                    }
-                                                }, 100);
-                                                resolve();
-                                            }
-                                        }
-                                    }
-                                }
-                                catch (decryptError) {
-                                    console.log('Failed to decrypt message:', decryptError);
-                                    reject(decryptError);
-                                }
-                            }
-                        });
-                        socketClient.connect();
-                        await socketClient.waitForAuth();
-                        console.log('Test client connected and authenticated');
-                        // Don't send any message here - we'll wait for CWD response first
-                        console.log('Waiting for initial current working directory response...');
-                        // Set timeouts for two-stage check
-                        setTimeout(() => {
-                            if (!cwdResponseReceived) {
-                                socketClient.disconnect();
-                                reject(new Error('Did not receive current working directory response within 5 seconds'));
-                            }
-                        }, 5000); // 5 second timeout for CWD response
-                        setTimeout(() => {
-                            if (cwdResponseReceived && !fileListResponseReceived) {
-                                socketClient.disconnect();
-                                reject(new Error('Did not receive hello-world.js in file listing response within 10 seconds'));
-                            }
-                        }, 15_000); // 15 second timeout for complete test
-                    }
-                    catch (error) {
-                        console.log('Error in createTestClient:', error);
-                        reject(error);
-                    }
-                };
-                runTestClient();
-            });
-        }
-        return testResult;
-    });
-});

package/dist/handlers/message-handler.d.ts

@@ -1,65 +0,0 @@
-/**
- * Message handler for handy-cli
- *
- * This module handles incoming messages from the socket server
- * and coordinates between the socket client and Claude CLI.
- *
- * Key responsibilities:
- * - Process incoming text-input messages
- * - Forward messages to Claude CLI
- * - Send Claude responses back through socket
- * - Handle message encryption/decryption (future)
- *
- * Design decisions:
- * - Uses event-driven architecture for loose coupling
- * - Handles only text-input messages initially
- * - Prepared for future encryption support
- */
-import { ClaudeOptions } from '#claude/claude';
-import { SessionService } from '#session/service';
-import { SocketClient } from '#socket/client';
-import { EventEmitter } from 'node:events';
-export interface MessageHandlerOptions {
-    claudeOptions?: Partial<ClaudeOptions>;
-    sessionId: string;
-    sessionService: SessionService;
-    socketClient: SocketClient;
-    workingDirectory: string;
-}
-export declare class MessageHandler extends EventEmitter {
-    private claude;
-    private claudeOptions;
-    private sessionId;
-    private sessionService;
-    private socketClient;
-    private workingDirectory;
-    constructor(options: MessageHandlerOptions);
-    /**
-     * Handle initial command directly (for startup)
-     */
-    handleInitialCommand(command: string): void;
-    /**
-     * Start handling messages
-     */
-    start(): void;
-    /**
-     * Stop handling messages
-     */
-    stop(): void;
-    /**
-     * Handle Claude responses
-     */
-    private handleClaudeResponse;
-    /**
-     * Handle text input messages
-     */
-    private handleTextInput;
-    /**
-     * Handle update messages from the server
-     */
-    private handleUpdate;
-    /**
-     * Set up event handlers
-     */
-    private setupHandlers;
-}

package/dist/handlers/message-handler.js

@@ -1,187 +0,0 @@
-/**
- * Message handler for handy-cli
- *
- * This module handles incoming messages from the socket server
- * and coordinates between the socket client and Claude CLI.
- *
- * Key responsibilities:
- * - Process incoming text-input messages
- * - Forward messages to Claude CLI
- * - Send Claude responses back through socket
- * - Handle message encryption/decryption (future)
- *
- * Design decisions:
- * - Uses event-driven architecture for loose coupling
- * - Handles only text-input messages initially
- * - Prepared for future encryption support
- */
-import { Claude } from '#claude/claude';
-import { logger } from '#utils/logger';
-import { EventEmitter } from 'node:events';
-// eslint-disable-next-line unicorn/prefer-event-target
-export class MessageHandler extends EventEmitter {
-    claude;
-    claudeOptions;
-    sessionId;
-    sessionService;
-    socketClient;
-    workingDirectory;
-    constructor(options) {
-        super();
-        this.socketClient = options.socketClient;
-        this.claude = new Claude();
-        this.sessionService = options.sessionService;
-        this.sessionId = options.sessionId;
-        this.workingDirectory = options.workingDirectory;
-        this.claudeOptions = options.claudeOptions || {};
-        this.setupHandlers();
-    }
-    /**
-     * Handle initial command directly (for startup)
-     */
-    handleInitialCommand(command) {
-        logger.info('Handling initial command:', command);
-        // Run Claude command
-        this.claude.runClaudeCodeTurn(command, undefined, // No session ID for initial command
-        {
-            workingDirectory: this.workingDirectory,
-            ...this.claudeOptions
-        });
-    }
-    /**
-     * Start handling messages
-     */
-    start() {
-        logger.info('Message handler started');
-        // Any initialization logic can go here
-    }
-    /**
-     * Stop handling messages
-     */
-    stop() {
-        logger.info('Message handler stopped');
-        this.claude.kill();
-    }
-    /**
-     * Handle Claude responses
-     */
-    async handleClaudeResponse(response) {
-        logger.info('Claude response:', JSON.stringify(response, null, 2));
-        try {
-            // Send the response to the server session
-            await this.sessionService.sendMessage(this.sessionId, {
-                data: response,
-                type: 'claude-response'
-            });
-            // Emit for local handling
-            this.emit('claudeResponse', response);
-        }
-        catch (error) {
-            logger.error('Failed to send Claude response to server:', error);
-            this.emit('error', error);
-        }
-    }
-    /**
-     * Handle text input messages
-     */
-    handleTextInput(message) {
-        logger.info('Received text input:', message.content);
-        // Run Claude command (kills any existing process automatically)
-        this.claude.runClaudeCodeTurn(message.content, undefined, // No session resuming for now
-        {
-            workingDirectory: this.workingDirectory,
-            ...this.claudeOptions
-        });
-    }
-    /**
-     * Handle update messages from the server
-     */
-    handleUpdate(update) {
-        logger.debug('Received update:', JSON.stringify(update, null, 2));
-        // Check if this is a new message for our session
-        if (update.content.t === 'new-message') {
-            const { c, sid } = update.content;
-            // Verify this message is for our session
-            if (sid !== this.sessionId) {
-                logger.debug('Message for different session, ignoring');
-                return;
-            }
-            try {
-                // Log the raw content structure for debugging
-                logger.debug('Raw content (c):', JSON.stringify(c));
-                logger.debug('Content type:', typeof c);
-                // Check if content is already a string or needs extraction
-                let encryptedContent;
-                if (typeof c === 'string') {
-                    // Direct string content
-                    encryptedContent = c;
-                }
-                else if (typeof c === 'object' && c !== null && 'c' in c && typeof c.c === 'string') {
-                    // Nested structure: { c: 'base64string', t: 'encrypted' }
-                    logger.debug('Extracting from nested structure');
-                    encryptedContent = c.c;
-                }
-                else {
-                    logger.error('Invalid content structure:', c);
-                    return;
-                }
-                // Decrypt the content
-                const decryptedContent = this.sessionService.decryptContent(encryptedContent);
-                logger.debug('Decrypted content:', decryptedContent);
-                // Type guard for the decrypted content
-                if (typeof decryptedContent === 'object' &&
-                    decryptedContent !== null &&
-                    'type' in decryptedContent) {
-                    const message = decryptedContent;
-                    // Handle the message based on type
-                    if (message.type === 'text-input') {
-                        this.handleTextInput(decryptedContent);
-                    }
-                    else if (message.type === 'claude-response') {
-                        // This is our own claude-response being echoed back from the server
-                        // We can safely ignore it or log it for debugging
-                        logger.debug('Received claude-response echo from server:', message);
-                    }
-                    else {
-                        logger.warn('Unknown message type:', message.type);
-                    }
-                }
-                else {
-                    logger.error('Invalid message format');
-                }
-            }
-            catch (error) {
-                logger.error('Failed to process message:', error);
-            }
-        }
-    }
-    /**
-     * Set up event handlers
-     */
-    setupHandlers() {
-        // Handle updates from socket server
-        this.socketClient.on('update', (update) => {
-            this.handleUpdate(update);
-        });
-        // Handle Claude responses
-        this.claude.on('response', (response) => {
-            this.handleClaudeResponse(response);
-        });
-        // Handle Claude output (non-JSON)
-        this.claude.on('output', (output) => {
-            logger.debug('Claude output:', output);
-            // For now, we'll log non-JSON output
-            // In the future, we might want to send this to the client
-        });
-        // Handle Claude errors
-        this.claude.on('error', (error) => {
-            logger.error('Claude error:', error);
-            this.emit('error', error);
-        });
-        // Handle Claude exit
-        this.claude.on('exit', (exitInfo) => {
-            logger.info('Claude exited:', exitInfo);
-            this.emit('claudeExit', exitInfo);
-        });
-    }
-}

package/dist/index.d.ts

@@ -1 +0,0 @@
-export { run } from '@oclif/core';

package/dist/index.js

@@ -1 +0,0 @@
-export { run } from '@oclif/core';

package/dist/session/service.d.ts

@@ -1,27 +0,0 @@
-/**
- * Session service for managing handy-server sessions
- */
-import type { CreateSessionResponse, GetMessagesResponse, SendMessageResponse } from '#session/types';
-export declare class SessionService {
-    private readonly serverUrl;
-    private readonly authToken;
-    constructor(serverUrl: string, authToken: string);
-    /**
-     * Create a new session or load existing one with the given tag
-     */
-    createSession(tag: string): Promise<CreateSessionResponse>;
-    /**
-     * Decrypt a message content
-     * Note: In real implementation, this would use proper decryption
-     */
-    decryptContent(encryptedContent: string): unknown;
-    /**
-     * Get messages from a session
-     */
-    getMessages(sessionId: string): Promise<GetMessagesResponse>;
-    /**
-     * Send a message to a session
-     * Note: In real implementation, we'd encrypt the content before sending
-     */
-    sendMessage(sessionId: string, content: unknown): Promise<SendMessageResponse>;
-}