lsh-framework 3.2.4 → 3.5.0

package/dist/lib/daemon-client.js

@@ -1,513 +0,0 @@
-/**
- * LSH Daemon Client
- * Provides communication interface between LSH and the job daemon
- */
-import * as net from 'net';
-import * as fs from 'fs';
-import { EventEmitter } from 'events';
-import DatabasePersistence from './database-persistence.js';
-import { createLogger } from './logger.js';
-import { getPlatformPaths } from './platform-utils.js';
-import { ENV_VARS, DEFAULTS } from '../constants/index.js';
-export class DaemonClient extends EventEmitter {
-    socketPath;
-    socket;
-    connected = false;
-    messageId = 0;
-    pendingMessages = new Map();
-    databasePersistence;
-    userId;
-    sessionId;
-    logger = createLogger('DaemonClient');
-    constructor(socketPath, userId) {
-        super();
-        // Use cross-platform socket path if not provided
-        if (!socketPath) {
-            const platformPaths = getPlatformPaths('lsh');
-            this.socketPath = platformPaths.socketPath;
-        }
-        else {
-            this.socketPath = socketPath;
-        }
-        this.userId = userId;
-        this.sessionId = `lsh_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        if (userId) {
-            this.databasePersistence = new DatabasePersistence(userId);
-        }
-    }
-    /**
-     * Connect to the daemon
-     */
-    async connect() {
-        return new Promise((resolve, reject) => {
-            if (this.connected) {
-                resolve(true);
-                return;
-            }
-            // Check if socket file exists
-            if (!fs.existsSync(this.socketPath)) {
-                reject(new Error(`Daemon socket not found at ${this.socketPath}. Is the daemon running?`));
-                return;
-            }
-            // Check socket permissions
-            try {
-                fs.accessSync(this.socketPath, fs.constants.R_OK | fs.constants.W_OK);
-            }
-            catch (_err) {
-                const stats = fs.statSync(this.socketPath);
-                const currentUid = process.getuid?.();
-                const owner = currentUid !== undefined && stats.uid === currentUid ? 'you' : 'another user';
-                reject(new Error(`Permission denied to access socket at ${this.socketPath}. Socket is owned by ${owner}. You may need to start your own daemon with: lsh daemon start`));
-                return;
-            }
-            this.socket = new net.Socket();
-            this.socket.on('connect', () => {
-                this.connected = true;
-                this.emit('connected');
-                resolve(true);
-            });
-            let buffer = '';
-            const MAX_BUFFER_SIZE = DEFAULTS.MAX_BUFFER_SIZE_BYTES;
-            this.socket.on('data', (data) => {
-                try {
-                    buffer += data.toString();
-                    // Prevent buffer from growing too large
-                    if (buffer.length > MAX_BUFFER_SIZE) {
-                        this.logger.error('Daemon response too large, truncating buffer');
-                        buffer = buffer.substring(buffer.length - MAX_BUFFER_SIZE / 2);
-                    }
-                    // Try to parse complete JSON messages
-                    // Messages might be split across multiple data events
-                    while (buffer.length > 0) {
-                        try {
-                            // Try to find complete JSON message boundaries
-                            let jsonStart = -1;
-                            let braceCount = 0;
-                            let inString = false;
-                            let escaped = false;
-                            for (let i = 0; i < buffer.length; i++) {
-                                const char = buffer[i];
-                                if (escaped) {
-                                    escaped = false;
-                                    continue;
-                                }
-                                if (char === '\\') {
-                                    escaped = true;
-                                    continue;
-                                }
-                                if (char === '"' && !escaped) {
-                                    inString = !inString;
-                                    continue;
-                                }
-                                if (inString)
-                                    continue;
-                                if (char === '{') {
-                                    if (jsonStart === -1)
-                                        jsonStart = i;
-                                    braceCount++;
-                                }
-                                else if (char === '}') {
-                                    braceCount--;
-                                    if (braceCount === 0 && jsonStart !== -1) {
-                                        // Found complete JSON object
-                                        const jsonStr = buffer.substring(jsonStart, i + 1);
-                                        try {
-                                            const response = JSON.parse(jsonStr);
-                                            this.handleResponse(response);
-                                            buffer = buffer.substring(i + 1); // Remove processed part
-                                            break;
-                                        }
-                                        catch (parseError) {
-                                            this.logger.error('Invalid JSON in daemon response', parseError, { jsonContent: jsonStr.substring(0, 200) });
-                                            buffer = buffer.substring(i + 1); // Skip this invalid JSON
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                            // If we didn't find a complete JSON object, wait for more data
-                            if (braceCount > 0 || jsonStart === -1) {
-                                break;
-                            }
-                        }
-                        catch (parseError) {
-                            this.logger.error('JSON parsing error', parseError);
-                            // Try to find the start of the next JSON object
-                            const nextStart = buffer.indexOf('{', 1);
-                            if (nextStart > 0) {
-                                buffer = buffer.substring(nextStart);
-                            }
-                            else {
-                                buffer = '';
-                                break;
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    this.logger.error('Failed to process daemon response', error);
-                    buffer = ''; // Reset buffer on error
-                }
-            });
-            this.socket.on('error', (error) => {
-                this.connected = false;
-                // Enhance error messages for common issues
-                if (error.code === 'EACCES') {
-                    error.message = `Permission denied to access daemon socket at ${this.socketPath}. The socket may be owned by another user. Try starting your own daemon with: lsh daemon start`;
-                }
-                else if (error.code === 'ECONNREFUSED') {
-                    error.message = `Daemon is not responding at ${this.socketPath}. The daemon may have crashed. Try restarting with: lsh daemon restart`;
-                }
-                else if (error.code === 'ENOENT') {
-                    error.message = `Daemon socket not found at ${this.socketPath}. Start the daemon with: lsh daemon start`;
-                }
-                this.emit('error', error);
-                reject(error);
-            });
-            this.socket.on('close', () => {
-                this.connected = false;
-                this.emit('disconnected');
-            });
-            this.socket.connect(this.socketPath);
-        });
-    }
-    /**
-     * Disconnect from the daemon
-     */
-    disconnect() {
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = undefined;
-        }
-        this.connected = false;
-    }
-    /**
-     * Send a message to the daemon
-     */
-    async sendMessage(message) {
-        if (!this.connected || !this.socket) {
-            throw new Error('Not connected to daemon');
-        }
-        const id = (++this.messageId).toString();
-        message.id = id;
-        return new Promise((resolve, reject) => {
-            // Set timeout for response (reduced for faster failure detection)
-            const timeoutId = setTimeout(() => {
-                if (this.pendingMessages.has(id)) {
-                    this.pendingMessages.delete(id);
-                    reject(new Error(`Request timeout after 10 seconds for command: ${message.command}`));
-                }
-            }, 10000); // 10 second timeout
-            // Store timeout ID for cleanup
-            this.pendingMessages.set(id, {
-                resolve: (data) => {
-                    clearTimeout(timeoutId);
-                    resolve(data);
-                },
-                reject: (error) => {
-                    clearTimeout(timeoutId);
-                    reject(error);
-                }
-            });
-            this.socket.write(JSON.stringify(message));
-        });
-    }
-    /**
-     * Handle response from daemon
-     */
-    handleResponse(response) {
-        if (response.id && this.pendingMessages.has(response.id)) {
-            const { resolve, reject } = this.pendingMessages.get(response.id);
-            this.pendingMessages.delete(response.id);
-            if (response.success) {
-                resolve(response.data);
-            }
-            else {
-                reject(new Error(response.error || 'Unknown error'));
-            }
-        }
-    }
-    /**
-     * Get daemon status
-     */
-    async getStatus() {
-        return await this.sendMessage({ command: 'status' });
-    }
-    /**
-     * Add a simple job to the daemon
-     */
-    async addJob(jobSpec) {
-        return await this.sendMessage({
-            command: 'addJob',
-            args: { jobSpec }
-        });
-    }
-    /**
-     * Create a cron job
-     */
-    async createCronJob(jobSpec) {
-        const daemonJobSpec = {
-            id: jobSpec.id,
-            name: jobSpec.name,
-            command: jobSpec.command,
-            type: 'scheduled',
-            schedule: jobSpec.schedule,
-            env: jobSpec.environment || {},
-            cwd: jobSpec.workingDirectory || process.cwd(),
-            user: jobSpec.user || process.env[ENV_VARS.USER],
-            priority: jobSpec.priority || 0,
-            tags: jobSpec.tags || [],
-            enabled: jobSpec.enabled !== false,
-            maxRetries: jobSpec.maxRetries || 3,
-            timeout: jobSpec.timeout || 0,
-        };
-        const result = await this.sendMessage({
-            command: 'addJob',
-            args: { jobSpec: daemonJobSpec }
-        });
-        // Sync to database if enabled
-        if (jobSpec.databaseSync && this.databasePersistence) {
-            await this.syncJobToDatabase(jobSpec, 'created');
-        }
-        return result;
-    }
-    /**
-     * Start a job
-     */
-    async startJob(jobId) {
-        const result = await this.sendMessage({
-            command: 'startJob',
-            args: { jobId }
-        });
-        // Sync to database
-        if (this.databasePersistence) {
-            await this.syncJobToDatabase({ id: jobId }, 'running');
-        }
-        return result;
-    }
-    /**
-     * Trigger a job to run immediately (bypass schedule)
-     */
-    async triggerJob(jobId) {
-        const result = await this.sendMessage({
-            command: 'triggerJob',
-            args: { jobId }
-        });
-        // Record job execution in database
-        if (this.databasePersistence) {
-            try {
-                const jobResult = result;
-                await this.databasePersistence.saveJob({
-                    user_id: this.userId,
-                    session_id: this.sessionId,
-                    job_id: jobId,
-                    command: `Triggered execution of ${jobId}`,
-                    status: jobResult.success ? 'completed' : 'failed',
-                    working_directory: process.cwd(),
-                    started_at: new Date().toISOString(),
-                    completed_at: new Date().toISOString(),
-                    exit_code: jobResult.success ? 0 : 1,
-                    output: jobResult.output,
-                    error: jobResult.error
-                });
-            }
-            catch (error) {
-                // Don't fail the trigger if database save fails
-                const err = error;
-                this.logger.warn(`Failed to save job execution to database: ${err.message}`);
-            }
-        }
-        return result;
-    }
-    /**
-     * Stop a job
-     */
-    async stopJob(jobId, signal = 'SIGTERM') {
-        const result = await this.sendMessage({
-            command: 'stopJob',
-            args: { jobId, signal }
-        });
-        // Sync to database
-        if (this.databasePersistence) {
-            await this.syncJobToDatabase({ id: jobId }, 'stopped');
-        }
-        return result;
-    }
-    /**
-     * List all jobs
-     */
-    async listJobs(filter) {
-        try {
-            const result = await this.sendMessage({
-                command: 'listJobs',
-                args: {
-                    filter,
-                    limit: 50 // Limit results to prevent oversized responses
-                }
-            });
-            // Ensure we return an array
-            if (Array.isArray(result)) {
-                return result;
-            }
-            else if (result && typeof result === 'object' && 'jobs' in result && Array.isArray(result.jobs)) {
-                return result.jobs;
-            }
-            else {
-                this.logger.warn('Unexpected job list format', { resultType: typeof result });
-                return [];
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to list jobs', error);
-            // Return empty array instead of throwing to prevent crashes
-            return [];
-        }
-    }
-    /**
-     * Get job details
-     */
-    async getJob(jobId) {
-        return await this.sendMessage({
-            command: 'getJob',
-            args: { jobId }
-        });
-    }
-    /**
-     * Remove a job
-     */
-    async removeJob(jobId, force = false) {
-        const result = await this.sendMessage({
-            command: 'removeJob',
-            args: { jobId, force }
-        });
-        // Remove from database
-        if (this.databasePersistence) {
-            // Note: DatabasePersistence doesn't have a removeJob method yet
-            // This would need to be implemented
-        }
-        return result;
-    }
-    /**
-     * Restart the daemon
-     */
-    async restartDaemon() {
-        await this.sendMessage({ command: 'restart' });
-    }
-    /**
-     * Stop the daemon
-     */
-    async stopDaemon() {
-        await this.sendMessage({ command: 'stop' });
-    }
-    /**
-     * Sync job status to Supabase database
-     */
-    async syncJobToDatabase(jobSpec, status) {
-        if (!this.databasePersistence)
-            return;
-        try {
-            await this.databasePersistence.saveJob({
-                session_id: this.databasePersistence.getSessionId(),
-                job_id: jobSpec.id,
-                command: jobSpec.command,
-                status: status,
-                working_directory: jobSpec.workingDirectory || process.cwd(),
-                started_at: new Date().toISOString(),
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to sync job to database', error);
-        }
-    }
-    /**
-     * Create a database-backed cron job
-     */
-    async createDatabaseCronJob(jobSpec) {
-        // Create job in daemon
-        const daemonResult = await this.createCronJob({
-            ...jobSpec,
-            databaseSync: true
-        });
-        // Create initial database record
-        if (this.databasePersistence) {
-            await this.databasePersistence.saveJob({
-                session_id: this.databasePersistence.getSessionId(),
-                job_id: jobSpec.id,
-                command: jobSpec.command,
-                status: 'running',
-                working_directory: jobSpec.workingDirectory || process.cwd(),
-                started_at: new Date().toISOString(),
-            });
-        }
-        return daemonResult;
-    }
-    /**
-     * Get job execution history from database
-     */
-    async getJobHistory(jobId, limit = 100) {
-        if (!this.databasePersistence) {
-            throw new Error('Database persistence not configured');
-        }
-        const jobs = await this.databasePersistence.getActiveJobs();
-        if (jobId) {
-            return jobs.filter(job => job.job_id === jobId);
-        }
-        return jobs.slice(0, limit);
-    }
-    /**
-     * Get job statistics from database
-     */
-    async getJobStatistics(jobId) {
-        if (!this.databasePersistence) {
-            throw new Error('Database persistence not configured');
-        }
-        const jobs = await this.databasePersistence.getActiveJobs();
-        if (jobId) {
-            const jobJobs = jobs.filter(job => job.job_id === jobId);
-            return this.calculateJobStatistics(jobJobs);
-        }
-        return this.calculateJobStatistics(jobs);
-    }
-    /**
-     * Calculate job statistics
-     */
-    calculateJobStatistics(jobs) {
-        const total = jobs.length;
-        const byStatus = jobs.reduce((acc, job) => {
-            const status = String(job.status);
-            acc[status] = (acc[status] || 0) + 1;
-            return acc;
-        }, {});
-        const completedCount = byStatus.completed || 0;
-        const successRate = total > 0 ? (completedCount / total) * 100 : 0;
-        return {
-            totalJobs: total,
-            byStatus,
-            successRate,
-            lastExecution: jobs.length > 0 ? (jobs[0].started_at || null) : null,
-        };
-    }
-    /**
-     * Check if daemon is running
-     */
-    isDaemonRunning() {
-        if (!fs.existsSync(this.socketPath)) {
-            return false;
-        }
-        try {
-            // Try to access the socket to verify it's working
-            fs.accessSync(this.socketPath, fs.constants.R_OK | fs.constants.W_OK);
-            return true;
-        }
-        catch (_error) {
-            return false;
-        }
-    }
-    /**
-     * Get connection status
-     */
-    isConnected() {
-        return this.connected;
-    }
-}
-export default DaemonClient;