lsh-framework 0.5.4

package/dist/services/log-file-extractor.js

@@ -0,0 +1,170 @@
+/**
+ * Log File Extractor
+ * Utility for extracting relevant log entries from log files
+ * based on patterns and filters.
+ */
+import fs from 'fs/promises';
+import readline from 'readline';
+/**
+ * Extract relevant log entries from a log file
+ */
+export async function extractRelevantLogs(filePath, options) {
+    const { pattern, maxLines = 1000, tailLines, contextBefore = 0, contextAfter = 0, } = options;
+    // Read the file
+    const fileHandle = await fs.open(filePath, 'r');
+    const stream = fileHandle.createReadStream();
+    const rl = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    const allLines = [];
+    const matchingIndices = [];
+    const result = [];
+    // If tailLines is specified, we need to buffer all lines first
+    if (tailLines !== undefined) {
+        for await (const line of rl) {
+            allLines.push(line);
+        }
+        // Only process last N lines
+        const startIndex = Math.max(0, allLines.length - tailLines);
+        const linesToProcess = allLines.slice(startIndex);
+        // Find matching lines
+        linesToProcess.forEach((line, index) => {
+            if (pattern.test(line)) {
+                matchingIndices.push(startIndex + index);
+            }
+        });
+    }
+    else {
+        // Process line by line without buffering all
+        let lineIndex = 0;
+        for await (const line of rl) {
+            allLines.push(line);
+            if (pattern.test(line)) {
+                matchingIndices.push(lineIndex);
+            }
+            lineIndex++;
+            // Stop if we have enough matches (considering context)
+            if (matchingIndices.length >= maxLines) {
+                break;
+            }
+        }
+    }
+    await fileHandle.close();
+    // Extract lines with context
+    const includedIndices = new Set();
+    for (const matchIndex of matchingIndices) {
+        if (result.length >= maxLines) {
+            break;
+        }
+        // Calculate range of lines to include
+        const startIndex = Math.max(0, matchIndex - contextBefore);
+        const endIndex = Math.min(allLines.length - 1, matchIndex + contextAfter);
+        for (let i = startIndex; i <= endIndex; i++) {
+            if (!includedIndices.has(i)) {
+                result.push(allLines[i]);
+                includedIndices.add(i);
+            }
+        }
+    }
+    return result.slice(0, maxLines);
+}
+/**
+ * Extract error logs from a file
+ */
+export async function extractErrors(filePath, options) {
+    return extractRelevantLogs(filePath, {
+        pattern: /ERROR|FATAL|CRITICAL/i,
+        maxLines: 100,
+        contextBefore: 2,
+        contextAfter: 2,
+        ...options,
+    });
+}
+/**
+ * Extract warning logs from a file
+ */
+export async function extractWarnings(filePath, options) {
+    return extractRelevantLogs(filePath, {
+        pattern: /WARN|WARNING/i,
+        maxLines: 100,
+        contextBefore: 1,
+        contextAfter: 1,
+        ...options,
+    });
+}
+/**
+ * Extract logs from the last N minutes
+ */
+export async function extractRecent(filePath, minutes, options) {
+    const now = new Date();
+    const cutoffTime = new Date(now.getTime() - minutes * 60 * 1000);
+    // Common timestamp patterns
+    const timestampPattern = /\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/;
+    return extractRelevantLogs(filePath, {
+        pattern: timestampPattern,
+        maxLines: 1000,
+        ...options,
+    }).then((lines) => {
+        // Filter lines by timestamp
+        return lines.filter((line) => {
+            const match = line.match(timestampPattern);
+            if (match) {
+                try {
+                    const lineTime = new Date(match[0].replace(' ', 'T'));
+                    return lineTime >= cutoffTime;
+                }
+                catch (_error) {
+                    return false;
+                }
+            }
+            return false;
+        });
+    });
+}
+/**
+ * Get summary statistics from a log file
+ */
+export async function getLogStatistics(filePath) {
+    const fileHandle = await fs.open(filePath, 'r');
+    const stream = fileHandle.createReadStream();
+    const rl = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    let totalLines = 0;
+    let errorCount = 0;
+    let warningCount = 0;
+    let infoCount = 0;
+    let debugCount = 0;
+    for await (const line of rl) {
+        totalLines++;
+        if (/ERROR|FATAL|CRITICAL/i.test(line)) {
+            errorCount++;
+        }
+        else if (/WARN|WARNING/i.test(line)) {
+            warningCount++;
+        }
+        else if (/INFO/i.test(line)) {
+            infoCount++;
+        }
+        else if (/DEBUG|TRACE/i.test(line)) {
+            debugCount++;
+        }
+    }
+    await fileHandle.close();
+    return {
+        totalLines,
+        errorCount,
+        warningCount,
+        infoCount,
+        debugCount,
+    };
+}
+export default {
+    extractRelevantLogs,
+    extractErrors,
+    extractWarnings,
+    extractRecent,
+    getLogStatistics,
+};

