lsh-framework 0.5.4

package/dist/lib/job-manager.js

@@ -0,0 +1,386 @@
+/**
+ * Job Management System for LSH Shell
+ * Supports CRUD operations on shell jobs and system processes
+ *
+ * REFACTORED: Now extends BaseJobManager to eliminate duplication
+ */
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import { BaseJobManager, } from './base-job-manager.js';
+import MemoryJobStorage from './job-storage-memory.js';
+const execAsync = promisify(exec);
+export class JobManager extends BaseJobManager {
+    nextJobId = 1;
+    persistenceFile;
+    schedulerInterval;
+    constructor(persistenceFile = '/tmp/lsh-jobs.json') {
+        super(new MemoryJobStorage(), 'JobManager');
+        this.persistenceFile = persistenceFile;
+        this.loadPersistedJobs();
+        this.startScheduler();
+        this.setupCleanupHandlers();
+    }
+    /**
+     * Start a job (execute it as a process)
+     */
+    async startJob(jobId) {
+        const baseJob = await this.getJob(jobId);
+        if (!baseJob) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+        const job = baseJob;
+        if (job.status === 'running') {
+            throw new Error(`Job ${jobId} is already running`);
+        }
+        try {
+            // Spawn the process
+            if (job.type === 'shell') {
+                job.process = spawn('sh', ['-c', job.command], {
+                    cwd: job.cwd,
+                    env: job.env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            else {
+                const [cmd, ...args] = job.command.split(' ');
+                job.process = spawn(cmd, args.concat(job.args || []), {
+                    cwd: job.cwd,
+                    env: job.env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            job.pid = job.process.pid;
+            // Handle output
+            job.process.stdout?.on('data', (data) => {
+                job.stdout = (job.stdout || '') + data.toString();
+                if (job.logFile) {
+                    fs.appendFileSync(job.logFile, data);
+                }
+                this.emit('jobOutput', job.id, 'stdout', data.toString());
+            });
+            job.process.stderr?.on('data', (data) => {
+                job.stderr = (job.stderr || '') + data.toString();
+                if (job.logFile) {
+                    fs.appendFileSync(job.logFile, data);
+                }
+                this.emit('jobOutput', job.id, 'stderr', data.toString());
+            });
+            // Handle completion
+            job.process.on('exit', (code, signal) => {
+                const status = code === 0 ? 'completed' : (signal === 'SIGKILL' ? 'killed' : 'failed');
+                this.updateJobStatus(job.id, status, {
+                    completedAt: new Date(),
+                    exitCode: code || undefined,
+                });
+                this.emit('jobCompleted', job, code, signal);
+                this.persistJobs();
+            });
+            // Set timeout if specified
+            if (job.timeout) {
+                job.timer = setTimeout(() => {
+                    this.stopJob(job.id, 'SIGKILL');
+                }, job.timeout);
+            }
+            // Update status to running
+            const updatedJob = await this.updateJobStatus(job.id, 'running', {
+                startedAt: new Date(),
+                pid: job.pid,
+            });
+            await this.persistJobs();
+            return updatedJob;
+        }
+        catch (error) {
+            await this.updateJobStatus(job.id, 'failed', {
+                completedAt: new Date(),
+                stderr: error.message,
+            });
+            this.emit('jobFailed', job, error);
+            await this.persistJobs();
+            throw error;
+        }
+    }
+    /**
+     * Stop a running job
+     */
+    async stopJob(jobId, signal = 'SIGTERM') {
+        const baseJob = await this.getJob(jobId);
+        if (!baseJob) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+        const job = baseJob;
+        if (job.status !== 'running') {
+            throw new Error(`Job ${jobId} is not running`);
+        }
+        if (!job.process || !job.pid) {
+            throw new Error(`Job ${jobId} has no associated process`);
+        }
+        // Clear timeout if exists
+        if (job.timer) {
+            clearTimeout(job.timer);
+            job.timer = undefined;
+        }
+        // Kill the process
+        try {
+            job.process.kill(signal);
+        }
+        catch (error) {
+            this.logger.error(`Failed to kill job ${jobId}`, error);
+        }
+        // Update status
+        const updatedJob = await this.updateJobStatus(jobId, 'stopped', {
+            completedAt: new Date(),
+        });
+        await this.persistJobs();
+        return updatedJob;
+    }
+    /**
+     * Create and immediately start a job
+     */
+    async runJob(spec) {
+        const job = await this.createJob(spec);
+        return await this.startJob(job.id);
+    }
+    /**
+     * Pause a job (stop it but keep for later resumption)
+     */
+    async pauseJob(jobId) {
+        await this.stopJob(jobId, 'SIGSTOP');
+        return await this.updateJobStatus(jobId, 'paused');
+    }
+    /**
+     * Resume a paused job
+     */
+    async resumeJob(jobId) {
+        const baseJob = await this.getJob(jobId);
+        if (!baseJob) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+        const job = baseJob;
+        if (job.status !== 'paused') {
+            throw new Error(`Job ${jobId} is not paused`);
+        }
+        if (!job.process || !job.pid) {
+            throw new Error(`Job ${jobId} has no associated process`);
+        }
+        // Send SIGCONT to resume
+        try {
+            job.process.kill('SIGCONT');
+            return await this.updateJobStatus(jobId, 'running');
+        }
+        catch (error) {
+            throw new Error(`Failed to resume job ${jobId}: ${error}`);
+        }
+    }
+    /**
+     * Kill a job forcefully
+     */
+    async killJob(jobId, signal = 'SIGKILL') {
+        return await this.stopJob(jobId, signal);
+    }
+    /**
+     * Monitor a job's resource usage
+     */
+    async monitorJob(jobId) {
+        const baseJob = await this.getJob(jobId);
+        if (!baseJob) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+        const job = baseJob;
+        if (!job.pid) {
+            throw new Error(`Job ${jobId} is not running`);
+        }
+        try {
+            const { stdout } = await execAsync(`ps -p ${job.pid} -o pid,ppid,pcpu,pmem,etime,state`);
+            const lines = stdout.split('\n');
+            if (lines.length < 2) {
+                return null; // Process not found
+            }
+            const parts = lines[1].trim().split(/\s+/);
+            const monitoring = {
+                pid: parseInt(parts[0]),
+                ppid: parseInt(parts[1]),
+                cpu: parseFloat(parts[2]),
+                memory: parseFloat(parts[3]),
+                elapsed: parts[4],
+                state: parts[5],
+                timestamp: new Date(),
+            };
+            // Update job with current resource usage
+            job.cpuUsage = monitoring.cpu;
+            job.memoryUsage = monitoring.memory;
+            this.emit('jobMonitoring', job, monitoring);
+            return monitoring;
+        }
+        catch (_error) {
+            return null; // Process likely terminated
+        }
+    }
+    /**
+     * Get system processes
+     */
+    async getSystemProcesses() {
+        try {
+            const { stdout } = await execAsync('ps -eo pid,ppid,user,pcpu,pmem,lstart,comm,args');
+            const lines = stdout.split('\n').slice(1); // Skip header
+            return lines
+                .filter(line => line.trim())
+                .map(line => {
+                const parts = line.trim().split(/\s+/);
+                return {
+                    pid: parseInt(parts[0]),
+                    ppid: parseInt(parts[1]),
+                    user: parts[2],
+                    cpu: parseFloat(parts[3]),
+                    memory: parseFloat(parts[4]),
+                    startTime: new Date(parts.slice(5, 9).join(' ')),
+                    name: parts[9],
+                    command: parts.slice(10).join(' ') || parts[9],
+                    status: 'running'
+                };
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to get system processes', error);
+            return [];
+        }
+    }
+    /**
+     * Get job statistics
+     */
+    getJobStats() {
+        const jobs = Array.from(this.jobs.values());
+        const stats = {
+            total: jobs.length,
+            byStatus: {},
+            byType: {},
+            running: jobs.filter(j => j.status === 'running').length,
+            completed: jobs.filter(j => j.status === 'completed').length,
+            failed: jobs.filter(j => j.status === 'failed').length,
+        };
+        jobs.forEach(job => {
+            stats.byStatus[job.status] = (stats.byStatus[job.status] || 0) + 1;
+            stats.byType[job.type] = (stats.byType[job.type] || 0) + 1;
+        });
+        return stats;
+    }
+    /**
+     * Clean up old jobs
+     */
+    async cleanupJobs(olderThanHours = 24) {
+        const cutoff = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
+        const jobs = await this.listJobs();
+        let cleaned = 0;
+        for (const job of jobs) {
+            if (job.status === 'completed' || job.status === 'failed') {
+                if (job.completedAt && job.completedAt < cutoff) {
+                    await this.removeJob(job.id, true);
+                    cleaned++;
+                }
+            }
+        }
+        this.logger.info(`Cleaned up ${cleaned} old jobs`);
+        return cleaned;
+    }
+    // ================================
+    // PRIVATE: Persistence & Scheduling
+    // ================================
+    async loadPersistedJobs() {
+        try {
+            if (fs.existsSync(this.persistenceFile)) {
+                const data = fs.readFileSync(this.persistenceFile, 'utf8');
+                const persistedJobs = JSON.parse(data);
+                for (const job of persistedJobs) {
+                    // Convert date strings back to Date objects
+                    job.createdAt = new Date(job.createdAt);
+                    if (job.startedAt)
+                        job.startedAt = new Date(job.startedAt);
+                    if (job.completedAt)
+                        job.completedAt = new Date(job.completedAt);
+                    // Don't restore running processes - mark them as stopped
+                    if (job.status === 'running') {
+                        job.status = 'stopped';
+                    }
+                    await this.storage.save(job);
+                    this.jobs.set(job.id, job);
+                }
+                this.logger.info(`Loaded ${persistedJobs.length} persisted jobs`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to load persisted jobs', error);
+        }
+    }
+    async persistJobs() {
+        try {
+            const jobs = Array.from(this.jobs.values()).map(job => {
+                const { process: _process, timer: _timer, ...serializable } = job;
+                return serializable;
+            });
+            fs.writeFileSync(this.persistenceFile, JSON.stringify(jobs, null, 2));
+        }
+        catch (error) {
+            this.logger.error('Failed to persist jobs', error);
+        }
+    }
+    startScheduler() {
+        // Check for scheduled jobs every minute
+        this.schedulerInterval = setInterval(() => {
+            this.checkScheduledJobs();
+        }, 60000);
+        // Run immediately on startup
+        this.checkScheduledJobs();
+    }
+    async checkScheduledJobs() {
+        const jobs = await this.listJobs({ status: 'created' });
+        const now = new Date();
+        for (const job of jobs) {
+            if (job.schedule?.nextRun && job.schedule.nextRun <= now) {
+                this.logger.info(`Starting scheduled job: ${job.id}`);
+                try {
+                    await this.startJob(job.id);
+                    // Calculate next run time
+                    if (job.schedule.interval) {
+                        job.schedule.nextRun = new Date(now.getTime() + job.schedule.interval);
+                        await this.updateJob(job.id, { schedule: job.schedule });
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Failed to start scheduled job ${job.id}`, error);
+                }
+            }
+        }
+    }
+    setupCleanupHandlers() {
+        const cleanup = async () => {
+            this.logger.info('JobManager shutting down...');
+            if (this.schedulerInterval) {
+                clearInterval(this.schedulerInterval);
+            }
+            // Stop all running jobs
+            const jobs = await this.listJobs({ status: 'running' });
+            for (const job of jobs) {
+                try {
+                    await this.stopJob(job.id);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to stop job ${job.id}`, error);
+                }
+            }
+            await this.persistJobs();
+            await this.cleanup();
+        };
+        process.on('SIGTERM', cleanup);
+        process.on('SIGINT', cleanup);
+    }
+    /**
+     * Override cleanup to include scheduler
+     */
+    async cleanup() {
+        if (this.schedulerInterval) {
+            clearInterval(this.schedulerInterval);
+        }
+        await super.cleanup();
+    }
+}
+export default JobManager;

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

@@ -0,0 +1,156 @@
+/**
+ * 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
+        const dbJob = {
+            job_id: job.id,
+            command: job.command,
+            started_at: job.startedAt?.toISOString(),
+            completed_at: job.completedAt?.toISOString(),
+            status: job.status,
+            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,
+                command: updates.command,
+                started_at: updates.startedAt?.toISOString(),
+                completed_at: updates.completedAt?.toISOString(),
+                status: updates.status || 'running',
+                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
+        const dbJob = {
+            job_id: execution.jobId,
+            command: execution.command,
+            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

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