@gricha/perry 0.3.0 → 0.3.2

package/dist/chat/session-monitor.js

@@ -1,186 +0,0 @@
-/**
- * Shared session monitoring and error handling for both Claude Code and OpenCode sessions.
- *
- * This module provides common functionality:
- * - Activity/heartbeat monitoring
- * - Timeout handling with user-friendly messages
- * - Session state management
- * - Error message formatting
- */
-/**
- * Monitors a session for timeouts and activity.
- * Handles cleanup of timers automatically.
- */
-export class SessionMonitor {
-    config;
-    callbacks;
-    operationTimer = null;
-    initialResponseTimer = null;
-    activityTimer = null;
-    lastActivity = 0;
-    started = false;
-    completed = false;
-    constructor(config, callbacks) {
-        this.config = config;
-        this.callbacks = callbacks;
-    }
-    /**
-     * Start monitoring the session
-     */
-    start() {
-        if (this.started)
-            return;
-        this.started = true;
-        // Set up initial response timeout
-        this.initialResponseTimer = setTimeout(() => {
-            if (!this.completed && this.lastActivity === 0) {
-                this.handleTimeout('No response received from server');
-            }
-        }, this.config.initialResponseTimeout);
-        // Set up overall operation timeout
-        this.operationTimer = setTimeout(() => {
-            if (!this.completed) {
-                this.handleTimeout(`Request timed out after ${this.config.operationTimeout / 1000}s. The operation took too long to complete.`);
-            }
-        }, this.config.operationTimeout);
-        // Set up activity monitoring if configured
-        if (this.config.activityTimeout && this.config.activityTimeout > 0) {
-            this.activityTimer = setInterval(() => {
-                const timeSinceActivity = Date.now() - this.lastActivity;
-                if (timeSinceActivity > this.config.activityTimeout && !this.completed) {
-                    this.handleActivityTimeout();
-                }
-            }, this.config.activityTimeout / 2);
-        }
-    }
-    /**
-     * Mark that we received activity (data, heartbeat, etc.)
-     */
-    markActivity() {
-        this.lastActivity = Date.now();
-        // Cancel initial response timeout once we receive first data
-        if (this.initialResponseTimer) {
-            clearTimeout(this.initialResponseTimer);
-            this.initialResponseTimer = null;
-        }
-    }
-    /**
-     * Mark the operation as complete and clean up
-     */
-    complete() {
-        this.completed = true;
-        this.cleanup();
-    }
-    /**
-     * Clean up all timers
-     */
-    cleanup() {
-        if (this.operationTimer) {
-            clearTimeout(this.operationTimer);
-            this.operationTimer = null;
-        }
-        if (this.initialResponseTimer) {
-            clearTimeout(this.initialResponseTimer);
-            this.initialResponseTimer = null;
-        }
-        if (this.activityTimer) {
-            clearInterval(this.activityTimer);
-            this.activityTimer = null;
-        }
-    }
-    /**
-     * Check if the monitor has been completed
-     */
-    isCompleted() {
-        return this.completed;
-    }
-    handleTimeout(message) {
-        this.completed = true;
-        this.callbacks.onError({
-            type: 'error',
-            content: `${message} Please try again or check if ${this.config.operationName} is responding.`,
-            timestamp: new Date().toISOString(),
-        });
-        this.callbacks.onTimeout();
-        this.cleanup();
-    }
-    handleActivityTimeout() {
-        this.completed = true;
-        this.callbacks.onError({
-            type: 'error',
-            content: `Connection to ${this.config.operationName} lost. Please try again.`,
-            timestamp: new Date().toISOString(),
-        });
-        if (this.callbacks.onActivityTimeout) {
-            this.callbacks.onActivityTimeout();
-        }
-        this.cleanup();
-    }
-}
-/**
- * Validates and formats error messages to be user-friendly
- */
-export function formatErrorMessage(error, context) {
-    if (error instanceof Error) {
-        // Remove stack traces and internal error patterns
-        let message = error.message || '';
-        // Common patterns to clean up
-        const cleanPatterns = [
-            /\s+at\s+.*/g, // Stack traces
-            /Error:\s+/g, // Redundant "Error: " prefix
-            /TypeError:\s+/g,
-            /ReferenceError:\s+/g,
-        ];
-        for (const pattern of cleanPatterns) {
-            message = message.replace(pattern, '');
-        }
-        message = message.trim();
-        // If message is too technical or empty, provide a generic message
-        if (!message || message.length < 5 || message.includes('undefined')) {
-            return `${context} failed. Please try again.`;
-        }
-        // Ensure first letter is capitalized
-        message = message.charAt(0).toUpperCase() + message.slice(1);
-        // Ensure it ends with punctuation
-        if (!/[.!?]$/.test(message)) {
-            message += '.';
-        }
-        return message;
-    }
-    return `${context} failed. Please try again.`;
-}
-/**
- * Wraps an async operation with timeout and error handling
- */
-export async function withTimeout(operation, timeoutMs, errorMessage) {
-    const timeout = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
-    });
-    return Promise.race([operation, timeout]);
-}
-/**
- * Configuration presets for different session types
- */
-export const MONITOR_PRESETS = {
-    // For Claude Code CLI sessions (simpler, no heartbeat)
-    claudeCode: {
-        operationTimeout: 300000, // 5 minutes for long operations
-        initialResponseTimeout: 10000, // 10 seconds to start responding
-        activityTimeout: 0, // Disabled - subprocess output is continuous
-        operationName: 'Claude Code',
-    },
-    // For OpenCode HTTP/SSE sessions (needs heartbeat monitoring)
-    openCode: {
-        operationTimeout: 120000, // 2 minutes
-        initialResponseTimeout: 5000, // 5 seconds to connect
-        activityTimeout: 45000, // 45 seconds (OpenCode heartbeats every 30s)
-        operationName: 'OpenCode',
-    },
-    // For quick operations (health checks, session verification)
-    quick: {
-        operationTimeout: 10000, // 10 seconds
-        initialResponseTimeout: 5000, // 5 seconds
-        activityTimeout: 0,
-        operationName: 'Operation',
-    },
-};