package/dist/services/secrets/secrets.js

@@ -0,0 +1,94 @@
+/**
+ * Secrets Management Commands
+ * Sync .env files across development environments
+ */
+import SecretsManager from '../../lib/secrets-manager.js';
+export async function init_secrets(program) {
+    const secretsCmd = program
+        .command('secrets')
+        .description('Manage environment secrets across machines');
+    // Push secrets to cloud
+    secretsCmd
+        .command('push')
+        .description('Push local .env to encrypted cloud storage')
+        .option('-f, --file <path>', 'Path to .env file', '.env')
+        .option('-e, --env <name>', 'Environment name (dev/staging/prod)', 'dev')
+        .action(async (options) => {
+        try {
+            const manager = new SecretsManager();
+            await manager.push(options.file, options.env);
+        }
+        catch (error) {
+            console.error('❌ Failed to push secrets:', error.message);
+            process.exit(1);
+        }
+    });
+    // Pull secrets from cloud
+    secretsCmd
+        .command('pull')
+        .description('Pull .env from encrypted cloud storage')
+        .option('-f, --file <path>', 'Path to .env file', '.env')
+        .option('-e, --env <name>', 'Environment name (dev/staging/prod)', 'dev')
+        .action(async (options) => {
+        try {
+            const manager = new SecretsManager();
+            await manager.pull(options.file, options.env);
+        }
+        catch (error) {
+            console.error('❌ Failed to pull secrets:', error.message);
+            process.exit(1);
+        }
+    });
+    // List environments
+    secretsCmd
+        .command('list')
+        .alias('ls')
+        .description('List all stored environments')
+        .action(async () => {
+        try {
+            const manager = new SecretsManager();
+            const envs = await manager.listEnvironments();
+            if (envs.length === 0) {
+                console.log('No environments found. Push your first .env with: lsh secrets push');
+                return;
+            }
+            console.log('\n📦 Available environments:\n');
+            for (const env of envs) {
+                console.log(`  • ${env}`);
+            }
+            console.log();
+        }
+        catch (error) {
+            console.error('❌ Failed to list environments:', error.message);
+            process.exit(1);
+        }
+    });
+    // Show secrets (masked)
+    secretsCmd
+        .command('show')
+        .description('Show secrets for an environment (masked)')
+        .option('-e, --env <name>', 'Environment name', 'dev')
+        .action(async (options) => {
+        try {
+            const manager = new SecretsManager();
+            await manager.show(options.env);
+        }
+        catch (error) {
+            console.error('❌ Failed to show secrets:', error.message);
+            process.exit(1);
+        }
+    });
+    // Generate encryption key
+    secretsCmd
+        .command('key')
+        .description('Generate a new encryption key')
+        .action(async () => {
+        const { randomBytes } = await import('crypto');
+        const key = randomBytes(32).toString('hex');
+        console.log('\n🔑 New encryption key (add to your .env):\n');
+        console.log(`LSH_SECRETS_KEY=${key}\n`);
+        console.log('💡 Tip: Share this key securely with your team to sync secrets.');
+        console.log('    Never commit it to git!\n');
+    });
+}
+export default init_secrets;

package/dist/services/shell/shell.js

