happy-coder 0.1.1

package/dist/session/service.test.js

@@ -0,0 +1,71 @@
+/**
+ * Tests for the session service module
+ *
+ * This test verifies the complete session workflow: create session, send message, read message
+ * using the real handy server API. No mocking is used as per project requirements.
+ */
+import { authGetToken, getOrCreateSecretKey } from '#auth/auth';
+import { getConfig } from '#utils/config';
+import { expect } from 'chai';
+import { SessionService } from './service.js';
+describe('SessionService', () => {
+    let sessionService;
+    let authToken;
+    before(async () => {
+        // Get auth token for tests
+        const config = getConfig();
+        const secret = await getOrCreateSecretKey();
+        authToken = await authGetToken(config.serverUrl, secret);
+        // Create session service instance
+        sessionService = new SessionService(config.serverUrl, authToken);
+    });
+    it('should create session, send message, and read message back', async () => {
+        // 1. Create a session
+        const tag = `test-session-${Date.now()}`;
+        const sessionResponse = await sessionService.createSession(tag);
+        expect(sessionResponse).to.be.an('object');
+        expect(sessionResponse.session).to.be.an('object');
+        expect(sessionResponse.session.id).to.be.a('string');
+        expect(sessionResponse.session.tag).to.equal(tag);
+        expect(sessionResponse.session.seq).to.be.a('number');
+        expect(sessionResponse.session.createdAt).to.be.a('number');
+        expect(sessionResponse.session.updatedAt).to.be.a('number');
+        const sessionId = sessionResponse.session.id;
+        // 2. Send a message to the session
+        const messageContent = {
+            content: 'Hello, this is a test message from the session service test',
+            type: 'text-input'
+        };
+        const sendResponse = await sessionService.sendMessage(sessionId, messageContent);
+        expect(sendResponse).to.be.an('object');
+        expect(sendResponse.message).to.be.an('object');
+        expect(sendResponse.message.id).to.be.a('string');
+        expect(sendResponse.message.seq).to.be.a('number');
+        expect(sendResponse.message.content).to.be.an('object');
+        expect(sendResponse.message.content.c).to.be.a('string');
+        expect(sendResponse.message.content.t).to.equal('encrypted');
+        expect(sendResponse.message.createdAt).to.be.a('number');
+        expect(sendResponse.message.updatedAt).to.be.a('number');
+        // 3. Read messages from the session
+        const getResponse = await sessionService.getMessages(sessionId);
+        expect(getResponse).to.be.an('object');
+        expect(getResponse.messages).to.be.an('array');
+        expect(getResponse.messages.length).to.be.greaterThan(0);
+        // Find our message (should be the first one since it's ordered by createdAt desc)
+        const retrievedMessage = getResponse.messages[0];
+        expect(retrievedMessage).to.be.an('object');
+        expect(retrievedMessage.id).to.equal(sendResponse.message.id);
+        expect(retrievedMessage.seq).to.equal(sendResponse.message.seq);
+        expect(retrievedMessage.content).to.be.an('object');
+        expect(retrievedMessage.content.c).to.equal(sendResponse.message.content.c);
+        expect(retrievedMessage.content.t).to.equal('encrypted');
+        // 4. Decrypt the retrieved message and verify it matches what we sent
+        const decryptedContent = sessionService.decryptContent(retrievedMessage.content.c);
+        expect(decryptedContent).to.deep.equal(messageContent);
+        console.log('✅ Complete workflow test passed:');
+        console.log(`  - Created session: ${sessionId}`);
+        console.log(`  - Sent message with seq: ${sendResponse.message.seq}`);
+        console.log(`  - Retrieved ${getResponse.messages.length} messages`);
+        console.log(`  - Decrypted content matches original: ${JSON.stringify(messageContent)}`);
+    });
+});

