lsh-framework 1.2.0 → 1.2.1

package/dist/app.js

@@ -1,33 +0,0 @@
-import { Command } from 'commander';
-import { init_lib } from './services/lib/lib.js';
-import { init_ishell } from './services/shell/shell.js';
-import { init_supabase } from './services/supabase/supabase.js';
-import { init_daemon } from './services/daemon/daemon.js';
-import { init_cron } from './services/cron/cron.js';
-const program = new Command();
-program
-    .version('0.0.0')
-    .description('lsh | extensible cli client.')
-    .name('lsh');
-init_ishell(program);
-init_lib(program);
-init_supabase(program);
-init_daemon(program);
-init_cron(program);
-// Show help without error when no command is provided
-program.configureHelp({
-    showGlobalOptions: true,
-});
-// Set exitOverride to prevent Commander from calling process.exit
-program.exitOverride((err) => {
-    // If showing help, exit cleanly
-    if (err.code === 'commander.helpDisplayed' || err.code === 'commander.help') {
-        process.exit(0);
-    }
-    throw err;
-});
-program.parse(process.argv);
-// If no command was provided, show help and exit cleanly
-if (process.argv.length <= 2) {
-    program.help({ error: false });
-}

package/dist/cicd/analytics.js

@@ -1,261 +0,0 @@
-import { createClient } from '@supabase/supabase-js';
-import Redis from 'ioredis';
-const SUPABASE_URL = process.env.SUPABASE_URL;
-const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY;
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-// Future use for Supabase integration - keeping for planned features
-const _supabase = SUPABASE_URL && SUPABASE_ANON_KEY ?
-    createClient(SUPABASE_URL, SUPABASE_ANON_KEY) : null;
-const redis = new Redis(REDIS_URL);
-// Calculate moving average for trend smoothing - utility function for future features
-function _movingAverage(data, window) {
-    const result = [];
-    for (let i = 0; i < data.length; i++) {
-        const start = Math.max(0, i - window + 1);
-        const subset = data.slice(start, i + 1);
-        const avg = subset.reduce((a, b) => a + b, 0) / subset.length;
-        result.push(avg);
-    }
-    return result;
-}
-// Detect anomalies using Z-score
-function detectAnomalies(data, threshold = 2.5) {
-    const mean = data.reduce((a, b) => a + b, 0) / data.length;
-    const variance = data.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / data.length;
-    const stdDev = Math.sqrt(variance);
-    return data.map((value, index) => {
-        const zScore = Math.abs((value - mean) / stdDev);
-        return zScore > threshold ? index : -1;
-    }).filter(index => index !== -1);
-}
-// Linear regression for predictions
-function linearRegression(data) {
-    const n = data.length;
-    const x = Array.from({ length: n }, (_, i) => i);
-    const sumX = x.reduce((a, b) => a + b, 0);
-    const sumY = data.reduce((a, b) => a + b, 0);
-    const sumXY = x.reduce((sum, xi, i) => sum + xi * data[i], 0);
-    const sumX2 = x.reduce((sum, xi) => sum + xi * xi, 0);
-    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
-    const intercept = (sumY - slope * sumX) / n;
-    return { slope, intercept };
-}
-export async function generateTrendAnalysis(days = 30) {
-    const trends = [];
-    const endDate = new Date();
-    const startDate = new Date();
-    startDate.setDate(endDate.getDate() - days);
-    for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
-        const dateStr = d.toISOString().split('T')[0];
-        const key = `metrics:${dateStr}`;
-        const metrics = await redis.hgetall(key);
-        const durations = await redis.lrange(`durations:${dateStr}`, 0, -1);
-        const totalBuilds = parseInt(metrics.total_builds || '0');
-        const successfulBuilds = parseInt(metrics.successful_builds || '0');
-        const failedBuilds = parseInt(metrics.failed_builds || '0');
-        const avgDuration = durations.length > 0
-            ? durations.reduce((sum, d) => sum + parseInt(d), 0) / durations.length
-            : 0;
-        trends.push({
-            date: dateStr,
-            totalBuilds,
-            successRate: totalBuilds > 0 ? (successfulBuilds / totalBuilds) * 100 : 0,
-            avgDuration: avgDuration / 1000 / 60, // Convert to minutes
-            failureRate: totalBuilds > 0 ? (failedBuilds / totalBuilds) * 100 : 0
-        });
-    }
-    return trends;
-}
-export async function detectBuildAnomalies(trends) {
-    const anomalies = [];
-    // Extract metrics
-    const durations = trends.map(t => t.avgDuration);
-    const failureRates = trends.map(t => t.failureRate);
-    const _buildCounts = trends.map(t => t.totalBuilds);
-    // Detect duration anomalies
-    const durationAnomalies = detectAnomalies(durations);
-    durationAnomalies.forEach(index => {
-        const mean = durations.reduce((a, b) => a + b, 0) / durations.length;
-        const stdDev = Math.sqrt(durations.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / durations.length);
-        anomalies.push({
-            timestamp: trends[index].date,
-            type: 'duration',
-            severity: durations[index] > mean + 3 * stdDev ? 'critical' : 'warning',
-            description: `Build duration significantly higher than average`,
-            value: durations[index],
-            expectedRange: {
-                min: Math.max(0, mean - 2 * stdDev),
-                max: mean + 2 * stdDev
-            }
-        });
-    });
-    // Detect failure rate anomalies
-    const failureAnomalies = detectAnomalies(failureRates, 2);
-    failureAnomalies.forEach(index => {
-        if (failureRates[index] > 20) { // Only flag if failure rate > 20%
-            anomalies.push({
-                timestamp: trends[index].date,
-                type: 'failure_rate',
-                severity: failureRates[index] > 50 ? 'critical' : 'warning',
-                description: `High failure rate detected`,
-                value: failureRates[index],
-                expectedRange: { min: 0, max: 20 }
-            });
-        }
-    });
-    return anomalies;
-}
-export async function generateInsights(trends) {
-    const insights = [];
-    if (trends.length < 7)
-        return insights;
-    // Compare last 7 days with previous 7 days
-    const recentWeek = trends.slice(-7);
-    const previousWeek = trends.slice(-14, -7);
-    const recentAvgSuccess = recentWeek.reduce((sum, t) => sum + t.successRate, 0) / 7;
-    const prevAvgSuccess = previousWeek.reduce((sum, t) => sum + t.successRate, 0) / 7;
-    const successChange = recentAvgSuccess - prevAvgSuccess;
-    if (Math.abs(successChange) > 5) {
-        insights.push({
-            type: successChange > 0 ? 'improvement' : 'degradation',
-            title: `Success Rate ${successChange > 0 ? 'Improved' : 'Degraded'}`,
-            description: `Success rate changed by ${Math.abs(successChange).toFixed(1)}% compared to previous week`,
-            metric: 'success_rate',
-            change: successChange,
-            impact: Math.abs(successChange) > 15 ? 'high' : Math.abs(successChange) > 10 ? 'medium' : 'low'
-        });
-    }
-    // Analyze build duration trends
-    const recentAvgDuration = recentWeek.reduce((sum, t) => sum + t.avgDuration, 0) / 7;
-    const prevAvgDuration = previousWeek.reduce((sum, t) => sum + t.avgDuration, 0) / 7;
-    const durationChange = ((recentAvgDuration - prevAvgDuration) / prevAvgDuration) * 100;
-    if (Math.abs(durationChange) > 10) {
-        insights.push({
-            type: durationChange < 0 ? 'improvement' : 'degradation',
-            title: `Build Duration ${durationChange < 0 ? 'Improved' : 'Increased'}`,
-            description: `Average build duration changed by ${Math.abs(durationChange).toFixed(1)}%`,
-            metric: 'duration',
-            change: durationChange,
-            impact: Math.abs(durationChange) > 30 ? 'high' : Math.abs(durationChange) > 20 ? 'medium' : 'low'
-        });
-    }
-    // Identify patterns
-    const dailyBuilds = trends.map(t => t.totalBuilds);
-    const weekdays = trends.map(t => new Date(t.date).getDay());
-    const weekdayAvg = Array(7).fill(0).map((_, day) => {
-        const dayBuilds = dailyBuilds.filter((_, i) => weekdays[i] === day);
-        return dayBuilds.reduce((a, b) => a + b, 0) / dayBuilds.length;
-    });
-    const peakDay = weekdayAvg.indexOf(Math.max(...weekdayAvg));
-    const lowDay = weekdayAvg.indexOf(Math.min(...weekdayAvg));
-    const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-    insights.push({
-        type: 'pattern',
-        title: 'Weekly Build Pattern Detected',
-        description: `Most builds occur on ${dayNames[peakDay]}, least on ${dayNames[lowDay]}`,
-        metric: 'frequency',
-        change: 0,
-        impact: 'low'
-    });
-    return insights;
-}
-export async function predictNextPeriod(trends) {
-    const predictions = [];
-    if (trends.length < 14)
-        return predictions;
-    // Predict success rate
-    const successRates = trends.map(t => t.successRate);
-    const successRegression = linearRegression(successRates.slice(-14));
-    const predictedSuccess = successRegression.slope * successRates.length + successRegression.intercept;
-    predictions.push({
-        metric: 'success_rate',
-        nextPeriod: 'next_7_days',
-        predictedValue: Math.max(0, Math.min(100, predictedSuccess)),
-        confidence: 0.75,
-        trend: successRegression.slope > 1 ? 'improving' :
-            successRegression.slope < -1 ? 'degrading' : 'stable'
-    });
-    // Predict build volume
-    const buildCounts = trends.map(t => t.totalBuilds);
-    const volumeRegression = linearRegression(buildCounts.slice(-14));
-    const predictedVolume = volumeRegression.slope * buildCounts.length + volumeRegression.intercept;
-    predictions.push({
-        metric: 'build_volume',
-        nextPeriod: 'next_day',
-        predictedValue: Math.max(0, Math.round(predictedVolume)),
-        confidence: 0.7,
-        trend: volumeRegression.slope > 5 ? 'improving' :
-            volumeRegression.slope < -5 ? 'degrading' : 'stable'
-    });
-    return predictions;
-}
-export async function calculateCostAnalysis(trends) {
-    // Estimate costs based on build minutes (GitHub Actions pricing model)
-    const COST_PER_MINUTE = 0.008; // $0.008 per minute for Linux runners
-    const totalMinutes = trends.reduce((sum, t) => sum + (t.totalBuilds * t.avgDuration), 0);
-    const totalCost = totalMinutes * COST_PER_MINUTE;
-    const totalBuilds = trends.reduce((sum, t) => sum + t.totalBuilds, 0);
-    const savingsOpportunities = [];
-    // Identify savings opportunities
-    const avgDuration = totalMinutes / totalBuilds;
-    if (avgDuration > 10) {
-        savingsOpportunities.push('Consider optimizing long-running builds (>10 minutes average)');
-    }
-    const avgFailureRate = trends.reduce((sum, t) => sum + t.failureRate, 0) / trends.length;
-    if (avgFailureRate > 15) {
-        const wastedCost = (totalCost * avgFailureRate / 100);
-        savingsOpportunities.push(`Reduce failure rate to save ~$${wastedCost.toFixed(2)}/month`);
-    }
-    // Check for off-peak opportunities
-    const peakHourBuilds = trends.filter(t => {
-        const hour = new Date(t.date).getHours();
-        return hour >= 9 && hour <= 17;
-    });
-    if (peakHourBuilds.length > trends.length * 0.7) {
-        savingsOpportunities.push('Schedule non-critical builds during off-peak hours');
-    }
-    return {
-        totalCost,
-        costPerBuild: totalBuilds > 0 ? totalCost / totalBuilds : 0,
-        costByPlatform: {
-            github: totalCost * 0.6, // Estimate based on usage
-            gitlab: totalCost * 0.25,
-            jenkins: totalCost * 0.15
-        },
-        savingsOpportunities
-    };
-}
-export async function generateAnalyticsReport(period = 'weekly') {
-    const days = period === 'daily' ? 1 : period === 'weekly' ? 7 : 30;
-    const trends = await generateTrendAnalysis(days);
-    const [insights, anomalies, predictions, costAnalysis] = await Promise.all([
-        generateInsights(trends),
-        detectBuildAnomalies(trends),
-        predictNextPeriod(trends),
-        calculateCostAnalysis(trends)
-    ]);
-    return {
-        period,
-        startDate: trends[0]?.date || new Date().toISOString(),
-        endDate: trends[trends.length - 1]?.date || new Date().toISOString(),
-        trends,
-        insights,
-        anomalies,
-        predictions,
-        costAnalysis
-    };
-}
-// Export functions for bottleneck detection
-export async function detectBottlenecks() {
-    // Analyze stage durations to find slowest parts
-    const stageData = await redis.hgetall('stage_durations');
-    const bottlenecks = Object.entries(stageData)
-        .map(([stage, duration]) => ({
-        stage,
-        avgDuration: parseInt(duration),
-        impact: 'high'
-    }))
-        .sort((a, b) => b.avgDuration - a.avgDuration)
-        .slice(0, 5);
-    return bottlenecks;
-}

