happy-coder 0.1.7 → 0.1.9

package/dist/session/service.js

@@ -1,93 +0,0 @@
-/**
- * Session service for managing handy-server sessions
- */
-import { logger } from '#utils/logger';
-import axios from 'axios';
-export class SessionService {
-    serverUrl;
-    authToken;
-    constructor(serverUrl, authToken) {
-        this.serverUrl = serverUrl;
-        this.authToken = authToken;
-    }
-    /**
-     * Create a new session or load existing one with the given tag
-     */
-    async createSession(tag) {
-        try {
-            const response = await axios.post(`${this.serverUrl}/v1/sessions`, { tag }, {
-                headers: {
-                    'Authorization': `Bearer ${this.authToken}`,
-                    'Content-Type': 'application/json'
-                }
-            });
-            logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${tag})`);
-            return response.data;
-        }
-        catch (error) {
-            logger.error('Failed to create session:', error);
-            throw new Error(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * Decrypt a message content
-     * Note: In real implementation, this would use proper decryption
-     */
-    decryptContent(encryptedContent) {
-        try {
-            const jsonContent = Buffer.from(encryptedContent, 'base64').toString('utf8');
-            return JSON.parse(jsonContent);
-        }
-        catch (error) {
-            logger.error('Failed to decrypt content:', error);
-            throw new Error('Failed to decrypt message content');
-        }
-    }
-    /**
-     * Get messages from a session
-     */
-    async getMessages(sessionId) {
-        try {
-            const response = await axios.get(`${this.serverUrl}/v1/sessions/${sessionId}/messages`, {
-                headers: {
-                    'Authorization': `Bearer ${this.authToken}`,
-                    'Content-Type': 'application/json'
-                }
-            });
-            logger.debug(`Retrieved ${response.data.messages.length} messages from session ${sessionId}`);
-            return response.data;
-        }
-        catch (error) {
-            logger.error('Failed to get messages:', error);
-            throw new Error(`Failed to get messages: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * Send a message to a session
-     * Note: In real implementation, we'd encrypt the content before sending
-     */
-    async sendMessage(sessionId, content) {
-        try {
-            // For now, we'll just base64 encode the JSON content
-            // In production, this should use proper encryption
-            const jsonContent = JSON.stringify(content);
-            const base64Content = Buffer.from(jsonContent).toString('base64');
-            const messageContent = {
-                c: base64Content,
-                t: 'encrypted'
-            };
-            const response = await axios.post(`${this.serverUrl}/v1/sessions/${sessionId}/messages`, messageContent, {
-                headers: {
-                    'Authorization': `Bearer ${this.authToken}`,
-                    'Content-Type': 'application/json'
-                }
-            });
-            logger.debug(`Message sent to session ${sessionId}, seq: ${response.data.message.seq}`);
-            return response.data;
-        }
-        catch (error) {
-            logger.error('Failed to send message:', error);
-            throw new Error(`Failed to send message: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-}

package/dist/session/service.test.d.ts

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

package/dist/session/service.test.js

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

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

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

package/dist/socket/client.d.ts

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

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

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

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

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

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

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

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

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