package/dist/session/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Session types for handy-server integration
+ */
+export interface Session {
+    createdAt: number;
+    id: string;
+    seq: number;
+    tag: string;
+    updatedAt: number;
+}
+export interface SessionMessage {
+    content: MessageContent;
+    createdAt: number;
+    id: string;
+    seq: number;
+    updatedAt: number;
+}
+export interface MessageContent {
+    c: string;
+    t: 'encrypted';
+}
+export interface CreateSessionResponse {
+    session: Session;
+}
+export interface SendMessageResponse {
+    message: SessionMessage;
+}
+export interface ListSessionsResponse {
+    sessions: Session[];
+}
+export interface GetMessagesResponse {
+    messages: SessionMessage[];
+}
+export interface SocketUpdate {
+    content: {
+        c: string;
+        mid: string;
+        sid: string;
+        t: 'new-message';
+    };
+    createdAt: number;
+    id: string;
+    seq: number;
+}

package/dist/session/types.js

@@ -0,0 +1,4 @@
+/**
+ * Session types for handy-server integration
+ */
+export {};

package/dist/socket/client.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Socket.IO client for handy-cli
+ *
+ * This module manages the WebSocket connection to the handy server.
+ * It handles authentication, connection lifecycle, and message routing.
+ *
+ * Key responsibilities:
+ * - Establish authenticated socket connection
+ * - Handle reconnection logic
+ * - Route messages between server and local handlers
+ * - Manage connection state
+ *
+ * Design decisions:
+ * - Uses socket.io-client for compatibility with server
+ * - Auth token passed in handshake for authentication
+ * - Automatic reconnection with exponential backoff
+ * - Event emitter pattern for decoupled message handling
+ */
+import { EventEmitter } from 'node:events';
+export interface SocketClientOptions {
+    authToken: string;
+    serverUrl: string;
+    socketPath: string;
+}
+export declare class SocketClient extends EventEmitter {
+    private isConnected;
+    private options;
+    private socket;
+    constructor(options: SocketClientOptions);
+    /**
+     * Connect to the socket server
+     */
+    connect(): void;
+    /**
+     * Disconnect from the socket server
+     */
+    disconnect(): void;
+    /**
+     * Check if socket is connected
+     */
+    getIsConnected(): boolean;
+    /**
+     * Wait for socket to be authenticated
+     */
+    waitForAuth(): Promise<string>;
+    /**
+     * Set up socket event handlers
+     */
+    private setupEventHandlers;
+}

package/dist/socket/client.js

