lsh-framework 0.5.4

package/dist/components/Terminal.js

@@ -0,0 +1,232 @@
+import { Box, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { stdout } from "process";
+import React, { useEffect, useState } from "react";
+import { Script, createContext } from "vm";
+import { shell_exec } from "../lib/shell.lib.js";
+import { parseShellCommand } from "../lib/shell-parser.js";
+import { ShellExecutor } from "../lib/shell-executor.js";
+export const Terminal = () => {
+    const [input, setInput] = useState("");
+    const [lines, setLines] = useState([]);
+    const [_mode, _setMode] = useState("auto"); // auto, js, shell
+    const [workingDir, setWorkingDir] = useState(process.cwd());
+    const [shellExecutor] = useState(() => new ShellExecutor());
+    const { exit } = useApp();
+    // Check if raw mode is supported synchronously
+    const isRawModeSupported = process.stdin.isTTY && process.stdin.setRawMode !== undefined;
+    // Detect if input is a shell command or JavaScript
+    const detectInputType = (input) => {
+        const trimmed = input.trim();
+        // Check for common shell commands
+        const shellCommands = ["ls", "cd", "pwd", "mkdir", "rm", "cp", "mv", "cat", "grep", "find", "ps", "kill", "chmod", "chown", "git", "npm", "node", "python", "curl", "wget"];
+        const firstWord = trimmed.split(' ')[0];
+        // Check for JavaScript patterns
+        const jsPatterns = [
+            /^(const|let|var|function|class|\{|\[|if|for|while|try|async|await)/,
+            /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*[=]/,
+            /\.(map|filter|reduce|forEach)/,
+            /^Math\.|^JSON\.|^console\./,
+            /^[0-9]+(\.[0-9]+)?(\s*[+\-*/])/
+        ];
+        // Force modes
+        if (trimmed.startsWith("js:"))
+            return "js";
+        if (trimmed.startsWith("sh:") || trimmed.startsWith("$"))
+            return "shell";
+        // JavaScript detection
+        if (jsPatterns.some(pattern => pattern.test(trimmed)))
+            return "js";
+        // Shell command detection
+        if (shellCommands.includes(firstWord))
+            return "shell";
+        // Default to shell for most other cases
+        return "shell";
+    };
+    // Execute JavaScript code in a VM context with enhanced features
+    const executeScript = async (input) => {
+        try {
+            let code = input;
+            if (code.startsWith("js:"))
+                code = code.substring(3).trim();
+            // Create context with useful globals
+            const context = createContext({
+                console,
+                process,
+                __dirname: workingDir,
+                __filename: '',
+                global,
+                Buffer,
+                setTimeout,
+                setInterval,
+                clearTimeout,
+                clearInterval,
+                shell_exec, // Make shell_exec available in JS context
+                sh: shell_exec, // Short alias
+            });
+            const script = new Script(code);
+            const result = script.runInContext(context);
+            return `${result !== undefined ? result : '(undefined)'}`;
+        }
+        catch (error) {
+            return `JS Error: ${error.message}`;
+        }
+    };
+    // Execute shell command using POSIX parser and executor
+    const executeShell = async (input) => {
+        try {
+            let command = input.trim();
+            if (command.startsWith("sh:"))
+                command = command.substring(3).trim();
+            if (command.startsWith("$"))
+                command = command.substring(1).trim();
+            // Parse the command using POSIX grammar
+            const ast = parseShellCommand(command);
+            // Execute the parsed command
+            const result = await shellExecutor.execute(ast);
+            // Update working directory from executor context
+            const context = shellExecutor.getContext();
+            if (context.cwd !== workingDir) {
+                setWorkingDir(context.cwd);
+            }
+            if (!result.success && result.stderr) {
+                return `Shell Error: ${result.stderr}`;
+            }
+            let output = "";
+            if (result.stdout)
+                output += result.stdout;
+            if (result.stderr)
+                output += (output ? "\n" : "") + `stderr: ${result.stderr}`;
+            return output || "(no output)";
+        }
+        catch (error) {
+            // Fallback to old shell execution for unparseable commands
+            try {
+                let command = input.trim();
+                if (command.startsWith("sh:"))
+                    command = command.substring(3).trim();
+                if (command.startsWith("$"))
+                    command = command.substring(1).trim();
+                const result = await shell_exec(command);
+                if (result.error) {
+                    return `Shell Error: ${result.error}`;
+                }
+                let output = "";
+                if (result.stdout)
+                    output += result.stdout;
+                if (result.stderr)
+                    output += (output ? "\n" : "") + `stderr: ${result.stderr}`;
+                return output || "(no output)";
+            }
+            catch (_fallbackError) {
+                return `Shell Error: ${error.message}`;
+            }
+        }
+    };
+    // Handle input submission
+    const handleSubmit = async () => {
+        if (!input.trim())
+            return;
+        const inputType = detectInputType(input);
+        const prompt = `[${workingDir.split('/').pop() || '/'}] ${inputType === 'js' ? 'js>' : '$'} ${input}`;
+        setLines(prev => [...prev, prompt]);
+        try {
+            let result;
+            if (inputType === "js") {
+                result = await executeScript(input);
+            }
+            else {
+                result = await executeShell(input);
+            }
+            // Add result with proper formatting and spacing
+            setLines(prev => [...prev, result, ""]);
+        }
+        catch (error) {
+            // Add error and a blank line for spacing
+            setLines(prev => [...prev, `Error: ${error.message}`, ""]);
+        }
+        setInput("");
+    };
+    // Handle resizing of the terminal
+    const [size, setSize] = useState({
+        columns: stdout.columns,
+        rows: stdout.rows,
+    });
+    useEffect(() => {
+        const handleResize = () => {
+            setSize({
+                columns: stdout.columns,
+                rows: stdout.rows,
+            });
+        };
+        stdout.on("resize", handleResize);
+        return () => {
+            stdout.off("resize", handleResize);
+        };
+    }, []);
+    // Only use input if raw mode is supported
+    const [_isInteractive, setIsInteractive] = useState(false);
+    useEffect(() => {
+        // Check if raw mode is supported
+        setIsInteractive(process.stdin.isTTY && process.stdin.setRawMode !== undefined);
+    }, []);
+    useInput((input, key) => {
+        if (!isRawModeSupported)
+            return;
+        if (key.return) {
+            handleSubmit();
+        }
+        else if (key.ctrl && input === "c") {
+            exit();
+        }
+    });
+    // Initialize with welcome message
+    useEffect(() => {
+        setLines([
+            "🚀 LSH Interactive Shell",
+            "Mix shell commands and JavaScript seamlessly!",
+            "Examples:",
+            "  ls -la          (shell command)",
+            "  2 + 2           (JavaScript expression)",
+            "  js: console.log('Hello')  (force JS mode)",
+            "  sh: echo 'Hi'   (force shell mode)",
+            "  await sh('ls')  (call shell from JS)",
+            "---"
+        ]);
+    }, []);
+    const currentDir = workingDir.split('/').pop() || '/';
+    const nextInputType = detectInputType(input);
+    const promptSymbol = nextInputType === 'js' ? 'js>' : '$';
+    if (!isRawModeSupported) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Interactive mode not supported"),
+            React.createElement(Text, { color: "yellow" }, "Raw mode is not supported in this environment."),
+            React.createElement(Text, { color: "gray" }, "To use the interactive REPL, run this command in a proper terminal:"),
+            React.createElement(Text, { color: "cyan" }, "  npm start repl"),
+            React.createElement(Text, { color: "gray" }, "or"),
+            React.createElement(Text, { color: "cyan" }, "  node dist/app.js repl"),
+            React.createElement(Text, { color: "gray" }, "For testing, use the shell lib functions directly in your Node.js code.")));
+    }
+    return (React.createElement(Box, { flexDirection: "column", padding: 1, width: size.columns, height: size.rows },
+        React.createElement(Box, { flexDirection: "column", width: "100%" },
+            React.createElement(Text, { color: "cyan", bold: true }, "LSH - Interactive Shell with JavaScript"),
+            React.createElement(Text, { color: "gray" },
+                "Current directory: ",
+                workingDir),
+            React.createElement(Text, { color: "gray" },
+                "Mode: Auto-detect (",
+                nextInputType === 'js' ? 'JavaScript' : 'Shell',
+                ")"),
+            React.createElement(Box, { borderStyle: "round", borderColor: "blue", paddingX: 1, marginY: 1, height: size.rows - 8, flexDirection: "column", width: "100%" },
+                React.createElement(Box, { flexDirection: "column", flexGrow: 1, overflowY: "hidden", width: "100%" }, lines.slice(Math.max(0, lines.length - (size.rows - 15))).map((line, index) => (React.createElement(Text, { key: index, wrap: "wrap", width: size.columns - 6 }, line)))),
+                React.createElement(Box, { flexDirection: "row", marginTop: 1, width: "100%" },
+                    React.createElement(Text, { color: "green" },
+                        "[",
+                        currentDir,
+                        "] ",
+                        promptSymbol,
+                        " "),
+                    React.createElement(Box, { flexGrow: 1, width: size.columns - currentDir.length - 8 },
+                        React.createElement(TextInput, { value: input, onChange: setInput, placeholder: "Enter shell command or JavaScript..." }))))),
+        React.createElement(Text, { color: "grey" }, "Press Ctrl+C to exit. Use js: or sh: to force execution mode.")));
+};