package/dist/cicd/auth.js

@@ -1,269 +0,0 @@
-import jwt from 'jsonwebtoken';
-import bcrypt from 'bcrypt';
-const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-in-production';
-const TOKEN_EXPIRY = '24h';
-export class AuthService {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-        this.initializeSchema();
-    }
-    async initializeSchema() {
-        const query = `
-      CREATE TABLE IF NOT EXISTS users (
-        id SERIAL PRIMARY KEY,
-        email VARCHAR(255) UNIQUE NOT NULL,
-        name VARCHAR(255) NOT NULL,
-        password_hash VARCHAR(255) NOT NULL,
-        role VARCHAR(50) NOT NULL DEFAULT 'viewer',
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        last_login TIMESTAMP,
-        is_active BOOLEAN DEFAULT true
-      );
-
-      CREATE TABLE IF NOT EXISTS api_keys (
-        id SERIAL PRIMARY KEY,
-        user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
-        key_hash VARCHAR(255) UNIQUE NOT NULL,
-        name VARCHAR(255),
-        permissions JSONB,
-        last_used TIMESTAMP,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        expires_at TIMESTAMP
-      );
-
-      CREATE TABLE IF NOT EXISTS audit_logs (
-        id SERIAL PRIMARY KEY,
-        user_id INTEGER REFERENCES users(id),
-        action VARCHAR(255) NOT NULL,
-        resource VARCHAR(255),
-        details JSONB,
-        ip_address VARCHAR(45),
-        user_agent TEXT,
-        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_audit_logs_user ON audit_logs(user_id);
-      CREATE INDEX IF NOT EXISTS idx_audit_logs_timestamp ON audit_logs(timestamp);
-    `;
-        try {
-            await this.pool.query(query);
-        }
-        catch (error) {
-            console.error('Error initializing auth schema:', error);
-        }
-    }
-    async register(email, password, name, role = 'viewer') {
-        const passwordHash = await bcrypt.hash(password, 10);
-        const query = `
-      INSERT INTO users (email, name, password_hash, role)
-      VALUES ($1, $2, $3, $4)
-      RETURNING id, email, name, role, created_at
-    `;
-        try {
-            const result = await this.pool.query(query, [email, name, passwordHash, role]);
-            return result.rows[0];
-        }
-        catch (error) {
-            if (error.code === '23505') { // Unique constraint violation
-                throw new Error('User with this email already exists');
-            }
-            throw error;
-        }
-    }
-    async login(email, password) {
-        const query = `
-      SELECT id, email, name, role, password_hash, created_at
-      FROM users
-      WHERE email = $1 AND is_active = true
-    `;
-        const result = await this.pool.query(query, [email]);
-        if (result.rows.length === 0) {
-            throw new Error('Invalid credentials');
-        }
-        const user = result.rows[0];
-        const isValid = await bcrypt.compare(password, user.password_hash);
-        if (!isValid) {
-            throw new Error('Invalid credentials');
-        }
-        // Update last login
-        await this.pool.query('UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = $1', [user.id]);
-        const token = this.generateToken(user);
-        delete user.password_hash;
-        return { user, token };
-    }
-    generateToken(user) {
-        const payload = {
-            userId: user.id,
-            email: user.email,
-            role: user.role
-        };
-        return jwt.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
-    }
-    verifyToken(token) {
-        try {
-            return jwt.verify(token, JWT_SECRET);
-        }
-        catch (_error) {
-            throw new Error('Invalid or expired token');
-        }
-    }
-    async generateApiKey(userId, name, permissions) {
-        const apiKey = this.generateRandomKey();
-        const keyHash = await bcrypt.hash(apiKey, 10);
-        const query = `
-      INSERT INTO api_keys (user_id, key_hash, name, permissions)
-      VALUES ($1, $2, $3, $4)
-      RETURNING id
-    `;
-        await this.pool.query(query, [userId, keyHash, name, permissions || {}]);
-        return apiKey;
-    }
-    generateRandomKey() {
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        let key = 'cicd_';
-        for (let i = 0; i < 32; i++) {
-            key += chars.charAt(Math.floor(Math.random() * chars.length));
-        }
-        return key;
-    }
-    async verifyApiKey(apiKey) {
-        const query = `
-      SELECT ak.*, u.email, u.role
-      FROM api_keys ak
-      JOIN users u ON ak.user_id = u.id
-      WHERE u.is_active = true
-      AND (ak.expires_at IS NULL OR ak.expires_at > CURRENT_TIMESTAMP)
-    `;
-        const result = await this.pool.query(query);
-        for (const row of result.rows) {
-            const isValid = await bcrypt.compare(apiKey, row.key_hash);
-            if (isValid) {
-                // Update last used
-                await this.pool.query('UPDATE api_keys SET last_used = CURRENT_TIMESTAMP WHERE id = $1', [row.id]);
-                return {
-                    userId: row.user_id,
-                    email: row.email,
-                    role: row.role
-                };
-            }
-        }
-        return null;
-    }
-    async logAudit(userId, action, resource, details, req) {
-        const query = `
-      INSERT INTO audit_logs (user_id, action, resource, details, ip_address, user_agent)
-      VALUES ($1, $2, $3, $4, $5, $6)
-    `;
-        const ipAddress = req?.ip || req?.socket?.remoteAddress;
-        const userAgent = req?.headers['user-agent'];
-        await this.pool.query(query, [
-            userId,
-            action,
-            resource,
-            details || {},
-            ipAddress,
-            userAgent
-        ]);
-    }
-}
-// Middleware for authentication
-export function authenticate(authService) {
-    return async (req, res, next) => {
-        try {
-            const authHeader = req.headers.authorization;
-            if (!authHeader) {
-                return res.status(401).json({ error: 'No authorization header' });
-            }
-            let user = null;
-            if (authHeader.startsWith('Bearer ')) {
-                // JWT token authentication
-                const token = authHeader.substring(7);
-                user = authService.verifyToken(token);
-            }
-            else if (authHeader.startsWith('ApiKey ')) {
-                // API key authentication
-                const apiKey = authHeader.substring(7);
-                user = await authService.verifyApiKey(apiKey);
-            }
-            if (!user) {
-                return res.status(401).json({ error: 'Invalid authentication credentials' });
-            }
-            req.user = user;
-            next();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Authentication failed';
-            return res.status(401).json({ error: message });
-        }
-    };
-}
-// Role-based access control middleware
-export function authorize(...allowedRoles) {
-    return (req, res, next) => {
-        if (!req.user) {
-            return res.status(401).json({ error: 'Authentication required' });
-        }
-        if (!allowedRoles.includes(req.user.role)) {
-            return res.status(403).json({ error: 'Insufficient permissions' });
-        }
-        next();
-    };
-}
-// Permission-based middleware
-export function requirePermission(permission) {
-    return (req, res, next) => {
-        if (!req.user) {
-            return res.status(401).json({ error: 'Authentication required' });
-        }
-        // Admin has all permissions
-        if (req.user.role === 'admin') {
-            return next();
-        }
-        // Check specific permissions based on role
-        const rolePermissions = {
-            developer: [
-                'pipelines.view',
-                'pipelines.trigger',
-                'metrics.view',
-                'analytics.view',
-                'alerts.view'
-            ],
-            viewer: [
-                'pipelines.view',
-                'metrics.view',
-                'analytics.view'
-            ]
-        };
-        const userPermissions = rolePermissions[req.user.role] || [];
-        if (!userPermissions.includes(permission)) {
-            return res.status(403).json({ error: `Permission '${permission}' required` });
-        }
-        next();
-    };
-}
-export function rateLimit(options) {
-    const requests = new Map();
-    return (req, res, next) => {
-        const key = req.user?.userId?.toString() || req.ip || 'anonymous';
-        const now = Date.now();
-        const record = requests.get(key);
-        if (!record || now > record.resetTime) {
-            requests.set(key, {
-                count: 1,
-                resetTime: now + options.windowMs
-            });
-            return next();
-        }
-        if (record.count >= options.max) {
-            const retryAfter = Math.ceil((record.resetTime - now) / 1000);
-            res.setHeader('Retry-After', retryAfter);
-            return res.status(429).json({
-                error: 'Too many requests',
-                retryAfter
-            });
-        }
-        record.count++;
-        next();
-    };
-}