@@ -0,0 +1,136 @@
+/**
+ * Socket.IO client for handy-cli
+ *
+ * This module manages the WebSocket connection to the handy server.
+ * It handles authentication, connection lifecycle, and message routing.
+ *
+ * Key responsibilities:
+ * - Establish authenticated socket connection
+ * - Handle reconnection logic
+ * - Route messages between server and local handlers
+ * - Manage connection state
+ *
+ * Design decisions:
+ * - Uses socket.io-client for compatibility with server
+ * - Auth token passed in handshake for authentication
+ * - Automatic reconnection with exponential backoff
+ * - Event emitter pattern for decoupled message handling
+ */
+import { logger } from '#utils/logger';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+// eslint-disable-next-line unicorn/prefer-event-target
+export class SocketClient extends EventEmitter {
+    isConnected = false;
+    options;
+    socket = null;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    /**
+     * Connect to the socket server
+     */
+    connect() {
+        if (this.socket) {
+            logger.warn('Socket already connected');
+            return;
+        }
+        logger.info('Connecting to socket server...');
+        logger.debug(`Server URL: ${this.options.serverUrl}`);
+        logger.debug(`Socket path: ${this.options.socketPath}`);
+        this.socket = io(this.options.serverUrl, {
+            auth: {
+                token: this.options.authToken
+            },
+            path: this.options.socketPath,
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+            transports: ['websocket', 'polling'],
+            withCredentials: true
+        });
+        this.setupEventHandlers();
+    }
+    /**
+     * Disconnect from the socket server
+     */
+    disconnect() {
+        if (this.socket) {
+            logger.info('Disconnecting socket...');
+            this.socket.disconnect();
+            this.socket = null;
+            this.isConnected = false;
+        }
+    }
+    /**
+     * Check if socket is connected
+     */
+    getIsConnected() {
+        return this.isConnected;
+    }
+    /**
+     * Wait for socket to be authenticated
+     */
+    async waitForAuth() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Authentication timeout'));
+            }, 10_000); // 10 second timeout
+            this.once('authenticated', (user) => {
+                clearTimeout(timeout);
+                resolve(user);
+            });
+            this.once('authError', () => {
+                clearTimeout(timeout);
+                reject(new Error('Authentication failed'));
+            });
+            this.once('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Set up socket event handlers
+     */
+    setupEventHandlers() {
+        if (!this.socket)
+            return;
+        // Connection events
+        this.socket.on('connect', () => {
+            logger.info('Socket connected successfully');
+            this.isConnected = true;
+            this.emit('connected');
+        });
+        this.socket.on('disconnect', (reason) => {
+            logger.warn('Socket disconnected:', reason);
+            this.isConnected = false;
+            this.emit('disconnected', reason);
+        });
+        this.socket.on('connect_error', (error) => {
+            logger.error('Socket connection error:', error.message);
+            this.emit('error', error);
+        });
+        // Server events
+        this.socket.on('auth', (data) => {
+            if (data.success) {
+                logger.info('Socket authenticated successfully for user:', data.user);
+                this.emit('authenticated', data.user);
+            }
+            else {
+                logger.error('Socket authentication failed');
+                this.emit('authError');
+            }
+        });
+        this.socket.on('error', (data) => {
+            logger.error('Server error:', data.message);
+            this.emit('serverError', data.message);
+        });
+        this.socket.on('update', (data) => {
+            logger.debug('Received update:', data);
+            this.emit('update', data);
+        });
+    }
+}

package/dist/socket/client.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for the socket client module
+ *
+ * These tests verify socket connection and authentication with the real server.
+ * No mocking is used as per project requirements.
+ */
+export {};

package/dist/socket/client.test.js

@@ -0,0 +1,74 @@
+/**
+ * Tests for the socket client module
+ *
+ * These tests verify socket connection and authentication with the real server.
+ * No mocking is used as per project requirements.
+ */
+import { authGetToken, getOrCreateSecretKey } from '#auth/auth';
+import { getConfig } from '#utils/config';
+import { expect } from 'chai';
+import { SocketClient } from './client.js';
+describe('SocketClient', () => {
+    let client = null;
+    let authToken;
+    before(async () => {
+        // Get auth token for tests
+        const config = getConfig();
+        const secret = await getOrCreateSecretKey();
+        authToken = await authGetToken(config.serverUrl, secret);
+    });
+    afterEach(() => {
+        // Clean up socket connection
+        if (client) {
+            client.disconnect();
+            client = null;
+        }
+    });
+    describe('connection', () => {
+        it('should connect to the server with valid auth token', async () => {
+            const config = getConfig();
+            client = new SocketClient({
+                authToken,
+                serverUrl: config.serverUrl,
+                socketPath: config.socketPath
+            });
+            client.connect();
+            // Wait for authentication
+            const user = await client.waitForAuth();
+            expect(user).to.be.a('string');
+            expect(client.getIsConnected()).to.equal(true);
+        });
+        it('should emit error with invalid auth token', async () => {
+            const config = getConfig();
+            client = new SocketClient({
+                authToken: 'invalid-token',
+                serverUrl: config.serverUrl,
+                socketPath: config.socketPath
+            });
+            client.connect();
+            // Should reject with auth error
+            try {
+                await client.waitForAuth();
+                expect.fail('Should have thrown auth error');
+            }
+            catch (error) {
+                expect(error.message).to.include('Authentication');
+            }
+        });
+    });
+    describe('events', () => {
+        it('should emit connected event on successful connection', (done) => {
+            const config = getConfig();
+            client = new SocketClient({
+                authToken,
+                serverUrl: config.serverUrl,
+                socketPath: config.socketPath
+            });
+            client.once('connected', () => {
+                expect(client.getIsConnected()).to.equal(true);
+                done();
+            });
+            client.connect();
+        });
+    });
+});