package/dist/components/UserInput.js

@@ -0,0 +1,30 @@
+import { useInput, useStdout } from 'ink';
+import React, { useState } from 'react';
+import { Divider } from './Divider.js';
+export function UserInput({ ..._props }) {
+    const [_feature, _setFeature] = useState('');
+    const [_readData, _setReadData] = useState([]);
+    const [_writeData, _setWriteData] = useState([]);
+    const [_userInput, _setUserInput] = useState('');
+    const [_name, _setName] = useState('');
+    const _handleSubmit = (_query) => {
+        // Do something with query
+        console.log(_query);
+        _setUserInput('');
+    };
+    const { stdout: _stdout, write: _write } = useStdout();
+    const _handleChange = (_query) => {
+    };
+    useInput((input, _key) => {
+        console.log(input);
+        // console.log(key);
+        if (input === 'q') {
+            // Exit program
+        }
+        ;
+    });
+    const input = (React.createElement(React.Fragment, null,
+        React.createElement(Divider, null),
+        React.createElement(Divider, null)));
+    return input;
+}

package/dist/daemon/api-server.js

@@ -0,0 +1,315 @@
+/**
+ * LSH API Server - RESTful API for daemon control and job management
+ */
+import cors from 'cors';
+import jwt from 'jsonwebtoken';
+import crypto from 'crypto';
+import { handleApiOperation } from '../lib/api-error-handler.js';
+import { BaseAPIServer } from '../lib/base-api-server.js';
+export class LSHApiServer extends BaseAPIServer {
+    daemon;
+    apiConfig;
+    clients = new Set(); // SSE clients
+    constructor(daemon, config = {}) {
+        const baseConfig = {
+            port: config.port || 3030,
+            corsOrigins: config.corsOrigins || ['http://localhost:*'],
+            jsonLimit: config.jsonLimit || '10mb',
+            enableHelmet: config.enableHelmet !== false,
+            enableRequestLogging: config.enableRequestLogging !== false,
+        };
+        super(baseConfig, 'LSHApiServer');
+        this.daemon = daemon;
+        this.apiConfig = {
+            ...this.config,
+            apiKey: config.apiKey || process.env.LSH_API_KEY || crypto.randomBytes(32).toString('hex'),
+            jwtSecret: config.jwtSecret || process.env.LSH_JWT_SECRET || crypto.randomBytes(32).toString('hex'),
+            enableWebhooks: config.enableWebhooks || false,
+            webhookEndpoints: config.webhookEndpoints || [],
+            ...config
+        };
+        this.setupEventHandlers();
+    }
+    /**
+     * Override CORS configuration to support wildcard patterns
+     */
+    configureCORS() {
+        const origins = this.config.corsOrigins;
+        if (origins === '*' || !origins) {
+            return cors();
+        }
+        if (Array.isArray(origins)) {
+            return cors({
+                origin: (origin, callback) => {
+                    if (!origin || origins.some(pattern => {
+                        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                        return regex.test(origin);
+                    })) {
+                        callback(null, true);
+                    }
+                    else {
+                        callback(new Error('Not allowed by CORS'));
+                    }
+                }
+            });
+        }
+        return cors({ origin: origins });
+    }
+    /**
+     * Helper method to handle API operations with automatic error handling and webhooks
+     */
+    async handleOperation(res, operation, successStatus = 200, webhookEvent) {
+        await handleApiOperation(res, operation, { successStatus, webhookEvent }, this.apiConfig.enableWebhooks ? this.triggerWebhook.bind(this) : undefined);
+    }
+    authenticateRequest(req, res, next) {
+        const apiKey = req.headers['x-api-key'];
+        const authHeader = req.headers['authorization'];
+        // Check API key
+        if (apiKey && apiKey === this.apiConfig.apiKey) {
+            return next();
+        }
+        // Check JWT token
+        if (authHeader && authHeader.startsWith('Bearer ')) {
+            const token = authHeader.substring(7);
+            try {
+                jwt.verify(token, this.apiConfig.jwtSecret);
+                return next();
+            }
+            catch (_err) {
+                return res.status(401).json({ error: 'Invalid token' });
+            }
+        }
+        return res.status(401).json({ error: 'Authentication required' });
+    }
+    setupRoutes() {
+        // Health check (no auth)
+        this.app.get('/health', (req, res) => {
+            res.json({ status: 'healthy', timestamp: new Date().toISOString() });
+        });
+        // Generate JWT token
+        this.app.post('/api/auth', (req, res) => {
+            const { apiKey } = req.body;
+            if (apiKey === this.apiConfig.apiKey) {
+                const token = jwt.sign({ type: 'api-access', created: Date.now() }, this.apiConfig.jwtSecret, { expiresIn: '24h' });
+                res.json({ token });
+            }
+            else {
+                res.status(401).json({ error: 'Invalid API key' });
+            }
+        });
+        // Protected routes
+        this.app.use('/api', this.authenticateRequest.bind(this));
+        // Daemon status
+        this.app.get('/api/status', async (req, res) => {
+            await this.handleOperation(res, async () => this.daemon.getStatus());
+        });
+        // Job management
+        this.app.get('/api/jobs', async (req, res) => {
+            await this.handleOperation(res, async () => {
+                const { filter, limit } = req.query;
+                return this.daemon.listJobs(filter ? JSON.parse(filter) : undefined, limit ? parseInt(limit) : undefined);
+            });
+        });
+        this.app.post('/api/jobs', async (req, res) => {
+            await this.handleOperation(res, async () => this.daemon.addJob(req.body), 201, 'job.created');
+        });
+        this.app.get('/api/jobs/:id', (req, res) => {
+            const job = this.daemon.getJob(req.params.id);
+            if (!job) {
+                return res.status(404).json({ error: 'Job not found' });
+            }
+            res.json(job);
+        });
+        this.app.post('/api/jobs/:id/start', async (req, res) => {
+            await this.handleOperation(res, async () => this.daemon.startJob(req.params.id), 200, 'job.started');
+        });
+        this.app.post('/api/jobs/:id/stop', async (req, res) => {
+            await this.handleOperation(res, async () => {
+                const { signal } = req.body;
+                return this.daemon.stopJob(req.params.id, signal);
+            }, 200, 'job.stopped');
+        });
+        this.app.post('/api/jobs/:id/trigger', async (req, res) => {
+            await this.handleOperation(res, async () => this.daemon.triggerJob(req.params.id));
+        });
+        this.app.delete('/api/jobs/:id', async (req, res) => {
+            await this.handleOperation(res, async () => {
+                const force = req.query.force === 'true';
+                const success = await this.daemon.removeJob(req.params.id, force);
+                if (!success) {
+                    throw new Error('Failed to remove job');
+                }
+                return { id: req.params.id };
+            }, 204, 'job.removed');
+        });
+        // Bulk operations
+        this.app.post('/api/jobs/bulk', async (req, res) => {
+            const { jobs } = req.body;
+            if (!Array.isArray(jobs)) {
+                return res.status(400).json({ error: 'Jobs must be an array' });
+            }
+            const results = [];
+            for (const jobSpec of jobs) {
+                try {
+                    const job = await this.daemon.addJob(jobSpec);
+                    results.push({ success: true, job });
+                }
+                catch (error) {
+                    results.push({ success: false, error: error.message, jobSpec });
+                }
+            }
+            res.json({ results });
+        });
+        // Server-sent events for real-time updates
+        this.app.get('/api/events', (req, res) => {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no' // Disable nginx buffering
+            });
+            // Send initial ping
+            res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: Date.now() })}\n\n`);
+            // Add client to set
+            this.clients.add(res);
+            // Setup heartbeat
+            const heartbeat = setInterval(() => {
+                res.write(`:ping\n\n`);
+            }, 30000);
+            // Cleanup on disconnect
+            req.on('close', () => {
+                clearInterval(heartbeat);
+                this.clients.delete(res);
+            });
+        });
+        // Webhook management
+        this.app.get('/api/webhooks', (req, res) => {
+            res.json({
+                enabled: this.apiConfig.enableWebhooks,
+                endpoints: this.apiConfig.webhookEndpoints
+            });
+        });
+        this.app.post('/api/webhooks', (req, res) => {
+            const { endpoint } = req.body;
+            if (!endpoint) {
+                return res.status(400).json({ error: 'Endpoint URL required' });
+            }
+            if (!this.apiConfig.webhookEndpoints?.includes(endpoint)) {
+                this.apiConfig.webhookEndpoints?.push(endpoint);
+            }
+            res.json({ success: true, endpoints: this.apiConfig.webhookEndpoints });
+        });
+        // Data export endpoints for integration
+        this.app.get('/api/export/jobs', async (req, res) => {
+            const jobs = await this.daemon.listJobs();
+            const format = req.query.format || 'json';
+            if (format === 'csv') {
+                res.setHeader('Content-Type', 'text/csv');
+                res.setHeader('Content-Disposition', 'attachment; filename="jobs.csv"');
+                const csv = this.convertToCSV(jobs);
+                res.send(csv);
+            }
+            else {
+                res.json(jobs);
+            }
+        });
+        // Supabase integration endpoint
+        this.app.post('/api/supabase/sync', async (req, res) => {
+            await this.handleOperation(res, async () => {
+                // This endpoint can be called by Supabase jobs to sync data
+                const { table, operation, data } = req.body;
+                // Emit event for mcli listener
+                this.emit('supabase:sync', { table, operation, data });
+                // Broadcast to SSE clients
+                this.broadcastToClients({
+                    type: 'supabase:sync',
+                    table,
+                    operation,
+                    data,
+                    timestamp: Date.now()
+                });
+                return { success: true, message: 'Data synced' };
+            });
+        });
+    }
+    setupEventHandlers() {
+        // Listen to daemon events and broadcast to SSE clients
+        const events = ['job:started', 'job:completed', 'job:failed', 'job:stopped'];
+        events.forEach(event => {
+            this.daemon.on(event, (data) => {
+                this.broadcastToClients({
+                    type: event,
+                    data,
+                    timestamp: Date.now()
+                });
+                if (this.apiConfig.enableWebhooks) {
+                    this.triggerWebhook(event, data);
+                }
+            });
+        });
+    }
+    broadcastToClients(data) {
+        const message = `data: ${JSON.stringify(data)}\n\n`;
+        this.clients.forEach(client => {
+            client.write(message);
+        });
+    }
+    async triggerWebhook(event, data) {
+        if (!this.apiConfig.webhookEndpoints?.length)
+            return;
+        const payload = {
+            event,
+            data,
+            timestamp: Date.now(),
+            source: 'lsh-daemon'
+        };
+        for (const endpoint of this.apiConfig.webhookEndpoints) {
+            try {
+                await fetch(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-LSH-Event': event
+                    },
+                    body: JSON.stringify(payload)
+                });
+            }
+            catch (error) {
+                this.logger.error(`Webhook failed for ${endpoint}`, error);
+            }
+        }
+    }
+    convertToCSV(data) {
+        if (!data.length)
+            return '';
+        const headers = Object.keys(data[0]);
+        const csv = [
+            headers.join(','),
+            ...data.map(row => headers.map(header => {
+                const value = row[header];
+                return typeof value === 'string' && value.includes(',')
+                    ? `"${value}"`
+                    : value;
+            }).join(','))
+        ];
+        return csv.join('\n');
+    }
+    /**
+     * Override onStop to cleanup SSE connections
+     */
+    onStop() {
+        // Close all SSE connections
+        this.clients.forEach(client => client.end());
+        this.clients.clear();
+    }
+    /**
+     * Override start to log API key
+     */
+    async start() {
+        await super.start();
+        this.logger.info(`API Key: ${this.apiConfig.apiKey}`);
+    }
+    getApiKey() {
+        return this.apiConfig.apiKey;
+    }
+}