happy-coder 0.1.6 → 0.1.9

package/dist/claude/claude.js

@@ -1,170 +0,0 @@
-/**
- * Simplified Claude CLI integration
- *
- * This module provides a simple interface to spawn Claude CLI for each command.
- * Each command runs in its own process and exits when complete.
- *
- * Key responsibilities:
- * - Spawn Claude CLI with appropriate arguments
- * - Track session ID across command invocations
- * - Parse and emit Claude responses
- * - Handle process lifecycle for each command
- *
- * Design decisions:
- * - One process per command (no stdin interaction)
- * - Session ID persisted in memory only
- * - Kill any existing process before starting new one
- * - Simple event-based API for responses
- */
-import { logger } from '#utils/logger';
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-// eslint-disable-next-line unicorn/prefer-event-target
-export class Claude extends EventEmitter {
-    currentProcess;
-    currentSessionId;
-    /**
-     * Get the current session ID
-     */
-    getSessionId() {
-        return this.currentSessionId;
-    }
-    /**
-     * Kill the current process if running
-     */
-    kill() {
-        if (this.currentProcess && !this.currentProcess.killed) {
-            logger.info('Killing Claude process');
-            this.currentProcess.kill();
-            this.currentProcess = undefined;
-        }
-    }
-    /**
-     * Run a single Claude command
-     * Kills any existing process and spawns a new one
-     */
-    async runClaudeCodeTurn(command, sessionId, options) {
-        // Kill any existing process - wait for it to exit
-        if (this.currentProcess && !this.currentProcess.killed) {
-            logger.info('Killing existing Claude process');
-            await this.killAndWait();
-        }
-        // Build command arguments (no session resuming for now)
-        const args = this.buildArgs(command, undefined, options);
-        logger.info('Spawning Claude CLI with args:', args);
-        // Spawn the process
-        this.currentProcess = spawn('claude', args, {
-            cwd: options.workingDirectory,
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        // Close stdin immediately (we don't send input)
-        this.currentProcess.stdin?.end();
-        // Handle stdout (JSON responses)
-        let outputBuffer = '';
-        this.currentProcess.stdout?.on('data', (data) => {
-            outputBuffer += data.toString();
-            // Process complete lines
-            const lines = outputBuffer.split('\n');
-            outputBuffer = lines.pop() || '';
-            for (const line of lines) {
-                if (line.trim()) {
-                    this.processOutput(line);
-                }
-            }
-        });
-        // Handle stderr
-        this.currentProcess.stderr?.on('data', (data) => {
-            const error = data.toString();
-            logger.error('Claude stderr:', error);
-            this.emit('error', error);
-        });
-        // Handle process exit
-        this.currentProcess.on('exit', (code, signal) => {
-            logger.info(`Claude process exited with code ${code} and signal ${signal}`);
-            this.emit('exit', { code, signal });
-            this.currentProcess = undefined;
-        });
-        // Handle process errors
-        this.currentProcess.on('error', (error) => {
-            logger.error('Claude process error:', error);
-            this.emit('processError', error);
-            this.currentProcess = undefined;
-        });
-    }
-    /**
-     * Build command line arguments for Claude
-     */
-    buildArgs(command, sessionId, options) {
-        const args = [
-            '--print', command,
-            '--output-format', 'stream-json',
-            '--verbose'
-        ];
-        // Add model
-        if (options.model) {
-            args.push('--model', options.model);
-        }
-        // Add permission mode
-        if (options.permissionMode) {
-            const modeMap = {
-                'auto': 'acceptEdits',
-                'default': 'default',
-                'plan': 'bypassPermissions'
-            };
-            args.push('--permission-mode', modeMap[options.permissionMode]);
-        }
-        // Add skip permissions flag
-        if (options.skipPermissions) {
-            args.push('--dangerously-skip-permissions');
-        }
-        // Add session resume if we have a session ID
-        if (sessionId) {
-            args.push('--resume', sessionId);
-        }
-        return args;
-    }
-    /**
-     * Kill the current process and wait for it to exit
-     */
-    async killAndWait() {
-        if (!this.currentProcess || this.currentProcess.killed) {
-            return;
-        }
-        return new Promise((resolve) => {
-            const process = this.currentProcess;
-            // Set up exit handler
-            const exitHandler = () => {
-                this.currentProcess = undefined;
-                resolve();
-            };
-            process.once('exit', exitHandler);
-            // Kill the process
-            process.kill();
-            // Set a timeout in case the process doesn't exit
-            setTimeout(() => {
-                process.removeListener('exit', exitHandler);
-                this.currentProcess = undefined;
-                resolve();
-            }, 1000); // 1 second timeout
-        });
-    }
-    /**
-     * Process a line of output from Claude
-     */
-    processOutput(line) {
-        try {
-            const response = JSON.parse(line);
-            // Capture session ID from responses
-            if (response.session_id) {
-                this.currentSessionId = response.session_id;
-                logger.info('Session ID updated:', this.currentSessionId);
-            }
-            // Emit the parsed response
-            this.emit('response', response);
-        }
-        catch {
-            // Not JSON, emit as regular output
-            this.emit('output', line);
-        }
-    }
-}

package/dist/claude/claude.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Integration tests for Claude CLI
- *
- * These tests verify that we can properly interact with Claude CLI,
- * send commands, and receive responses.
- */
-export {};

package/dist/claude/claude.test.js

@@ -1,130 +0,0 @@
-/**
- * Integration tests for Claude CLI
- *
- * These tests verify that we can properly interact with Claude CLI,
- * send commands, and receive responses.
- */
-import { Claude } from '#claude/claude';
-import { logger } from '#utils/logger';
-import { expect } from 'chai';
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-describe('Claude CLI Integration', function () {
-    this.timeout(60_000); // 60 second timeout for Claude operations
-    let claude;
-    const playgroundPath = resolve('./claude-cli-playground-project');
-    before(() => {
-        // Verify playground directory exists
-        if (!existsSync(playgroundPath)) {
-            throw new Error('Playground directory not found. Run from handy-cli root directory.');
-        }
-    });
-    beforeEach(() => {
-        // Create a new Claude instance for each test
-        claude = new Claude();
-    });
-    afterEach(() => {
-        // Clean up Claude process
-        claude.kill();
-    });
-    it('should execute ls command and list files in playground directory', (done) => {
-        const responses = [];
-        let hasListedFiles = false;
-        let sessionId;
-        let testCompleted = false;
-        let hasSeenToolUse = false;
-        let hasSeenToolResult = false;
-        // Set a timeout to prevent infinite hanging
-        const timeout = setTimeout(() => {
-            if (!testCompleted) {
-                testCompleted = true;
-                claude.kill();
-                done(new Error('Test timeout: Claude did not respond within expected time'));
-            }
-        }, 15_000); // 15 second timeout
-        claude.on('response', (response) => {
-            responses.push(response);
-            logger.info('Response type:', response.type, 'Session ID:', response.session_id);
-            // Capture session ID
-            if (response.session_id) {
-                sessionId = response.session_id;
-                logger.info('Captured session ID:', sessionId);
-            }
-            // Check for tool use and tool results based on actual Claude output
-            if (response.type === 'assistant' && response.data) {
-                const content = JSON.stringify(response.data).toLowerCase();
-                if (content.includes('tool_use') || content.includes('ls')) {
-                    hasSeenToolUse = true;
-                    logger.info('Detected tool use in assistant response');
-                }
-            }
-            if (response.type === 'user' && response.data) {
-                const content = JSON.stringify(response.data).toLowerCase();
-                if (content.includes('tool_result') || content.includes('hello-world.js')) {
-                    hasSeenToolResult = true;
-                    hasListedFiles = true;
-                    logger.info('Detected tool result with file listing');
-                }
-            }
-            // Check various response types for file listing
-            if (response.type === 'assistant' || response.type === 'user' || response.type === 'claude-response') {
-                const content = JSON.stringify(response).toLowerCase();
-                // Check for expected files in playground
-                if (content.includes('hello-world.js')) {
-                    hasListedFiles = true;
-                    logger.info('Found hello-world.js in response');
-                }
-            }
-            // Complete test when we have seen both tool use and tool result
-            if (hasSeenToolUse && hasSeenToolResult && hasListedFiles && sessionId && !testCompleted) {
-                testCompleted = true;
-                clearTimeout(timeout);
-                expect(sessionId).to.be.a('string');
-                expect(sessionId).to.have.length.greaterThan(0);
-                expect(hasListedFiles).to.equal(true, 'Claude should have listed files');
-                expect(responses).to.have.length.greaterThan(0);
-                done();
-            }
-        });
-        claude.on('error', (error) => {
-            if (!testCompleted) {
-                testCompleted = true;
-                clearTimeout(timeout);
-                done(new Error(`Claude error: ${error}`));
-            }
-        });
-        claude.on('processError', (error) => {
-            if (!testCompleted) {
-                testCompleted = true;
-                clearTimeout(timeout);
-                // Claude CLI might not be installed
-                console.warn('Claude CLI not available:', error.message);
-                done();
-            }
-        });
-        claude.on('exit', (exitInfo) => {
-            if (!testCompleted) {
-                testCompleted = true;
-                clearTimeout(timeout);
-                logger.info(`Claude process exited with code ${exitInfo.code} and signal ${exitInfo.signal}`);
-                // Check if we got the expected responses even though process exited
-                if (sessionId && responses.length > 0 && (hasListedFiles || hasSeenToolResult)) {
-                    // Process exited but we got expected responses - this is normal
-                    expect(sessionId).to.be.a('string');
-                    expect(responses).to.have.length.greaterThan(0);
-                    done();
-                }
-                else {
-                    // Process exited without proper responses - this is an error
-                    done(new Error(`Claude process exited with code ${exitInfo.code} and signal ${exitInfo.signal} without providing expected responses`));
-                }
-            }
-        });
-        // Start Claude with ls command  
-        claude.runClaudeCodeTurn('Use the LS tool to list files in the current directory and tell me the first 5 files or folders you see.', undefined, {
-            model: 'sonnet',
-            permissionMode: 'default',
-            workingDirectory: playgroundPath
-        });
-    });
-});

package/dist/claude/types.d.ts

@@ -1,37 +0,0 @@
-/**
- * Types for Claude CLI interaction
- *
- * This module defines types for the JSON line output from Claude CLI
- * and configuration options for spawning Claude processes.
- */
-import type { ChildProcess } from 'node:child_process';
-/**
- * Claude CLI spawn options
- */
-export interface ClaudeSpawnOptions {
-    allowedTools?: string[];
-    disallowedTools?: string[];
-    model?: string;
-    permissionMode?: 'auto' | 'default' | 'plan';
-    sessionId?: string;
-    skipPermissions?: boolean;
-    workingDirectory: string;
-}
-/**
- * Claude CLI JSON output types
- */
-export interface ClaudeResponse {
-    data?: unknown;
-    error?: string;
-    message?: string;
-    session_id?: string;
-    type: string;
-}
-/**
- * Claude process state
- */
-export interface ClaudeProcess {
-    isRunning: boolean;
-    process: ChildProcess;
-    sessionId?: string;
-}

package/dist/claude/types.js

@@ -1,7 +0,0 @@
-/**
- * Types for Claude CLI interaction
- *
- * This module defines types for the JSON line output from Claude CLI
- * and configuration options for spawning Claude processes.
- */
-export {};

package/dist/commands/start.d.ts

@@ -1,38 +0,0 @@
-/**
- * Start command for handy-cli
- *
- * This is the main command that starts a Claude Code session and connects
- * it to the handy server for remote access.
- *
- * Key responsibilities:
- * - Initialize authentication
- * - Establish socket connection
- * - Start Claude session
- * - Handle message routing
- * - Graceful shutdown
- *
- * Design decisions:
- * - Uses oclif command framework as requested
- * - Handles all initialization in sequence
- * - Provides clear error messages
- * - Supports graceful shutdown on SIGINT/SIGTERM
- */
-import { Command } from '@oclif/core';
-export default class Start extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        model: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        'permission-mode': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        'skip-permissions': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'test-session': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    private messageHandler?;
-    private sessionId?;
-    private sessionService?;
-    private socketClient?;
-    run(): Promise<void>;
-    private cleanup;
-    private setupShutdownHandlers;
-    private shutdown;
-}

package/dist/commands/start.js

@@ -1,161 +0,0 @@
-/**
- * Start command for handy-cli
- *
- * This is the main command that starts a Claude Code session and connects
- * it to the handy server for remote access.
- *
- * Key responsibilities:
- * - Initialize authentication
- * - Establish socket connection
- * - Start Claude session
- * - Handle message routing
- * - Graceful shutdown
- *
- * Design decisions:
- * - Uses oclif command framework as requested
- * - Handles all initialization in sequence
- * - Provides clear error messages
- * - Supports graceful shutdown on SIGINT/SIGTERM
- */
-import { authGetToken, generateHandyUrl, getOrCreateSecretKey } from '#auth/auth';
-import { MessageHandler } from '#handlers/message-handler';
-import { SessionService } from '#session/service';
-import { SocketClient } from '#socket/client';
-import { getConfig } from '#utils/config';
-import { logger } from '#utils/logger';
-import { displayQRCode } from '#utils/qrcode';
-import { Command, Flags } from '@oclif/core';
-import { basename } from 'node:path';
-export default class Start extends Command {
-    static description = 'Start a Claude Code session connected to the handy server';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --model sonnet',
-        '<%= config.bin %> <%= command.id %> --skip-permissions',
-    ];
-    static flags = {
-        model: Flags.string({
-            char: 'm',
-            default: 'sonnet',
-            description: 'Claude model to use',
-            options: ['sonnet', 'opus', 'haiku'],
-        }),
-        'permission-mode': Flags.string({
-            default: 'auto',
-            description: 'Permission mode for Claude',
-            options: ['plan', 'auto', 'default'],
-        }),
-        'skip-permissions': Flags.boolean({
-            default: true,
-            description: 'Skip permission prompts (dangerous)',
-        }),
-        'test-session': Flags.string({
-            description: 'Use a specific session ID for testing (internal use)',
-            hidden: true,
-        }),
-    };
-    messageHandler;
-    sessionId;
-    sessionService;
-    socketClient;
-    async run() {
-        const { flags } = await this.parse(Start);
-        try {
-            // Load configuration
-            const config = getConfig();
-            logger.info('Starting handy-cli...');
-            // Step 1: Authentication
-            logger.info('Authenticating with server...');
-            const secret = await getOrCreateSecretKey();
-            const authToken = await authGetToken(config.serverUrl, secret);
-            logger.info('Authentication successful');
-            // Step 1.5: Display QR code for mobile connection
-            const handyUrl = generateHandyUrl(secret);
-            displayQRCode(handyUrl);
-            // Step 2: Connect to socket server
-            logger.info('Connecting to socket server...');
-            this.socketClient = new SocketClient({
-                authToken,
-                serverUrl: config.serverUrl,
-                socketPath: config.socketPath,
-            });
-            this.socketClient.connect();
-            // Wait for authentication
-            const user = await this.socketClient.waitForAuth();
-            logger.info(`Connected as user: ${user}`);
-            // Step 3: Create server session
-            const workingDirectory = process.cwd();
-            const sessionTag = basename(workingDirectory);
-            logger.info(`Creating server session with tag: ${sessionTag}`);
-            this.sessionService = new SessionService(config.serverUrl, authToken);
-            const { session } = await this.sessionService.createSession(sessionTag);
-            this.sessionId = session.id;
-            logger.info(`Session created: ${this.sessionId}`);
-            // Step 4: Initialize Claude
-            logger.info(`Initializing Claude in: ${workingDirectory}`);
-            // Step 4: Set up message handler with session ID
-            this.messageHandler = new MessageHandler({
-                claudeOptions: {
-                    model: flags.model,
-                    permissionMode: flags['permission-mode'],
-                    skipPermissions: flags['skip-permissions']
-                },
-                sessionId: this.sessionId,
-                sessionService: this.sessionService,
-                socketClient: this.socketClient,
-                workingDirectory
-            });
-            this.messageHandler.start();
-            // Set up event handlers for logging
-            this.messageHandler.on('claudeResponse', (response) => {
-                logger.info('Claude response:', JSON.stringify(response, null, 2));
-            });
-            this.messageHandler.on('error', (error) => {
-                logger.error('Handler error:', error);
-            });
-            this.messageHandler.on('claudeExit', (exitInfo) => {
-                logger.info('Claude process exited:', exitInfo);
-            });
-            // Step 5: Start initial Claude session
-            logger.info('Starting Claude Code session...');
-            logger.info('Model:', flags.model);
-            logger.info('Permission mode:', flags['permission-mode']);
-            logger.info('Skip permissions:', flags['skip-permissions']);
-            // Start with a command to show current working directory to ensure we
-            // are in the correct project
-            const initialCommand = 'Show current working directory';
-            logger.info('Sending initial command to Claude:', initialCommand);
-            // Send the initial command through the message handler to ensure it's properly captured
-            this.messageHandler.handleInitialCommand(initialCommand);
-            // Set up graceful shutdown
-            this.setupShutdownHandlers();
-            logger.info('Handy CLI is running. Press Ctrl+C to stop.');
-            logger.info('Waiting for commands from connected clients...');
-            // Keep the process running
-            await new Promise(() => { });
-        }
-        catch (error) {
-            logger.error('Failed to start:', error);
-            this.cleanup();
-            this.exit(1);
-        }
-    }
-    cleanup() {
-        if (this.messageHandler) {
-            this.messageHandler.stop();
-        }
-        if (this.socketClient) {
-            this.socketClient.disconnect();
-        }
-    }
-    setupShutdownHandlers() {
-        process.on('SIGINT', () => this.shutdown());
-        process.on('SIGTERM', () => this.shutdown());
-    }
-    shutdown() {
-        logger.info('Shutting down...');
-        this.cleanup();
-        // Use OCLIF's exit method for proper shutdown
-        this.exit(0);
-    }
-}

package/dist/commands/start.test.d.ts

@@ -1,7 +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.
- */
-export {};