package/dist/socket/types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Socket message types for handy-cli
+ *
+ * This module defines TypeScript interfaces for socket communication with the handy server.
+ * These types mirror the server's message format for type-safe communication.
+ *
+ * Key design decisions:
+ * - All messages are strongly typed to prevent runtime errors
+ * - Message content is encrypted using the session's encryption key
+ * - Types match the server's Prisma JSON types exactly
+ */
+/**
+ * Base message content structure for encrypted messages
+ */
+export interface SessionMessageContent {
+    c: string;
+    t: 'encrypted';
+}
+/**
+ * Update body for new messages
+ */
+export interface UpdateBody {
+    c: SessionMessageContent | string;
+    mid: string;
+    sid: string;
+    t: 'new-message';
+}
+/**
+ * Update event from server
+ */
+export interface Update {
+    content: UpdateBody;
+    createdAt: number;
+    id: string;
+    seq: number;
+}
+/**
+ * Socket events from server to client
+ */
+export interface ServerToClientEvents {
+    auth: (data: {
+        success: boolean;
+        user: string;
+    }) => void;
+    error: (data: {
+        message: string;
+    }) => void;
+    update: (data: Update) => void;
+}
+/**
+ * Socket events from client to server
+ */
+export interface ClientToServerEvents {
+}
+/**
+ * Client message types that we'll handle locally
+ */
+export interface TextInputMessage {
+    content: string;
+    type: 'text-input';
+}
+/**
+ * Session information
+ */
+export interface Session {
+    createdAt: number;
+    id: string;
+    seq: number;
+    updatedAt: number;
+}
+/**
+ * Session message from API
+ */
+export interface SessionMessage {
+    content: SessionMessageContent;
+    createdAt: number;
+    id: string;
+    seq: number;
+    updatedAt: number;
+}

package/dist/socket/types.js

@@ -0,0 +1,12 @@
+/**
+ * Socket message types for handy-cli
+ *
+ * This module defines TypeScript interfaces for socket communication with the handy server.
+ * These types mirror the server's message format for type-safe communication.
+ *
+ * Key design decisions:
+ * - All messages are strongly typed to prevent runtime errors
+ * - Message content is encrypted using the session's encryption key
+ * - Types match the server's Prisma JSON types exactly
+ */
+export {};

package/dist/utils/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Configuration management for handy-cli
+ *
+ * This module provides hardcoded configuration values for the application.
+ *
+ * Key responsibilities:
+ * - Provide typed configuration object
+ * - Centralize configuration constants
+ *
+ * Design decisions:
+ * - Hardcoded values instead of environment variables for simplicity
+ * - Server URL points to the known handy-api server
+ * - Socket path uses a known path for session updates
+ */
+export interface Config {
+    serverUrl: string;
+    socketPath: string;
+}
+/**
+ * Get the application configuration
+ */
+export declare function getConfig(): Config;

package/dist/utils/config.js

