lsh-framework 3.2.5 → 3.5.0

package/dist/lib/job-storage-database.js

@@ -1,164 +0,0 @@
-/**
- * Database Job Storage
- * Persistent storage for jobs and executions using DatabasePersistence
- * Used by CronJobManager and other database-backed managers
- */
-import DatabasePersistence from './database-persistence.js';
-export class DatabaseJobStorage {
-    persistence;
-    userId;
-    constructor(userId) {
-        this.userId = userId;
-        this.persistence = new DatabasePersistence(userId);
-    }
-    async save(job) {
-        // Map BaseJobSpec to database format (ShellJob structure)
-        const dbJob = {
-            job_id: job.id,
-            session_id: `job-storage-${Date.now()}`,
-            command: job.command,
-            working_directory: process.cwd(),
-            started_at: job.startedAt?.toISOString() || new Date().toISOString(),
-            completed_at: job.completedAt?.toISOString(),
-            status: job.status,
-            pid: job.pid,
-            exit_code: job.exitCode,
-            output: job.stdout,
-            error: job.stderr,
-        };
-        // Save using available method
-        await this.persistence.saveJob(dbJob);
-    }
-    async get(_jobId) {
-        // This would require adding a method to DatabasePersistence
-        // For now, return null and rely on list() filtering
-        return null;
-    }
-    async list(_filter) {
-        // Get active jobs from database
-        const dbJobs = await this.persistence.getActiveJobs();
-        // Convert to BaseJobSpec format
-        const jobs = dbJobs.map(dbJob => ({
-            id: dbJob.job_id,
-            name: dbJob.job_id, // Using job_id as name since name field doesn't exist
-            command: dbJob.command,
-            status: this.mapDbStatusToJobStatus(dbJob.status),
-            createdAt: new Date(dbJob.started_at),
-            startedAt: new Date(dbJob.started_at),
-            completedAt: dbJob.completed_at ? new Date(dbJob.completed_at) : undefined,
-            user: this.userId,
-            tags: [],
-            priority: 5,
-            maxRetries: 3,
-            retryCount: 0,
-            databaseSync: true,
-            exitCode: dbJob.exit_code,
-            stdout: dbJob.output,
-            stderr: dbJob.error,
-        }));
-        return jobs;
-    }
-    mapDbStatusToJobStatus(dbStatus) {
-        switch (dbStatus) {
-            case 'running':
-                return 'running';
-            case 'completed':
-            case 'success':
-                return 'completed';
-            case 'stopped':
-                return 'stopped';
-            case 'paused':
-                return 'paused';
-            case 'failed':
-            case 'timeout':
-                return 'failed';
-            case 'killed':
-                return 'killed';
-            default:
-                return 'created';
-        }
-    }
-    async update(jobId, updates) {
-        // Update by saving again (upsert behavior)
-        if (updates.command) {
-            const dbJob = {
-                job_id: jobId,
-                session_id: `job-storage-${Date.now()}`,
-                command: updates.command,
-                working_directory: process.cwd(),
-                started_at: updates.startedAt?.toISOString() || new Date().toISOString(),
-                completed_at: updates.completedAt?.toISOString(),
-                status: (updates.status || 'running'),
-                pid: updates.pid,
-                exit_code: updates.exitCode,
-                output: updates.stdout,
-                error: updates.stderr,
-            };
-            await this.persistence.saveJob(dbJob);
-        }
-    }
-    async delete(jobId) {
-        // DatabasePersistence doesn't have a delete method yet
-        // This would need to be added
-        console.warn(`Delete not implemented for job ${jobId}`);
-    }
-    async saveExecution(execution) {
-        // Map to database format and save as job (ShellJob structure)
-        const dbJob = {
-            job_id: execution.jobId,
-            session_id: `execution-${Date.now()}`,
-            command: execution.command,
-            working_directory: process.cwd(),
-            started_at: execution.startTime.toISOString(),
-            completed_at: execution.endTime?.toISOString(),
-            status: execution.status,
-            exit_code: execution.exitCode,
-            output: execution.stdout,
-            error: execution.stderr || execution.errorMessage,
-        };
-        await this.persistence.saveJob(dbJob);
-    }
-    async getExecutions(jobId, limit = 50) {
-        // Get active jobs (no specific history method available yet)
-        const dbJobs = await this.persistence.getActiveJobs();
-        const jobExecutions = dbJobs.filter(job => job.job_id === jobId);
-        return jobExecutions.slice(0, limit).map(dbExec => ({
-            executionId: `exec_${dbExec.job_id}_${Date.now()}`,
-            jobId: dbExec.job_id,
-            jobName: dbExec.job_id,
-            command: dbExec.command,
-            startTime: new Date(dbExec.started_at),
-            endTime: dbExec.completed_at ? new Date(dbExec.completed_at) : undefined,
-            duration: dbExec.completed_at
-                ? new Date(dbExec.completed_at).getTime() - new Date(dbExec.started_at).getTime()
-                : undefined,
-            status: this.mapDbStatus(dbExec.status),
-            exitCode: dbExec.exit_code,
-            stdout: dbExec.output,
-            stderr: dbExec.error,
-            errorMessage: dbExec.error,
-        }));
-    }
-    mapDbStatus(dbStatus) {
-        switch (dbStatus) {
-            case 'running':
-                return 'running';
-            case 'completed':
-            case 'success':
-                return 'completed';
-            case 'failed':
-                return 'failed';
-            case 'killed':
-                return 'killed';
-            case 'timeout':
-                return 'timeout';
-            default:
-                return 'failed';
-        }
-    }
-    async cleanup() {
-        // DatabasePersistence maintains its own connections
-        // No cleanup needed here
-    }
-}
-export default DatabaseJobStorage;

