lsh-framework 3.2.5 → 3.5.0

package/dist/lib/history-system.js

@@ -1,246 +0,0 @@
-/**
- * Command History System Implementation
- * Provides ZSH-compatible history functionality
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { DEFAULTS } from '../constants/index.js';
-export class HistorySystem {
-    entries = [];
-    currentIndex = -1;
-    config;
-    isEnabled = true;
-    constructor(config) {
-        this.config = {
-            maxSize: DEFAULTS.MAX_HISTORY_SIZE,
-            filePath: path.join(os.homedir(), '.lsh_history'),
-            shareHistory: false,
-            ignoreDups: true,
-            ignoreSpace: false,
-            expireDuplicatesFirst: true,
-            ...config,
-        };
-        this.loadHistory();
-    }
-    /**
-     * Add a command to history
-     */
-    addCommand(command, exitCode) {
-        if (!this.isEnabled)
-            return;
-        // Skip empty commands
-        if (!command.trim())
-            return;
-        // Skip commands starting with space if ignoreSpace is enabled
-        if (this.config.ignoreSpace && command.startsWith(' '))
-            return;
-        // Remove duplicates if configured
-        if (this.config.ignoreDups) {
-            this.removeDuplicateCommand(command);
-        }
-        const entry = {
-            lineNumber: this.entries.length + 1,
-            command: command.trim(),
-            timestamp: Date.now(),
-            exitCode,
-        };
-        this.entries.push(entry);
-        // Trim history if it exceeds max size
-        if (this.entries.length > this.config.maxSize) {
-            this.entries = this.entries.slice(-this.config.maxSize);
-            this.renumberEntries();
-        }
-        this.currentIndex = this.entries.length - 1;
-        this.saveHistory();
-    }
-    /**
-     * Get history entry by line number
-     */
-    getEntry(lineNumber) {
-        return this.entries.find(entry => entry.lineNumber === lineNumber);
-    }
-    /**
-     * Get history entry by command prefix
-     */
-    getEntryByPrefix(prefix) {
-        return this.entries
-            .slice()
-            .reverse()
-            .find(entry => entry.command.startsWith(prefix));
-    }
-    /**
-     * Get all history entries
-     */
-    getAllEntries() {
-        return [...this.entries];
-    }
-    /**
-     * Search history for commands matching pattern
-     */
-    searchHistory(pattern) {
-        const regex = new RegExp(pattern, 'i');
-        return this.entries.filter(entry => regex.test(entry.command));
-    }
-    /**
-     * Get previous command in history
-     */
-    getPreviousCommand() {
-        if (this.currentIndex > 0) {
-            this.currentIndex--;
-            return this.entries[this.currentIndex].command;
-        }
-        return null;
-    }
-    /**
-     * Get next command in history
-     */
-    getNextCommand() {
-        if (this.currentIndex < this.entries.length - 1) {
-            this.currentIndex++;
-            return this.entries[this.currentIndex].command;
-        }
-        return null;
-    }
-    /**
-     * Reset history navigation index
-     */
-    resetIndex() {
-        this.currentIndex = this.entries.length - 1;
-    }
-    /**
-     * Expand history references like !! !n !string
-     */
-    expandHistory(command) {
-        let result = command;
-        // Handle !! (last command)
-        result = result.replace(/!!/g, () => {
-            const lastEntry = this.entries[this.entries.length - 1];
-            return lastEntry ? lastEntry.command : '!!';
-        });
-        // Handle !n (command number n)
-        result = result.replace(/!(\d+)/g, (match, numStr) => {
-            const num = parseInt(numStr, 10);
-            const entry = this.getEntry(num);
-            return entry ? entry.command : match;
-        });
-        // Handle !string (last command starting with string)
-        result = result.replace(/!([a-zA-Z0-9_]+)/g, (match, prefix) => {
-            const entry = this.getEntryByPrefix(prefix);
-            return entry ? entry.command : match;
-        });
-        // Handle ^old^new (quick substitution)
-        result = result.replace(/\^([^^]+)\^([^^]*)/g, (match, old, replacement) => {
-            const lastEntry = this.entries[this.entries.length - 1];
-            if (lastEntry) {
-                return lastEntry.command.replace(new RegExp(old, 'g'), replacement);
-            }
-            return match;
-        });
-        return result;
-    }
-    /**
-     * Clear history
-     */
-    clearHistory() {
-        this.entries = [];
-        this.currentIndex = -1;
-        this.saveHistory();
-    }
-    /**
-     * Get history statistics
-     */
-    getStats() {
-        const unique = new Set(this.entries.map(e => e.command)).size;
-        const oldest = this.entries.length > 0 ? new Date(this.entries[0].timestamp) : null;
-        const newest = this.entries.length > 0 ? new Date(this.entries[this.entries.length - 1].timestamp) : null;
-        return {
-            total: this.entries.length,
-            unique,
-            oldest,
-            newest,
-        };
-    }
-    /**
-     * Enable/disable history
-     */
-    setEnabled(enabled) {
-        this.isEnabled = enabled;
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-    }
-    /**
-     * Load history from file
-     */
-    loadHistory() {
-        try {
-            if (fs.existsSync(this.config.filePath)) {
-                const content = fs.readFileSync(this.config.filePath, 'utf8');
-                const lines = content.split('\n').filter(line => line.trim());
-                this.entries = lines.map((line, index) => {
-                    // Parse history line format: timestamp:command
-                    const colonIndex = line.indexOf(':');
-                    if (colonIndex > 0) {
-                        const timestamp = parseInt(line.substring(0, colonIndex), 10);
-                        const command = line.substring(colonIndex + 1);
-                        return {
-                            lineNumber: index + 1,
-                            command,
-                            timestamp: isNaN(timestamp) ? Date.now() : timestamp,
-                        };
-                    }
-                    else {
-                        return {
-                            lineNumber: index + 1,
-                            command: line,
-                            timestamp: Date.now(),
-                        };
-                    }
-                });
-            }
-        }
-        catch (_error) {
-            // If loading fails, start with empty history
-            this.entries = [];
-        }
-    }
-    /**
-     * Save history to file
-     */
-    saveHistory() {
-        try {
-            const content = this.entries
-                .map(entry => `${entry.timestamp}:${entry.command}`)
-                .join('\n');
-            // Ensure directory exists
-            const dir = path.dirname(this.config.filePath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(this.config.filePath, content, 'utf8');
-        }
-        catch (_error) {
-            // Silently fail if we can't save history
-        }
-    }
-    /**
-     * Remove duplicate command from history
-     */
-    removeDuplicateCommand(command) {
-        const trimmedCommand = command.trim();
-        this.entries = this.entries.filter(entry => entry.command !== trimmedCommand);
-    }
-    /**
-     * Renumber entries after trimming
-     */
-    renumberEntries() {
-        this.entries.forEach((entry, index) => {
-            entry.lineNumber = index + 1;
-        });
-    }
-}
-export default HistorySystem;