@@ -0,0 +1,23 @@
+/**
+ * Configuration management for handy-cli
+ *
+ * This module provides hardcoded configuration values for the application.
+ *
+ * Key responsibilities:
+ * - Provide typed configuration object
+ * - Centralize configuration constants
+ *
+ * Design decisions:
+ * - Hardcoded values instead of environment variables for simplicity
+ * - Server URL points to the known handy-api server
+ * - Socket path uses a known path for session updates
+ */
+/**
+ * Get the application configuration
+ */
+export function getConfig() {
+    return {
+        serverUrl: 'https://handy-api.korshakov.org',
+        socketPath: '/v1/updates'
+    };
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Logger utility for handy-cli
+ *
+ * This module provides structured logging with different log levels and colors.
+ *
+ * Key responsibilities:
+ * - Provide consistent logging interface
+ * - Color-coded output for different log levels
+ * - Timestamp prefixes for better debugging
+ */
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    ERROR = "ERROR",
+    INFO = "INFO",
+    WARN = "WARN"
+}
+declare class Logger {
+    debug(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    private getTimestamp;
+    private log;
+}
+export declare const logger: Logger;
+export {};

package/dist/utils/logger.js

@@ -0,0 +1,60 @@
+/**
+ * Logger utility for handy-cli
+ *
+ * This module provides structured logging with different log levels and colors.
+ *
+ * Key responsibilities:
+ * - Provide consistent logging interface
+ * - Color-coded output for different log levels
+ * - Timestamp prefixes for better debugging
+ */
+import chalk from 'chalk';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["WARN"] = "WARN";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    debug(message, ...args) {
+        if (process.env.DEBUG) {
+            this.log(LogLevel.DEBUG, message, ...args);
+        }
+    }
+    error(message, ...args) {
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+    info(message, ...args) {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+    warn(message, ...args) {
+        this.log(LogLevel.WARN, message, ...args);
+    }
+    getTimestamp() {
+        return new Date().toISOString();
+    }
+    log(level, message, ...args) {
+        const timestamp = this.getTimestamp();
+        const prefix = `[${timestamp}] [${level}]`;
+        switch (level) {
+            case LogLevel.DEBUG: {
+                console.log(chalk.gray(prefix), message, ...args);
+                break;
+            }
+            case LogLevel.ERROR: {
+                console.error(chalk.red(prefix), message, ...args);
+                break;
+            }
+            case LogLevel.INFO: {
+                console.log(chalk.blue(prefix), message, ...args);
+                break;
+            }
+            case LogLevel.WARN: {
+                console.log(chalk.yellow(prefix), message, ...args);
+                break;
+            }
+        }
+    }
+}
+export const logger = new Logger();

package/dist/utils/paths.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Path utilities for handy-cli
+ *
+ * This module provides utilities for working with file paths,
+ * particularly for accessing user home directory and config files.
+ *
+ * Key responsibilities:
+ * - Resolve paths relative to user home directory
+ * - Provide consistent paths for config and secret files
+ */
+/**
+ * Get the path to the secret key file in user's home directory
+ */
+export declare function getSecretKeyPath(): string;
+/**
+ * Get the user's home directory
+ */
+export declare function getHomeDir(): string;

package/dist/utils/paths.js

@@ -0,0 +1,24 @@
+/**
+ * Path utilities for handy-cli
+ *
+ * This module provides utilities for working with file paths,
+ * particularly for accessing user home directory and config files.
+ *
+ * Key responsibilities:
+ * - Resolve paths relative to user home directory
+ * - Provide consistent paths for config and secret files
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Get the path to the secret key file in user's home directory
+ */
+export function getSecretKeyPath() {
+    return join(homedir(), '.handy-claude-code.key');
+}
+/**
+ * Get the user's home directory
+ */
+export function getHomeDir() {
+    return homedir();
+}

package/dist/utils/qrcode.d.ts

@@ -0,0 +1,19 @@
+/**
+ * QR Code utility for handy-cli
+ *
+ * This module handles QR code generation and terminal display for the handy:// URL.
+ *
+ * Key responsibilities:
+ * - Generate QR codes for terminal display
+ * - Format QR codes with proper spacing and borders
+ * - Handle errors gracefully
+ *
+ * Design decisions:
+ * - Uses qrcode-terminal for ASCII art QR codes
+ * - Displays QR codes with clear instructions
+ * - Provides fallback text if QR generation fails
+ */
+/**
+ * Display a QR code in the terminal for the given URL
+ */
+export declare function displayQRCode(url: string): void;