lsh-framework 1.3.2 → 1.4.1

package/dist/lib/local-storage-adapter.js

@@ -0,0 +1,493 @@
+/**
+ * Local File-Based Storage Adapter
+ * Provides persistence when Supabase/PostgreSQL is not available
+ * Uses JSON files for storage - suitable for development and single-user deployments
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Local file-based storage adapter
+ * Implements same interface as DatabasePersistence but uses local JSON files
+ */
+export class LocalStorageAdapter {
+    dataDir;
+    dataFile;
+    data;
+    userId;
+    sessionId;
+    autoFlush;
+    flushInterval;
+    isDirty = false;
+    constructor(userId, config = {}) {
+        this.userId = userId;
+        this.sessionId = this.generateSessionId();
+        this.dataDir = config.dataDir || path.join(os.homedir(), '.lsh', 'data');
+        this.dataFile = path.join(this.dataDir, 'storage.json');
+        this.autoFlush = config.autoFlush !== false; // default true
+        // Initialize empty data structure
+        this.data = {
+            shell_history: [],
+            shell_jobs: [],
+            shell_configuration: [],
+            shell_sessions: [],
+            shell_aliases: [],
+            shell_functions: [],
+            shell_completions: [],
+        };
+        // Start auto-flush if enabled
+        if (this.autoFlush) {
+            const interval = config.flushInterval || 5000; // default 5s
+            this.flushInterval = setInterval(() => this.flush(), interval);
+        }
+    }
+    /**
+     * Initialize storage directory and load existing data
+     */
+    async initialize() {
+        try {
+            // Create data directory if it doesn't exist
+            await fs.mkdir(this.dataDir, { recursive: true });
+            // Load existing data if file exists
+            try {
+                const content = await fs.readFile(this.dataFile, 'utf-8');
+                this.data = JSON.parse(content);
+            }
+            catch (_error) {
+                // File doesn't exist yet, use empty data
+                await this.flush();
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize local storage:', error);
+            throw error;
+        }
+    }
+    /**
+     * Flush in-memory data to disk
+     */
+    async flush() {
+        if (!this.isDirty) {
+            return;
+        }
+        try {
+            await fs.writeFile(this.dataFile, JSON.stringify(this.data, null, 2), 'utf-8');
+            this.isDirty = false;
+        }
+        catch (error) {
+            console.error('Failed to flush data to disk:', error);
+            throw error;
+        }
+    }
+    /**
+     * Mark data as dirty (needs flush)
+     */
+    markDirty() {
+        this.isDirty = true;
+    }
+    /**
+     * Cleanup and flush on exit
+     */
+    async cleanup() {
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+        }
+        await this.flush();
+    }
+    /**
+     * Generate a unique session ID
+     */
+    generateSessionId() {
+        return `lsh_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Generate a unique ID
+     */
+    generateId() {
+        return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Save shell history entry
+     */
+    async saveHistoryEntry(entry) {
+        try {
+            const newEntry = {
+                ...entry,
+                id: this.generateId(),
+                user_id: this.userId,
+                session_id: this.sessionId,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            this.data.shell_history.push(newEntry);
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error saving history entry:', error);
+            return false;
+        }
+    }
+    /**
+     * Get shell history entries
+     */
+    async getHistoryEntries(limit = 100, offset = 0) {
+        try {
+            const filtered = this.data.shell_history.filter(entry => this.userId ? entry.user_id === this.userId : entry.user_id === undefined || entry.user_id === null);
+            // Sort by timestamp descending
+            filtered.sort((a, b) => {
+                const timeA = new Date(a.timestamp).getTime();
+                const timeB = new Date(b.timestamp).getTime();
+                return timeB - timeA;
+            });
+            return filtered.slice(offset, offset + limit);
+        }
+        catch (error) {
+            console.error('Error getting history entries:', error);
+            return [];
+        }
+    }
+    /**
+     * Save shell job
+     */
+    async saveJob(job) {
+        try {
+            const newJob = {
+                ...job,
+                id: this.generateId(),
+                user_id: this.userId,
+                session_id: this.sessionId,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            this.data.shell_jobs.push(newJob);
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error saving job:', error);
+            return false;
+        }
+    }
+    /**
+     * Update shell job status
+     */
+    async updateJobStatus(jobId, status, exitCode) {
+        try {
+            const job = this.data.shell_jobs.find(j => j.job_id === jobId &&
+                (this.userId ? j.user_id === this.userId : j.user_id === undefined || j.user_id === null));
+            if (!job) {
+                return false;
+            }
+            job.status = status;
+            job.updated_at = new Date().toISOString();
+            if (status === 'completed' || status === 'failed') {
+                job.completed_at = new Date().toISOString();
+                if (exitCode !== undefined) {
+                    job.exit_code = exitCode;
+                }
+            }
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error updating job status:', error);
+            return false;
+        }
+    }
+    /**
+     * Get active jobs
+     */
+    async getActiveJobs() {
+        try {
+            return this.data.shell_jobs
+                .filter(job => ['running', 'stopped', 'completed', 'failed'].includes(job.status) &&
+                (this.userId ? job.user_id === this.userId : job.user_id === undefined || job.user_id === null))
+                .sort((a, b) => {
+                const timeA = new Date(a.created_at || 0).getTime();
+                const timeB = new Date(b.created_at || 0).getTime();
+                return timeB - timeA;
+            });
+        }
+        catch (error) {
+            console.error('Error getting active jobs:', error);
+            return [];
+        }
+    }
+    /**
+     * Save shell configuration
+     */
+    async saveConfiguration(config) {
+        try {
+            // Find existing config
+            const existingIndex = this.data.shell_configuration.findIndex(c => c.user_id === (this.userId || null) &&
+                c.config_key === config.config_key);
+            const newConfig = {
+                ...config,
+                id: existingIndex >= 0 ? this.data.shell_configuration[existingIndex].id : this.generateId(),
+                user_id: this.userId,
+                created_at: existingIndex >= 0 ? this.data.shell_configuration[existingIndex].created_at : new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            if (existingIndex >= 0) {
+                this.data.shell_configuration[existingIndex] = newConfig;
+            }
+            else {
+                this.data.shell_configuration.push(newConfig);
+            }
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error saving configuration:', error);
+            return false;
+        }
+    }
+    /**
+     * Get shell configuration
+     */
+    async getConfiguration(key) {
+        try {
+            let filtered = this.data.shell_configuration.filter(config => this.userId ? config.user_id === this.userId : config.user_id === undefined || config.user_id === null);
+            if (key) {
+                filtered = filtered.filter(config => config.config_key === key);
+            }
+            return filtered;
+        }
+        catch (error) {
+            console.error('Error getting configuration:', error);
+            return [];
+        }
+    }
+    /**
+     * Save shell alias
+     */
+    async saveAlias(alias) {
+        try {
+            const existingIndex = this.data.shell_aliases.findIndex(a => a.user_id === (this.userId || null) &&
+                a.alias_name === alias.alias_name);
+            const newAlias = {
+                ...alias,
+                id: existingIndex >= 0 ? this.data.shell_aliases[existingIndex].id : this.generateId(),
+                user_id: this.userId,
+                created_at: existingIndex >= 0 ? this.data.shell_aliases[existingIndex].created_at : new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            if (existingIndex >= 0) {
+                this.data.shell_aliases[existingIndex] = newAlias;
+            }
+            else {
+                this.data.shell_aliases.push(newAlias);
+            }
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error saving alias:', error);
+            return false;
+        }
+    }
+    /**
+     * Get shell aliases
+     */
+    async getAliases() {
+        try {
+            return this.data.shell_aliases.filter(alias => alias.is_active &&
+                (this.userId ? alias.user_id === this.userId : alias.user_id === undefined || alias.user_id === null));
+        }
+        catch (error) {
+            console.error('Error getting aliases:', error);
+            return [];
+        }
+    }
+    /**
+     * Save shell function
+     */
+    async saveFunction(func) {
+        try {
+            const existingIndex = this.data.shell_functions.findIndex(f => f.user_id === (this.userId || null) &&
+                f.function_name === func.function_name);
+            const newFunc = {
+                ...func,
+                id: existingIndex >= 0 ? this.data.shell_functions[existingIndex].id : this.generateId(),
+                user_id: this.userId,
+                created_at: existingIndex >= 0 ? this.data.shell_functions[existingIndex].created_at : new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            if (existingIndex >= 0) {
+                this.data.shell_functions[existingIndex] = newFunc;
+            }
+            else {
+                this.data.shell_functions.push(newFunc);
+            }
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error saving function:', error);
+            return false;
+        }
+    }
+    /**
+     * Get shell functions
+     */
+    async getFunctions() {
+        try {
+            return this.data.shell_functions.filter(func => func.is_active &&
+                (this.userId ? func.user_id === this.userId : func.user_id === undefined || func.user_id === null));
+        }
+        catch (error) {
+            console.error('Error getting functions:', error);
+            return [];
+        }
+    }
+    /**
+     * Start a new shell session
+     */
+    async startSession(workingDirectory, environmentVariables) {
+        try {
+            const newSession = {
+                id: this.generateId(),
+                user_id: this.userId,
+                session_id: this.sessionId,
+                hostname: os.hostname(),
+                working_directory: workingDirectory,
+                environment_variables: environmentVariables,
+                started_at: new Date().toISOString(),
+                is_active: true,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+            };
+            this.data.shell_sessions.push(newSession);
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error starting session:', error);
+            return false;
+        }
+    }
+    /**
+     * End the current shell session
+     */
+    async endSession() {
+        try {
+            const session = this.data.shell_sessions.find(s => s.session_id === this.sessionId &&
+                (this.userId ? s.user_id === this.userId : s.user_id === undefined || s.user_id === null));
+            if (!session) {
+                return false;
+            }
+            session.ended_at = new Date().toISOString();
+            session.is_active = false;
+            session.updated_at = new Date().toISOString();
+            this.markDirty();
+            return true;
+        }
+        catch (error) {
+            console.error('Error ending session:', error);
+            return false;
+        }
+    }
+    /**
+     * Test storage connectivity (always succeeds for local storage)
+     */
+    async testConnection() {
+        try {
+            await fs.access(this.dataDir);
+            return true;
+        }
+        catch (_error) {
+            return false;
+        }
+    }
+    /**
+     * Get session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get latest rows from all tables
+     */
+    async getLatestRows(limit = 5) {
+        const result = {};
+        try {
+            // Get latest shell history entries
+            const history = this.data.shell_history
+                .filter(entry => this.userId ? entry.user_id === this.userId : entry.user_id === undefined || entry.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_history = history;
+            // Get latest shell jobs
+            const jobs = this.data.shell_jobs
+                .filter(job => this.userId ? job.user_id === this.userId : job.user_id === undefined || job.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_jobs = jobs;
+            // Get latest shell configuration
+            const config = this.data.shell_configuration
+                .filter(cfg => this.userId ? cfg.user_id === this.userId : cfg.user_id === undefined || cfg.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_configuration = config;
+            // Get latest shell sessions
+            const sessions = this.data.shell_sessions
+                .filter(session => this.userId ? session.user_id === this.userId : session.user_id === undefined || session.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_sessions = sessions;
+            // Get latest shell aliases
+            const aliases = this.data.shell_aliases
+                .filter(alias => this.userId ? alias.user_id === this.userId : alias.user_id === undefined || alias.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_aliases = aliases;
+            // Get latest shell functions
+            const functions = this.data.shell_functions
+                .filter(func => this.userId ? func.user_id === this.userId : func.user_id === undefined || func.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_functions = functions;
+            // Get latest shell completions
+            const completions = this.data.shell_completions
+                .filter(comp => this.userId ? comp.user_id === this.userId : comp.user_id === undefined || comp.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+            result.shell_completions = completions;
+            return result;
+        }
+        catch (error) {
+            console.error('Error getting latest rows:', error);
+            return {};
+        }
+    }
+    /**
+     * Get latest rows from a specific table
+     */
+    async getLatestRowsFromTable(tableName, limit = 5) {
+        try {
+            const validTables = [
+                'shell_history',
+                'shell_jobs',
+                'shell_configuration',
+                'shell_sessions',
+                'shell_aliases',
+                'shell_functions',
+                'shell_completions',
+            ];
+            if (!validTables.includes(tableName)) {
+                throw new Error(`Invalid table name: ${tableName}`);
+            }
+            const table = this.data[tableName];
+            return table
+                .filter(row => this.userId ? row.user_id === this.userId : row.user_id === undefined || row.user_id === null)
+                .sort((a, b) => new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime())
+                .slice(0, limit);
+        }
+        catch (error) {
+            console.error(`Error getting latest rows from ${tableName}:`, error);
+            return [];
+        }
+    }
+}
+export default LocalStorageAdapter;

package/dist/lib/saas-audit.js

@@ -0,0 +1,213 @@
+/**
+ * LSH SaaS Audit Logging Service
+ * Comprehensive audit trail for all actions
+ */
+import { getSupabaseClient } from './supabase-client.js';
+/**
+ * Audit Logger Service
+ */
+export class AuditLogger {
+    supabase = getSupabaseClient();
+    /**
+     * Log an audit event
+     */
+    async log(input) {
+        try {
+            const { error } = await this.supabase.from('audit_logs').insert({
+                organization_id: input.organizationId,
+                team_id: input.teamId || null,
+                user_id: input.userId || null,
+                user_email: input.userEmail || null,
+                action: input.action,
+                resource_type: input.resourceType,
+                resource_id: input.resourceId || null,
+                ip_address: input.ipAddress || null,
+                user_agent: input.userAgent || null,
+                metadata: input.metadata || {},
+                old_value: input.oldValue || null,
+                new_value: input.newValue || null,
+                timestamp: new Date().toISOString(),
+            });
+            if (error) {
+                console.error('Failed to write audit log:', error);
+                // Don't throw - audit logging should not break the main operation
+            }
+        }
+        catch (error) {
+            console.error('Audit logging error:', error);
+            // Don't throw - audit logging should not break the main operation
+        }
+    }
+    /**
+     * Get audit logs for organization
+     */
+    async getOrganizationLogs(organizationId, options = {}) {
+        let query = this.supabase
+            .from('audit_logs')
+            .select('*', { count: 'exact' })
+            .eq('organization_id', organizationId);
+        if (options.startDate) {
+            query = query.gte('timestamp', options.startDate.toISOString());
+        }
+        if (options.endDate) {
+            query = query.lte('timestamp', options.endDate.toISOString());
+        }
+        if (options.action) {
+            query = query.eq('action', options.action);
+        }
+        if (options.userId) {
+            query = query.eq('user_id', options.userId);
+        }
+        if (options.teamId) {
+            query = query.eq('team_id', options.teamId);
+        }
+        query = query.order('timestamp', { ascending: false });
+        if (options.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options.offset) {
+            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
+        }
+        const { data, count, error } = await query;
+        if (error) {
+            throw new Error(`Failed to get audit logs: ${error.message}`);
+        }
+        return {
+            logs: (data || []).map(this.mapDbLogToLog),
+            total: count || 0,
+        };
+    }
+    /**
+     * Get audit logs for a specific resource
+     */
+    async getResourceLogs(organizationId, resourceType, resourceId, limit = 50) {
+        const { data, error } = await this.supabase
+            .from('audit_logs')
+            .select('*')
+            .eq('organization_id', organizationId)
+            .eq('resource_type', resourceType)
+            .eq('resource_id', resourceId)
+            .order('timestamp', { ascending: false })
+            .limit(limit);
+        if (error) {
+            throw new Error(`Failed to get resource logs: ${error.message}`);
+        }
+        return (data || []).map(this.mapDbLogToLog);
+    }
+    /**
+     * Get audit logs for a team
+     */
+    async getTeamLogs(teamId, options = {}) {
+        let query = this.supabase
+            .from('audit_logs')
+            .select('*', { count: 'exact' })
+            .eq('team_id', teamId);
+        if (options.startDate) {
+            query = query.gte('timestamp', options.startDate.toISOString());
+        }
+        if (options.endDate) {
+            query = query.lte('timestamp', options.endDate.toISOString());
+        }
+        query = query.order('timestamp', { ascending: false });
+        if (options.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options.offset) {
+            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
+        }
+        const { data, count, error } = await query;
+        if (error) {
+            throw new Error(`Failed to get team logs: ${error.message}`);
+        }
+        return {
+            logs: (data || []).map(this.mapDbLogToLog),
+            total: count || 0,
+        };
+    }
+    /**
+     * Get audit logs for a user
+     */
+    async getUserLogs(userId, options = {}) {
+        let query = this.supabase
+            .from('audit_logs')
+            .select('*', { count: 'exact' })
+            .eq('user_id', userId);
+        if (options.startDate) {
+            query = query.gte('timestamp', options.startDate.toISOString());
+        }
+        if (options.endDate) {
+            query = query.lte('timestamp', options.endDate.toISOString());
+        }
+        query = query.order('timestamp', { ascending: false });
+        if (options.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options.offset) {
+            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
+        }
+        const { data, count, error } = await query;
+        if (error) {
+            throw new Error(`Failed to get user logs: ${error.message}`);
+        }
+        return {
+            logs: (data || []).map(this.mapDbLogToLog),
+            total: count || 0,
+        };
+    }
+    /**
+     * Delete old audit logs (for retention policy)
+     */
+    async deleteOldLogs(organizationId, retentionDays) {
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
+        const { count, error } = await this.supabase
+            .from('audit_logs')
+            .delete({ count: 'exact' })
+            .eq('organization_id', organizationId)
+            .lt('timestamp', cutoffDate.toISOString());
+        if (error) {
+            throw new Error(`Failed to delete old logs: ${error.message}`);
+        }
+        return count || 0;
+    }
+    /**
+     * Map database log to AuditLog type
+     */
+    mapDbLogToLog(dbLog) {
+        return {
+            id: dbLog.id,
+            organizationId: dbLog.organization_id,
+            teamId: dbLog.team_id,
+            userId: dbLog.user_id,
+            userEmail: dbLog.user_email,
+            action: dbLog.action,
+            resourceType: dbLog.resource_type,
+            resourceId: dbLog.resource_id,
+            ipAddress: dbLog.ip_address,
+            userAgent: dbLog.user_agent,
+            metadata: dbLog.metadata || {},
+            oldValue: dbLog.old_value,
+            newValue: dbLog.new_value,
+            timestamp: new Date(dbLog.timestamp),
+        };
+    }
+}
+/**
+ * Singleton instance
+ */
+export const auditLogger = new AuditLogger();
+/**
+ * Helper function to extract IP from request
+ */
+export function getIpFromRequest(req) {
+    return (req.headers['x-forwarded-for']?.split(',')[0].trim() ||
+        req.headers['x-real-ip'] ||
+        req.connection?.remoteAddress ||
+        req.socket?.remoteAddress);
+}
+/**
+ * Helper function to extract user agent from request
+ */
+export function getUserAgentFromRequest(req) {
+    return req.headers['user-agent'];
+}