@@ -0,0 +1,28 @@
+import { render } from "ink";
+import React from "react";
+import { Terminal } from "../../components/Terminal.js";
+export async function get_ishell(_type = "Jvm", _spec = { function: "currentUsage" }) { }
+export async function init_ishell(program) {
+    await cmd_interactive(program);
+}
+async function cmd_interactive(program) {
+    program
+        .command("repl")
+        .description("lsh interactive shell")
+        .action(async (_type, _action, _spec) => {
+        // Check if raw mode is supported before rendering
+        if (process.stdin.isTTY && process.stdin.setRawMode !== undefined) {
+            render(React.createElement(Terminal, null));
+        }
+        else {
+            console.log('⚠️  Interactive mode not supported');
+            console.log('Raw mode is not supported in this environment.');
+            console.log('To use the interactive REPL, run this command in a proper terminal:');
+            console.log('  npm start repl');
+            console.log('or');
+            console.log('  node dist/app.js repl');
+            console.log('For testing, use the shell lib functions directly in your Node.js code.');
+            process.exit(1);
+        }
+    });
+}

package/dist/services/supabase/supabase-registrar.js

@@ -0,0 +1,367 @@
+/**
+ * Supabase Command Registrar
+ * Registers all Supabase-related CLI commands using BaseCommandRegistrar
+ */
+import { BaseCommandRegistrar } from '../../lib/base-command-registrar.js';
+import { supabaseClient } from '../../lib/supabase-client.js';
+import DatabasePersistence from '../../lib/database-persistence.js';
+import CloudConfigManager from '../../lib/cloud-config-manager.js';
+import { CREATE_TABLES_SQL } from '../../lib/database-schema.js';
+export class SupabaseCommandRegistrar extends BaseCommandRegistrar {
+    constructor() {
+        super('SupabaseService');
+    }
+    async register(program) {
+        const supabaseCmd = this.createCommand(program, 'supabase', 'Supabase database management commands');
+        this.registerConnectionCommands(supabaseCmd);
+        this.registerDataCommands(supabaseCmd);
+        this.registerMLCommands(supabaseCmd);
+    }
+    registerConnectionCommands(supabaseCmd) {
+        // Test connection
+        this.addSubcommand(supabaseCmd, {
+            name: 'test',
+            description: 'Test Supabase database connection',
+            action: async () => {
+                this.logInfo('Testing Supabase connection...');
+                const isConnected = await supabaseClient.testConnection();
+                if (isConnected) {
+                    this.logSuccess('Supabase connection successful');
+                    const info = supabaseClient.getConnectionInfo();
+                    this.logInfo(`Connection info: ${JSON.stringify(info)}`);
+                }
+                else {
+                    throw new Error('Supabase connection failed');
+                }
+            }
+        });
+        // Initialize schema
+        this.addSubcommand(supabaseCmd, {
+            name: 'init',
+            description: 'Initialize database schema',
+            action: async () => {
+                this.logInfo('Initializing database schema...');
+                const persistence = new DatabasePersistence();
+                const success = await persistence.initializeSchema();
+                if (success) {
+                    this.logSuccess('Database schema initialized');
+                    this.logInfo('Note: Run the following SQL in your Supabase dashboard:');
+                    this.logInfo(CREATE_TABLES_SQL);
+                }
+                else {
+                    throw new Error('Failed to initialize schema');
+                }
+            }
+        });
+        // Sync management
+        this.addSubcommand(supabaseCmd, {
+            name: 'sync',
+            description: 'Synchronize data with Supabase',
+            options: [
+                { flags: '-f, --force', description: 'Force full synchronization', defaultValue: false }
+            ],
+            action: async (_options) => {
+                this.logInfo('Synchronizing data with Supabase...');
+                const persistence = new DatabasePersistence();
+                // Test connection first
+                const isConnected = await persistence.testConnection();
+                if (!isConnected) {
+                    throw new Error('Cannot sync - database not available');
+                }
+                // Sync configuration
+                this.logInfo('Syncing configuration...');
+                // Configuration sync is handled automatically by CloudConfigManager
+                // Sync history (this would be done automatically by the enhanced history system)
+                this.logInfo('Syncing history...');
+                // History sync is handled by EnhancedHistorySystem
+                this.logSuccess('Synchronization completed');
+            }
+        });
+    }
+    registerDataCommands(supabaseCmd) {
+        // History management
+        this.addSubcommand(supabaseCmd, {
+            name: 'history',
+            description: 'Manage shell history',
+            options: [
+                { flags: '-l, --list', description: 'List recent history entries', defaultValue: false },
+                { flags: '-c, --count <number>', description: 'Number of entries to show', defaultValue: '10' },
+                { flags: '-s, --search <query>', description: 'Search history entries' }
+            ],
+            action: async (options) => {
+                const persistence = new DatabasePersistence();
+                if (options.list) {
+                    const count = parseInt(options.count);
+                    const entries = await persistence.getHistoryEntries(count);
+                    this.logInfo(`Recent ${entries.length} history entries:`);
+                    entries.forEach((entry, index) => {
+                        const timestamp = new Date(entry.timestamp).toLocaleString();
+                        const exitCode = entry.exit_code ? ` (exit: ${entry.exit_code})` : '';
+                        this.logInfo(`${index + 1}. [${timestamp}] ${entry.command}${exitCode}`);
+                    });
+                }
+                else if (options.search) {
+                    const entries = await persistence.getHistoryEntries(100);
+                    const filtered = entries.filter(entry => entry.command.toLowerCase().includes(options.search.toLowerCase()));
+                    this.logInfo(`Found ${filtered.length} matching entries:`);
+                    filtered.forEach((entry, index) => {
+                        const timestamp = new Date(entry.timestamp).toLocaleString();
+                        this.logInfo(`${index + 1}. [${timestamp}] ${entry.command}`);
+                    });
+                }
+                else {
+                    this.logInfo('Use --list or --search to manage history');
+                }
+            }
+        });
+        // Configuration management
+        this.addSubcommand(supabaseCmd, {
+            name: 'config',
+            description: 'Manage shell configuration',
+            options: [
+                { flags: '-l, --list', description: 'List all configuration', defaultValue: false },
+                { flags: '-g, --get <key>', description: 'Get configuration value' },
+                { flags: '-s, --set <key> <value>', description: 'Set configuration value' },
+                { flags: '-d, --delete <key>', description: 'Delete configuration key' },
+                { flags: '-e, --export', description: 'Export configuration to JSON', defaultValue: false }
+            ],
+            action: async (options) => {
+                const configManager = new CloudConfigManager();
+                if (options.list) {
+                    const config = configManager.getAll();
+                    this.logInfo('Current configuration:');
+                    config.forEach(item => {
+                        this.logInfo(`  ${item.key}: ${JSON.stringify(item.value)}`);
+                    });
+                }
+                else if (options.get) {
+                    const value = configManager.get(options.get);
+                    if (value !== undefined) {
+                        this.logInfo(`${options.get}: ${JSON.stringify(value)}`);
+                    }
+                    else {
+                        this.logWarning(`Configuration key '${options.get}' not found`);
+                    }
+                }
+                else if (options.set) {
+                    const [key, value] = options.set;
+                    configManager.set(key, value);
+                    this.logSuccess(`Configuration '${key}' set to: ${value}`);
+                }
+                else if (options.delete) {
+                    configManager.delete(options.delete);
+                    this.logSuccess(`Configuration '${options.delete}' deleted`);
+                }
+                else if (options.export) {
+                    const exported = configManager.export();
+                    this.logInfo(exported);
+                }
+                else {
+                    this.logInfo('Use --list, --get, --set, --delete, or --export to manage configuration');
+                }
+            }
+        });
+        // Jobs management
+        this.addSubcommand(supabaseCmd, {
+            name: 'jobs',
+            description: 'Manage shell jobs',
+            options: [
+                { flags: '-l, --list', description: 'List active jobs', defaultValue: false },
+                { flags: '-h, --history', description: 'List job history', defaultValue: false }
+            ],
+            action: async (options) => {
+                const persistence = new DatabasePersistence();
+                if (options.list) {
+                    const jobs = await persistence.getActiveJobs();
+                    this.logInfo(`Active jobs (${jobs.length}):`);
+                    jobs.forEach(job => {
+                        const started = new Date(job.started_at).toLocaleString();
+                        this.logInfo(`${job.job_id}: ${job.command} (${job.status}) - Started: ${started}`);
+                    });
+                }
+                else if (options.history) {
+                    this.logInfo('Job history feature not yet implemented');
+                }
+                else {
+                    this.logInfo('Use --list or --history to manage jobs');
+                }
+            }
+        });
+        // Database rows management
+        this.addSubcommand(supabaseCmd, {
+            name: 'rows',
+            description: 'Show latest database entries',
+            options: [
+                { flags: '-l, --limit <number>', description: 'Number of rows to show per table', defaultValue: '5' },
+                { flags: '-t, --table <name>', description: 'Show rows from specific table only' }
+            ],
+            action: async (options) => {
+                const persistence = new DatabasePersistence();
+                const limit = parseInt(options.limit);
+                // Test connection first
+                const isConnected = await persistence.testConnection();
+                if (!isConnected) {
+                    throw new Error('Cannot fetch rows - database not available');
+                }
+                if (options.table) {
+                    // Show rows from specific table
+                    this.logInfo(`Latest ${limit} entries from table '${options.table}':`);
+                    const rows = await persistence.getLatestRowsFromTable(options.table, limit);
+                    if (rows.length === 0) {
+                        this.logInfo('No entries found.');
+                    }
+                    else {
+                        rows.forEach((row, index) => {
+                            const timestamp = row.created_at ? new Date(row.created_at).toLocaleString() : 'N/A';
+                            this.logInfo(`\n${index + 1}. [${timestamp}]`);
+                            this.logInfo(JSON.stringify(row, null, 2));
+                        });
+                    }
+                }
+                else {
+                    // Show rows from all tables
+                    this.logInfo(`Latest ${limit} entries from each table:`);
+                    const allRows = await persistence.getLatestRows(limit);
+                    for (const [tableName, rows] of Object.entries(allRows)) {
+                        this.logInfo(`\n=== ${tableName.toUpperCase()} ===`);
+                        if (rows.length === 0) {
+                            this.logInfo('No entries found.');
+                        }
+                        else {
+                            rows.forEach((row, index) => {
+                                const timestamp = row.created_at ? new Date(row.created_at).toLocaleString() : 'N/A';
+                                this.logInfo(`\n${index + 1}. [${timestamp}]`);
+                                this.logInfo(JSON.stringify(row, null, 2));
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    }
+    registerMLCommands(supabaseCmd) {
+        // ML Training Jobs
+        this.addSubcommand(supabaseCmd, {
+            name: 'ml-train',
+            description: 'Manage ML training jobs',
+            options: [
+                { flags: '-l, --list', description: 'List training jobs', defaultValue: false },
+                { flags: '-s, --status <status>', description: 'Filter by status (pending, running, completed, failed)' },
+                { flags: '-c, --create <name>', description: 'Create new training job' },
+                { flags: '--model-type <type>', description: 'Model type for new job' },
+                { flags: '--dataset <name>', description: 'Dataset name for new job' }
+            ],
+            action: async (options) => {
+                if (options.list) {
+                    let query = supabaseClient.getClient()
+                        .from('ml_training_jobs')
+                        .select('*')
+                        .order('created_at', { ascending: false });
+                    if (options.status) {
+                        query = query.eq('status', options.status);
+                    }
+                    const { data: jobs, error } = await query.limit(20);
+                    if (error) {
+                        throw new Error(`Failed to fetch training jobs: ${error.message}`);
+                    }
+                    this.logInfo(`Training Jobs (${jobs?.length || 0}):`);
+                    jobs?.forEach(job => {
+                        const created = new Date(job.created_at).toLocaleString();
+                        this.logInfo(`\n${job.job_name} (${job.model_type})`);
+                        this.logInfo(`  Status: ${job.status}`);
+                        this.logInfo(`  Created: ${created}`);
+                        this.logInfo(`  Dataset: ${job.dataset_name}`);
+                    });
+                }
+                else if (options.create) {
+                    if (!options.modelType || !options.dataset) {
+                        throw new Error('Both --model-type and --dataset are required to create a job');
+                    }
+                    const { data, error } = await supabaseClient.getClient()
+                        .from('ml_training_jobs')
+                        .insert({
+                        job_name: options.create,
+                        model_type: options.modelType,
+                        dataset_name: options.dataset,
+                        status: 'pending',
+                        created_at: new Date().toISOString()
+                    })
+                        .select();
+                    if (error) {
+                        throw new Error(`Failed to create training job: ${error.message}`);
+                    }
+                    this.logSuccess(`Created training job: ${options.create}`);
+                    this.logInfo(JSON.stringify(data, null, 2));
+                }
+                else {
+                    this.logInfo('Use --list or --create to manage training jobs');
+                }
+            }
+        });
+        // ML Models
+        this.addSubcommand(supabaseCmd, {
+            name: 'ml-models',
+            description: 'Manage ML models',
+            options: [
+                { flags: '-l, --list', description: 'List ML models', defaultValue: false },
+                { flags: '--deployed', description: 'Filter by deployed models only', defaultValue: false }
+            ],
+            action: async (options) => {
+                if (options.list) {
+                    let query = supabaseClient.getClient()
+                        .from('ml_models')
+                        .select('*')
+                        .order('created_at', { ascending: false });
+                    if (options.deployed) {
+                        query = query.eq('deployed', true);
+                    }
+                    const { data: models, error } = await query.limit(20);
+                    if (error) {
+                        throw new Error(`Failed to fetch models: ${error.message}`);
+                    }
+                    this.logInfo(`ML Models (${models?.length || 0}):`);
+                    models?.forEach(model => {
+                        const created = new Date(model.created_at).toLocaleString();
+                        this.logInfo(`\n${model.model_name} (v${model.version})`);
+                        this.logInfo(`  Type: ${model.model_type}`);
+                        this.logInfo(`  Accuracy: ${model.accuracy}`);
+                        this.logInfo(`  Deployed: ${model.deployed ? 'Yes' : 'No'}`);
+                        this.logInfo(`  Created: ${created}`);
+                    });
+                }
+                else {
+                    this.logInfo('Use --list to manage ML models');
+                }
+            }
+        });
+        // ML Features
+        this.addSubcommand(supabaseCmd, {
+            name: 'ml-features',
+            description: 'Manage ML feature definitions',
+            options: [
+                { flags: '-l, --list', description: 'List feature definitions', defaultValue: false }
+            ],
+            action: async (options) => {
+                if (options.list) {
+                    const { data: features, error } = await supabaseClient.getClient()
+                        .from('ml_features')
+                        .select('*')
+                        .order('created_at', { ascending: false })
+                        .limit(20);
+                    if (error) {
+                        throw new Error(`Failed to fetch features: ${error.message}`);
+                    }
+                    this.logInfo(`ML Features (${features?.length || 0}):`);
+                    features?.forEach(feature => {
+                        this.logInfo(`\n${feature.feature_name}`);
+                        this.logInfo(`  Type: ${feature.feature_type}`);
+                        this.logInfo(`  Importance: ${feature.importance_score}`);
+                    });
+                }
+                else {
+                    this.logInfo('Use --list to manage ML features');
+                }
+            }
+        });
+    }
+}

package/dist/services/supabase/supabase.js

@@ -0,0 +1,9 @@
+/**
+ * Supabase Service - CLI command registration
+ * Uses SupabaseCommandRegistrar for clean, maintainable command setup
+ */
+import { SupabaseCommandRegistrar } from './supabase-registrar.js';
+export async function init_supabase(program) {
+    const registrar = new SupabaseCommandRegistrar();
+    await registrar.register(program);
+}

package/dist/services/zapier.js

@@ -0,0 +1,16 @@
+import axios from 'axios';
+export async function test() {
+    const options = {
+        method: 'POST',
+        url: 'https://stoplight.io/mocks/zapier/public-api/181772442/authentications',
+        headers: { 'Content-Type': 'application/vnd.api+json', Accept: 'application/vnd.api+json' },
+        data: '{\n  "data": {\n    "title": "SuperExampleCRM (example@zapier.com)",\n    "app": "868f9d3c-2ea0-4f19-a32d-a61b276ab8de",\n    "authentication_fields": {}\n  }\n}'
+    };
+    try {
+        const { data } = await axios.request(options);
+        console.log(data);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}