package/dist/lib/job-manager.js

@@ -1,436 +0,0 @@
-/**
- * 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;
-    initPromise;
-    constructor(persistenceFile = '/tmp/lsh-jobs.json') {
-        super(new MemoryJobStorage(), 'JobManager');
-        this.persistenceFile = persistenceFile;
-        this.initPromise = this.loadPersistedJobs();
-        this.startScheduler();
-        this.setupCleanupHandlers();
-    }
-    /**
-     * Wait for initialization to complete
-     */
-    async ready() {
-        await this.initPromise;
-    }
-    /**
-     * Create a job and persist to filesystem
-     */
-    async createJob(spec) {
-        const job = await super.createJob(spec);
-        await this.persistJobs();
-        return job;
-    }
-    /**
-     * Update a job and persist to filesystem
-     */
-    async updateJob(jobId, updates) {
-        const job = await super.updateJob(jobId, updates);
-        await this.persistJobs();
-        return job;
-    }
-    /**
-     * Remove a job and persist to filesystem
-     */
-    async removeJob(jobId, force = false) {
-        const result = await super.removeJob(jobId, force);
-        if (result) {
-            await this.persistJobs();
-        }
-        return result;
-    }
-    /**
-     * Update job status and persist to filesystem
-     */
-    async updateJobStatus(jobId, status, additionalUpdates) {
-        const job = await super.updateJobStatus(jobId, status, additionalUpdates);
-        await this.persistJobs();
-        return job;
-    }
-    /**
-     * 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', async (code, signal) => {
-                // Check if job still exists (might have been removed during cleanup)
-                const existingJob = await this.getJob(job.id);
-                if (!existingJob) {
-                    this.logger.debug(`Job ${job.id} already removed, skipping status update`);
-                    return;
-                }
-                const status = code === 0 ? 'completed' : (signal === 'SIGKILL' ? 'killed' : 'failed');
-                await this.updateJobStatus(job.id, status, {
-                    completedAt: new Date(),
-                    exitCode: code || undefined,
-                });
-                this.emit('jobCompleted', job, code, signal);
-            });
-            // 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,
-            });
-            return updatedJob;
-        }
-        catch (error) {
-            const err = error;
-            await this.updateJobStatus(job.id, 'failed', {
-                completedAt: new Date(),
-                stderr: err.message,
-            });
-            this.emit('jobFailed', job, error);
-            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(),
-        });
-        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');
-                // Handle empty file
-                if (!data || data.trim() === '') {
-                    this.logger.info('Persistence file is empty, starting fresh');
-                    return;
-                }
-                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;
-            });
-            // Write with secure permissions (mode 0o600 = rw-------)
-            fs.writeFileSync(this.persistenceFile, JSON.stringify(jobs, null, 2), { mode: 0o600 });
-        }
-        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;