package/dist/lib/job-storage-memory.js

@@ -1,73 +0,0 @@
-/**
- * In-Memory Job Storage
- * Fast, volatile storage for jobs and executions
- * Used by JobManager for runtime job tracking
- */
-export class MemoryJobStorage {
-    jobs = new Map();
-    executions = new Map();
-    maxExecutionsPerJob;
-    constructor(maxExecutionsPerJob = 100) {
-        this.maxExecutionsPerJob = maxExecutionsPerJob;
-    }
-    async save(job) {
-        this.jobs.set(job.id, { ...job });
-    }
-    async get(jobId) {
-        const job = this.jobs.get(jobId);
-        return job ? { ...job } : null;
-    }
-    async list(filter) {
-        let jobs = Array.from(this.jobs.values()).map(job => ({ ...job }));
-        // Basic filtering (additional filters applied by BaseJobManager)
-        if (filter?.status) {
-            const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-            jobs = jobs.filter(job => statuses.includes(job.status));
-        }
-        return jobs;
-    }
-    async update(jobId, updates) {
-        const job = this.jobs.get(jobId);
-        if (!job) {
-            throw new Error(`Job ${jobId} not found`);
-        }
-        Object.assign(job, updates);
-        this.jobs.set(jobId, job);
-    }
-    async delete(jobId) {
-        this.jobs.delete(jobId);
-        this.executions.delete(jobId);
-    }
-    async saveExecution(execution) {
-        const jobExecutions = this.executions.get(execution.jobId) || [];
-        // Add new execution at the beginning
-        jobExecutions.unshift(execution);
-        // Limit number of executions stored
-        if (jobExecutions.length > this.maxExecutionsPerJob) {
-            jobExecutions.length = this.maxExecutionsPerJob;
-        }
-        this.executions.set(execution.jobId, jobExecutions);
-    }
-    async getExecutions(jobId, limit) {
-        const jobExecutions = this.executions.get(jobId) || [];
-        if (limit && limit < jobExecutions.length) {
-            return jobExecutions.slice(0, limit);
-        }
-        return jobExecutions.map(e => ({ ...e }));
-    }
-    async cleanup() {
-        this.jobs.clear();
-        this.executions.clear();
-    }
-    // Additional utility methods
-    getJobCount() {
-        return this.jobs.size;
-    }
-    getExecutionCount(jobId) {
-        if (jobId) {
-            return this.executions.get(jobId)?.length || 0;
-        }
-        return Array.from(this.executions.values()).reduce((sum, execs) => sum + execs.length, 0);
-    }
-}
-export default MemoryJobStorage;