lsh-framework 0.5.4

package/dist/commands/api.js

@@ -0,0 +1,343 @@
+/**
+ * API Server Commands for LSH
+ */
+import chalk from 'chalk';
+import crypto from 'crypto';
+import DaemonClient from '../lib/daemon-client.js';
+export function registerApiCommands(program) {
+    const api = program
+        .command('api')
+        .description('API server management and configuration');
+    // Start daemon with API server enabled
+    api
+        .command('start')
+        .description('Start daemon with API server enabled')
+        .option('-p, --port <port>', 'API port', '3030')
+        .option('-k, --api-key <key>', 'API key (generated if not provided)')
+        .option('--webhooks', 'Enable webhook support', false)
+        .action(async (options) => {
+        try {
+            const apiKey = options.apiKey || crypto.randomBytes(32).toString('hex');
+            const daemonClient = new DaemonClient();
+            // Check if daemon is already running
+            if (daemonClient.isDaemonRunning()) {
+                console.log(chalk.yellow('⚠️  Daemon is already running. Restarting with API enabled...'));
+                // Stop existing daemon
+                await daemonClient.connect();
+                await daemonClient.stopDaemon();
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+            // Write API configuration to environment or a config file
+            process.env.LSH_API_ENABLED = 'true';
+            process.env.LSH_API_PORT = options.port;
+            process.env.LSH_API_KEY = apiKey;
+            process.env.LSH_ENABLE_WEBHOOKS = options.webhooks ? 'true' : 'false';
+            // Restart the daemon which will pick up the environment variables
+            await daemonClient.restartDaemon();
+            console.log(chalk.green('✅ Daemon started with API server'));
+            console.log(chalk.blue(`\n📡 API Server: http://localhost:${options.port}`));
+            console.log(chalk.yellow(`🔑 API Key: ${apiKey}`));
+            console.log(chalk.gray('\nStore this API key securely. You will need it to authenticate API requests.'));
+            console.log(chalk.gray(`\nExample usage:`));
+            console.log(chalk.gray(`  curl -H "X-API-Key: ${apiKey}" http://localhost:${options.port}/api/status`));
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Failed to start API server: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    // Generate API key
+    api
+        .command('key')
+        .description('Generate a new API key')
+        .action(() => {
+        const apiKey = crypto.randomBytes(32).toString('hex');
+        console.log(chalk.green('🔑 Generated API Key:'));
+        console.log(apiKey);
+        console.log(chalk.gray('\nSet this as LSH_API_KEY environment variable:'));
+        console.log(chalk.gray(`  export LSH_API_KEY="${apiKey}"`));
+    });
+    // Test API connection
+    api
+        .command('test')
+        .description('Test API server connection')
+        .option('-p, --port <port>', 'API port', '3030')
+        .option('-k, --api-key <key>', 'API key')
+        .action(async (options) => {
+        try {
+            const apiKey = options.apiKey || process.env.LSH_API_KEY;
+            if (!apiKey) {
+                console.error(chalk.red('❌ API key required. Use --api-key or set LSH_API_KEY environment variable'));
+                process.exit(1);
+            }
+            const response = await fetch(`http://localhost:${options.port}/api/status`, {
+                headers: {
+                    'X-API-Key': apiKey
+                }
+            });
+            if (response.ok) {
+                const status = await response.json();
+                console.log(chalk.green('✅ API server is running'));
+                console.log('Status:', JSON.stringify(status, null, 2));
+            }
+            else {
+                console.error(chalk.red(`❌ API server returned ${response.status}: ${response.statusText}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Failed to connect to API server: ${error.message}`));
+            console.log(chalk.yellow('Make sure the daemon is running with API enabled:'));
+            console.log(chalk.gray('  lsh api start'));
+        }
+    });
+    // Configure webhooks
+    api
+        .command('webhook')
+        .description('Configure webhook endpoints')
+        .argument('<action>', 'Action: add, list, remove')
+        .argument('[endpoint]', 'Webhook endpoint URL')
+        .option('-p, --port <port>', 'API port', '3030')
+        .option('-k, --api-key <key>', 'API key')
+        .action(async (action, endpoint, options) => {
+        try {
+            const apiKey = options.apiKey || process.env.LSH_API_KEY;
+            if (!apiKey) {
+                console.error(chalk.red('❌ API key required'));
+                process.exit(1);
+            }
+            const baseUrl = `http://localhost:${options.port}`;
+            switch (action) {
+                case 'add': {
+                    if (!endpoint) {
+                        console.error(chalk.red('❌ Endpoint URL required'));
+                        process.exit(1);
+                    }
+                    const addResponse = await fetch(`${baseUrl}/api/webhooks`, {
+                        method: 'POST',
+                        headers: {
+                            'X-API-Key': apiKey,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ endpoint })
+                    });
+                    if (addResponse.ok) {
+                        const result = await addResponse.json();
+                        console.log(chalk.green('✅ Webhook added successfully'));
+                        console.log('Endpoints:', result.endpoints);
+                    }
+                    else {
+                        console.error(chalk.red('❌ Failed to add webhook'));
+                    }
+                    break;
+                }
+                case 'list': {
+                    const listResponse = await fetch(`${baseUrl}/api/webhooks`, {
+                        headers: { 'X-API-Key': apiKey }
+                    });
+                    if (listResponse.ok) {
+                        const webhooks = await listResponse.json();
+                        console.log(chalk.blue('📮 Webhook Configuration:'));
+                        console.log(`Enabled: ${webhooks.enabled}`);
+                        console.log('Endpoints:', webhooks.endpoints);
+                    }
+                    break;
+                }
+                default:
+                    console.error(chalk.red(`❌ Unknown action: ${action}`));
+                    console.log('Valid actions: add, list, remove');
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Failed: ${error.message}`));
+        }
+    });
+    // Example client code generator
+    api
+        .command('example')
+        .description('Generate example client code')
+        .option('-l, --language <lang>', 'Language (js, python, curl)', 'js')
+        .option('-p, --port <port>', 'API port', '3030')
+        .action((options) => {
+        const apiKey = process.env.LSH_API_KEY || 'YOUR_API_KEY';
+        switch (options.language) {
+            case 'js':
+                console.log(chalk.blue('// JavaScript Example Client\n'));
+                console.log(`const LSHClient = {
+  baseURL: 'http://localhost:${options.port}',
+  apiKey: '${apiKey}',
+
+  async request(path, options = {}) {
+    const response = await fetch(\`\${this.baseURL}\${path}\`, {
+      ...options,
+      headers: {
+        'X-API-Key': this.apiKey,
+        'Content-Type': 'application/json',
+        ...options.headers
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(\`API error: \${response.statusText}\`);
+    }
+
+    return response.json();
+  },
+
+  // Get daemon status
+  async getStatus() {
+    return this.request('/api/status');
+  },
+
+  // List all jobs
+  async listJobs() {
+    return this.request('/api/jobs');
+  },
+
+  // Create a new job
+  async createJob(jobSpec) {
+    return this.request('/api/jobs', {
+      method: 'POST',
+      body: JSON.stringify(jobSpec)
+    });
+  },
+
+  // Trigger job execution
+  async triggerJob(jobId) {
+    return this.request(\`/api/jobs/\${jobId}/trigger\`, {
+      method: 'POST'
+    });
+  },
+
+  // Stream events using EventSource
+  streamEvents() {
+    const eventSource = new EventSource(\`\${this.baseURL}/api/events\`);
+
+    eventSource.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      console.log('Event:', data);
+    };
+
+    eventSource.onerror = (error) => {
+      console.error('EventSource error:', error);
+    };
+
+    return eventSource;
+  }
+};
+
+// Example usage
+(async () => {
+  try {
+    const status = await LSHClient.getStatus();
+    console.log('Daemon status:', status);
+
+    // Create a job
+    const job = await LSHClient.createJob({
+      name: 'Example Job',
+      command: 'echo "Hello from API"',
+      type: 'shell'
+    });
+    console.log('Created job:', job);
+
+    // Trigger the job
+    const result = await LSHClient.triggerJob(job.id);
+    console.log('Job result:', result);
+
+  } catch (error) {
+    console.error('Error:', error);
+  }
+})();`);
+                break;
+            case 'python':
+                console.log(chalk.blue('# Python Example Client\n'));
+                console.log(`import requests
+import json
+from typing import Dict, Any, Optional
+
+class LSHClient:
+    def __init__(self, base_url: str = "http://localhost:${options.port}", api_key: str = "${apiKey}"):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.headers = {
+            "X-API-Key": api_key,
+            "Content-Type": "application/json"
+        }
+
+    def request(self, method: str, path: str, data: Optional[Dict] = None) -> Dict[str, Any]:
+        """Make an API request"""
+        url = f"{self.base_url}{path}"
+        response = requests.request(method, url, headers=self.headers, json=data)
+        response.raise_for_status()
+        return response.json()
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get daemon status"""
+        return self.request("GET", "/api/status")
+
+    def list_jobs(self) -> list:
+        """List all jobs"""
+        return self.request("GET", "/api/jobs")
+
+    def create_job(self, job_spec: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new job"""
+        return self.request("POST", "/api/jobs", job_spec)
+
+    def trigger_job(self, job_id: str) -> Dict[str, Any]:
+        """Trigger job execution"""
+        return self.request("POST", f"/api/jobs/{job_id}/trigger")
+
+# Example usage
+if __name__ == "__main__":
+    client = LSHClient()
+
+    # Get status
+    status = client.get_status()
+    print(f"Daemon status: {json.dumps(status, indent=2)}")
+
+    # Create a job
+    job = client.create_job({
+        "name": "Example Job",
+        "command": "echo 'Hello from Python'",
+        "type": "shell"
+    })
+    print(f"Created job: {job}")
+
+    # Trigger the job
+    result = client.trigger_job(job["id"])
+    print(f"Job result: {result}")`);
+                break;
+            case 'curl':
+                console.log(chalk.blue('# cURL Examples\n'));
+                console.log(`# Get daemon status
+curl -H "X-API-Key: ${apiKey}" \\
+  http://localhost:${options.port}/api/status
+
+# List all jobs
+curl -H "X-API-Key: ${apiKey}" \\
+  http://localhost:${options.port}/api/jobs
+
+# Create a new job
+curl -X POST \\
+  -H "X-API-Key: ${apiKey}" \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "name": "Example Job",
+    "command": "echo Hello World",
+    "type": "shell"
+  }' \\
+  http://localhost:${options.port}/api/jobs
+
+# Trigger a job
+curl -X POST \\
+  -H "X-API-Key: ${apiKey}" \\
+  http://localhost:${options.port}/api/jobs/JOB_ID/trigger
+
+# Stream events
+curl -H "X-API-Key: ${apiKey}" \\
+  -H "Accept: text/event-stream" \\
+  http://localhost:${options.port}/api/events`);
+                break;
+        }
+    });
+}
+export default registerApiCommands;

package/dist/commands/self.js

@@ -0,0 +1,318 @@
+/**
+ * Self-management commands for LSH
+ * Provides utilities for updating and maintaining the CLI
+ */
+import { Command } from 'commander';
+import * as https from 'https';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const selfCommand = new Command('self');
+selfCommand.description('Manage and update the LSH application');
+/**
+ * Parse version string to tuple for comparison
+ */
+function parseVersion(version) {
+    return version
+        .replace(/^v/, '')
+        .split('.')
+        .map(x => parseInt(x) || 0);
+}
+/**
+ * Compare two version strings
+ * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+    const parts1 = parseVersion(v1);
+    const parts2 = parseVersion(v2);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 < p2)
+            return -1;
+        if (p1 > p2)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Get current version from package.json
+ */
+function getCurrentVersion() {
+    try {
+        const packageJsonPath = path.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Fetch latest version from npm registry
+ */
+async function fetchLatestVersion() {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'registry.npmjs.org',
+            port: 443,
+            path: '/gwicho38-lsh',
+            method: 'GET',
+            headers: {
+                'User-Agent': 'lsh-cli',
+            },
+        };
+        https.get(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    if (res.statusCode === 200) {
+                        const npmData = JSON.parse(data);
+                        const latestVersion = npmData['dist-tags']?.latest;
+                        if (latestVersion) {
+                            const publishedAt = npmData.time?.[latestVersion];
+                            resolve({
+                                version: latestVersion,
+                                publishedAt: publishedAt || undefined,
+                            });
+                        }
+                        else {
+                            resolve(null);
+                        }
+                    }
+                    else {
+                        console.error(chalk.red(`✗ npm registry returned status ${res.statusCode}`));
+                        resolve(null);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }).on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Check GitHub Actions CI status for a specific version tag
+ */
+async function checkCIStatus(_version) {
+    return new Promise((resolve) => {
+        const options = {
+            hostname: 'api.github.com',
+            port: 443,
+            path: `/repos/gwicho38/lsh/actions/runs?per_page=5`,
+            method: 'GET',
+            headers: {
+                'User-Agent': 'lsh-cli',
+                'Accept': 'application/vnd.github.v3+json',
+            },
+        };
+        https.get(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    if (res.statusCode === 200) {
+                        const ghData = JSON.parse(data);
+                        const runs = ghData.workflow_runs || [];
+                        // Find the most recent workflow run for main branch
+                        const mainRuns = runs.filter((run) => run.head_branch === 'main' && run.status === 'completed');
+                        if (mainRuns.length > 0) {
+                            const latestRun = mainRuns[0];
+                            const passing = latestRun.conclusion === 'success';
+                            resolve({
+                                passing,
+                                url: latestRun.html_url,
+                            });
+                        }
+                        else {
+                            // No completed runs found, assume passing
+                            resolve({ passing: true });
+                        }
+                    }
+                    else {
+                        // If we can't check CI, don't block the update
+                        resolve({ passing: true });
+                    }
+                }
+                catch (_error) {
+                    // On error, don't block the update
+                    resolve({ passing: true });
+                }
+            });
+        }).on('error', () => {
+            // On network error, don't block the update
+            resolve({ passing: true });
+        });
+    });
+}
+/**
+ * Update command - check for and install updates from npm
+ */
+selfCommand
+    .command('update')
+    .description('Check for and install LSH updates from npm')
+    .option('--check', 'Only check for updates, don\'t install')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--skip-ci-check', 'Skip CI status check and install anyway')
+    .action(async (options) => {
+    try {
+        const currentVersion = getCurrentVersion();
+        console.log(chalk.cyan('Current version:'), currentVersion);
+        console.log(chalk.cyan('Checking npm for updates...'));
+        // Fetch latest version from npm
+        const latestInfo = await fetchLatestVersion();
+        if (!latestInfo) {
+            console.log(chalk.red('✗ Failed to fetch version information from npm'));
+            console.log(chalk.yellow('⚠ Make sure you have internet connectivity'));
+            return;
+        }
+        const { version: latestVersion, publishedAt } = latestInfo;
+        console.log(chalk.cyan('Latest version:'), latestVersion);
+        if (publishedAt) {
+            const date = new Date(publishedAt);
+            console.log(chalk.dim(`  Published: ${date.toLocaleDateString()}`));
+        }
+        // Compare versions
+        const comparison = compareVersions(currentVersion, latestVersion);
+        if (comparison === 0) {
+            console.log(chalk.green('✓ You\'re already on the latest version!'));
+            return;
+        }
+        if (comparison > 0) {
+            console.log(chalk.green(`✓ Your version (${currentVersion}) is newer than npm`));
+            console.log(chalk.dim('  You may be using a development version'));
+            return;
+        }
+        // Update available
+        console.log(chalk.yellow(`⬆ Update available: ${currentVersion} → ${latestVersion}`));
+        if (options.check) {
+            console.log(chalk.cyan('ℹ Run \'lsh self update\' to install the update'));
+            return;
+        }
+        // Ask for confirmation unless --yes flag is used
+        if (!options.yes) {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk.yellow(`Install lsh ${latestVersion}? (y/N) `), (ans) => {
+                    rl.close();
+                    resolve(ans);
+                });
+            });
+            if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+                console.log(chalk.yellow('Update cancelled'));
+                return;
+            }
+        }
+        // Check CI status before installing (unless skipped)
+        if (!options.skipCiCheck) {
+            console.log(chalk.cyan('🔍 Checking CI status...'));
+            const ciStatus = await checkCIStatus(latestVersion);
+            if (!ciStatus.passing) {
+                console.log(chalk.red('✗ CI build is failing for the latest version'));
+                if (ciStatus.url) {
+                    console.log(chalk.yellow(`  View CI status: ${ciStatus.url}`));
+                }
+                console.log(chalk.yellow('⚠ Update blocked to prevent installing a broken version'));
+                console.log(chalk.dim('  Use --skip-ci-check to install anyway (not recommended)'));
+                return;
+            }
+            else {
+                console.log(chalk.green('✓ CI build is passing'));
+            }
+        }
+        // Install update
+        console.log(chalk.cyan(`📦 Installing lsh ${latestVersion}...`));
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const updateProcess = spawn(npmCmd, ['install', '-g', 'gwicho38-lsh@latest'], {
+            stdio: 'inherit',
+        });
+        updateProcess.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk.green(`✓ Successfully updated to lsh ${latestVersion}!`));
+                console.log(chalk.yellow('ℹ Restart your terminal or run \'hash -r\' to use the new version'));
+            }
+            else {
+                console.log(chalk.red('✗ Update failed'));
+                console.log(chalk.yellow('ℹ Try running with sudo: sudo npm install -g gwicho38-lsh@latest'));
+            }
+        });
+    }
+    catch (error) {
+        console.error(chalk.red('✗ Error during update:'), error);
+    }
+});
+/**
+ * Version command - show detailed version information
+ */
+selfCommand
+    .command('version')
+    .description('Show detailed version information')
+    .action(() => {
+    const currentVersion = getCurrentVersion();
+    console.log(chalk.cyan('╔════════════════════════════════════╗'));
+    console.log(chalk.cyan('║         LSH Version Info           ║'));
+    console.log(chalk.cyan('╚════════════════════════════════════╝'));
+    console.log();
+    console.log(chalk.cyan('Version:'), currentVersion);
+    console.log(chalk.cyan('Node:'), process.version);
+    console.log(chalk.cyan('Platform:'), `${process.platform} (${process.arch})`);
+    console.log();
+    console.log(chalk.dim('Run \'lsh self update --check\' to check for updates'));
+});
+/**
+ * Info command - show installation and configuration info
+ */
+selfCommand
+    .command('info')
+    .description('Show installation and configuration information')
+    .action(() => {
+    const currentVersion = getCurrentVersion();
+    console.log(chalk.cyan('╔════════════════════════════════════╗'));
+    console.log(chalk.cyan('║      LSH Installation Info         ║'));
+    console.log(chalk.cyan('╚════════════════════════════════════╝'));
+    console.log();
+    // Version info
+    console.log(chalk.yellow('Version Information:'));
+    console.log('  LSH Version:', currentVersion);
+    console.log('  Node.js:', process.version);
+    console.log('  Platform:', `${process.platform} (${process.arch})`);
+    console.log();
+    // Installation paths
+    console.log(chalk.yellow('Installation:'));
+    console.log('  Executable:', process.execPath);
+    console.log('  Working Dir:', process.cwd());
+    console.log();
+    // Environment
+    console.log(chalk.yellow('Environment:'));
+    console.log('  NODE_ENV:', process.env.NODE_ENV || 'not set');
+    console.log('  HOME:', process.env.HOME || 'not set');
+    console.log('  USER:', process.env.USER || 'not set');
+    console.log();
+    // Configuration
+    const envFile = path.join(process.cwd(), '.env');
+    const envExists = fs.existsSync(envFile);
+    console.log(chalk.yellow('Configuration:'));
+    console.log('  .env file:', envExists ? chalk.green('Found') : chalk.red('Not found'));
+    if (!envExists) {
+        console.log(chalk.dim('  Copy .env.example to .env to configure'));
+    }
+    console.log();
+    console.log(chalk.dim('For more info, visit: https://github.com/gwicho38/lsh'));
+});
+export default selfCommand;