happy-coder 0.1.1

package/dist/claude/claude.test.js

@@ -0,0 +1,130 @@
+/**
+ * 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

@@ -0,0 +1,37 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,161 @@
+/**
+ * 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

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