package/dist/chat/session-utils.js

@@ -1,155 +0,0 @@
-/**
- * Shared utilities for session management across Claude Code and OpenCode.
- *
- * Provides common functionality for:
- * - Session verification
- * - Session state checking
- * - Session pickup handling
- */
-/**
- * Abstract base class for session verification.
- * Subclasses implement the actual verification mechanism.
- */
-export class SessionVerifier {
-    sessionId;
-    constructor(sessionId) {
-        this.sessionId = sessionId;
-    }
-    /**
-     * Verify session and notify callbacks about state
-     */
-    async verifyAndNotify(callbacks) {
-        if (!this.sessionId) {
-            return true; // No session to verify
-        }
-        const exists = await this.verify();
-        if (!exists) {
-            callbacks.onMessage({
-                type: 'system',
-                content: 'Previous session expired, starting new session...',
-                timestamp: new Date().toISOString(),
-            });
-            if (callbacks.onSessionExpired) {
-                callbacks.onSessionExpired();
-            }
-            return false;
-        }
-        // Check session status
-        const status = await this.getStatus();
-        if (status === 'busy') {
-            callbacks.onMessage({
-                type: 'system',
-                content: 'Session is currently busy, waiting for it to become available...',
-                timestamp: new Date().toISOString(),
-            });
-            if (callbacks.onSessionBusy) {
-                callbacks.onSessionBusy();
-            }
-        }
-        return true;
-    }
-}
-/**
- * Verifier for OpenCode sessions (uses HTTP API)
- */
-export class OpenCodeSessionVerifier extends SessionVerifier {
-    containerName;
-    port;
-    execInContainer;
-    constructor(sessionId, containerName, port, execInContainer) {
-        super(sessionId);
-        this.containerName = containerName;
-        this.port = port;
-        this.execInContainer = execInContainer;
-    }
-    async verify() {
-        if (!this.sessionId)
-            return true;
-        try {
-            const result = await this.execInContainer(this.containerName, [
-                'curl',
-                '-s',
-                '-o',
-                '/dev/null',
-                '-w',
-                '%{http_code}',
-                '--max-time',
-                '5',
-                `http://localhost:${this.port}/session/${this.sessionId}`,
-            ], { user: 'workspace' });
-            return result.stdout.trim() === '200';
-        }
-        catch {
-            return false;
-        }
-    }
-    async getStatus() {
-        if (!this.sessionId)
-            return 'unknown';
-        try {
-            const result = await this.execInContainer(this.containerName, ['curl', '-s', '--max-time', '5', `http://localhost:${this.port}/session/status`], { user: 'workspace' });
-            const statuses = JSON.parse(result.stdout);
-            const status = statuses[this.sessionId];
-            if (status?.type === 'idle')
-                return 'idle';
-            if (status?.type === 'busy')
-                return 'busy';
-            return 'unknown';
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-}
-/**
- * Verifier for Claude Code sessions (filesystem-based)
- */
-export class ClaudeCodeSessionVerifier extends SessionVerifier {
-    checkSessionFile;
-    constructor(sessionId, checkSessionFile) {
-        super(sessionId);
-        this.checkSessionFile = checkSessionFile;
-    }
-    async verify() {
-        if (!this.sessionId)
-            return true;
-        try {
-            return await this.checkSessionFile(this.sessionId);
-        }
-        catch {
-            return false;
-        }
-    }
-    async getStatus() {
-        // Claude Code sessions don't have a "busy" state in the same way
-        // They're file-based and managed by the CLI
-        return 'unknown';
-    }
-}
-/**
- * Helper to handle session pickup flow consistently
- */
-export async function handleSessionPickup(verifier, callbacks) {
-    const exists = await verifier.verifyAndNotify(callbacks);
-    if (!exists) {
-        // Session doesn't exist, need to create new one
-        await callbacks.onNoSession();
-    }
-}
-/**
- * Create appropriate session verifier based on session type
- */
-export function createSessionVerifier(type, sessionId, config) {
-    if (type === 'opencode') {
-        if (!config.containerName || !config.port || !config.execInContainer) {
-            throw new Error('OpenCode verifier requires containerName, port, and execInContainer');
-        }
-        return new OpenCodeSessionVerifier(sessionId, config.containerName, config.port, config.execInContainer);
-    }
-    else {
-        if (!config.checkSessionFile) {
-            throw new Error('Claude Code verifier requires checkSessionFile');
-        }
-        return new ClaudeCodeSessionVerifier(sessionId, config.checkSessionFile);
-    }
-}

package/dist/chat/websocket.js

@@ -1,33 +0,0 @@
-import { BaseChatWebSocketServer, } from './base-chat-websocket';
-import { createChatSession } from './handler';
-import { createHostChatSession } from './host-handler';
-export class ChatWebSocketServer extends BaseChatWebSocketServer {
-    getConfig;
-    agentType = '';
-    constructor(options) {
-        super(options);
-        this.getConfig = options.getConfig;
-    }
-    createConnection(ws, workspaceName) {
-        return {
-            ws,
-            session: null,
-            workspaceName,
-        };
-    }
-    createHostSession(sessionId, onMessage, messageModel, projectPath) {
-        const config = this.getConfig();
-        const model = messageModel || config.agents?.claude_code?.model;
-        return createHostChatSession({ sessionId, model, workDir: projectPath }, onMessage);
-    }
-    createContainerSession(containerName, sessionId, onMessage, messageModel) {
-        const config = this.getConfig();
-        const model = messageModel || config.agents?.claude_code?.model;
-        return createChatSession({
-            containerName,
-            workDir: '/home/workspace',
-            sessionId,
-            model,
-        }, onMessage);
-    }
-}