@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/ext/ide-components/shared/file_utils.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+"""
+Shared file utilities for Tilt IDE components
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, List, Tuple
+
+# Flisk CLI root directory (5 levels up from this file: ext/ide-components/shared/)
+PROJECT_ROOT = Path(__file__).parent.parent.parent.parent.parent
+MAX_FILE_SIZE = 1024 * 1024  # 1MB
+
+
+class FileUtils:
+    """Safe file operations for IDE components"""
+    
+    @staticmethod
+    def validate_path(path: str) -> Optional[Path]:
+        """
+        Validate and sanitize a file path.
+        Returns absolute Path if valid, None if invalid.
+        
+        Security: Prevents path traversal attacks by ensuring
+        the resolved path is within the project root.
+        """
+        try:
+            # Handle relative paths
+            if not path.startswith('/'):
+                target = PROJECT_ROOT / path
+            else:
+                target = Path(path)
+            
+            # Resolve to absolute, removing .. and symlinks
+            resolved = target.resolve()
+            
+            # Ensure within project root
+            try:
+                resolved.relative_to(PROJECT_ROOT.resolve())
+            except ValueError:
+                return None
+            
+            return resolved
+        except (ValueError, OSError, RuntimeError):
+            return None
+    
+    @staticmethod
+    def get_file_info(file_path: Path) -> dict:
+        """Get file metadata for display"""
+        stat = file_path.stat()
+        size = stat.st_size
+        
+        # Human-readable size
+        if size < 1024:
+            size_str = f"{size} B"
+        elif size < 1024 * 1024:
+            size_str = f"{size / 1024:.1f} KB"
+        else:
+            size_str = f"{size / (1024 * 1024):.1f} MB"
+        
+        # Modified time
+        from datetime import datetime
+        mtime = datetime.fromtimestamp(stat.st_mtime)
+        mtime_str = mtime.strftime("%Y-%m-%d %H:%M")
+        
+        # File type icon
+        ext = file_path.suffix.lower()
+        icon = FileUtils.get_file_icon(ext, file_path.is_dir(), file_path.name)
+        
+        return {
+            'name': file_path.name,
+            'path': str(file_path.relative_to(PROJECT_ROOT)),
+            'size': size,
+            'size_str': size_str,
+            'modified': mtime_str,
+            'is_dir': file_path.is_dir(),
+            'icon': icon,
+            'extension': ext,
+        }
+    
+    @staticmethod
+    def get_file_icon(ext: str, is_dir: bool, filename: str = '') -> str:
+        """Get emoji icon for file type"""
+        if is_dir:
+            if filename.startswith('.'):
+                return '🔒'
+            if filename in ('node_modules', 'vendor', '__pycache__'):
+                return '📦'
+            return '📁'
+        
+        # Check special filenames first (exact match)
+        special_icons = {
+            'Makefile': '🔨',
+            'README': '📖',
+            'LICENSE': '📜',
+            'Dockerfile': '🐳',
+            'docker-compose.yml': '🐳',
+            'docker-compose.yaml': '🐳',
+            '.gitignore': '🚫',
+            'go.mod': '🔵',
+            'go.sum': '🔵',
+            'Cargo.toml': '🦀',
+            'Cargo.lock': '🦀',
+            'package.json': '⬡',
+            'package-lock.json': '⬡',
+            'requirements.txt': '🐍',
+            'setup.py': '🐍',
+        }
+        
+        if filename in special_icons:
+            return special_icons[filename]
+        
+        icons = {
+            '.ts': '📘', '.tsx': '📘',
+            '.js': '📒', '.jsx': '📒',
+            '.mjs': '📒', '.cjs': '📒',
+            '.json': '📋',
+            '.yaml': '📋', '.yml': '📋',
+            '.star': '⭐',
+            '.py': '🐍',
+            '.pyc': '🐍',
+            '.pyo': '🐍',
+            '.ipynb': '📓',
+            '.md': '📝',
+            '.mdx': '📝',
+            '.txt': '📄',
+            '.prisma': '🗃️',
+            '.dockerfile': '🐳', '.docker': '🐳',
+            '.sh': '🔧',
+            '.bash': '🔧',
+            '.zsh': '🔧',
+            '.fish': '🔧',
+            '.css': '🎨', '.scss': '🎨', '.sass': '🎨', '.less': '🎨',
+            '.html': '🌐', '.htm': '🌐', '.xhtml': '🌐',
+            '.vue': '💚',
+            '.svelte': '🧡',
+            '.conf': '⚙️', '.config': '⚙️', '.cfg': '⚙️',
+            '.ini': '⚙️',
+            '.toml': '⚙️',
+            '.env': '🔐',
+            '.env.local': '🔐', '.env.production': '🔐', '.env.development': '🔐',
+            '.sql': '🗄️',
+            '.go': '🔵',
+            '.rs': '🦀',
+            '.java': '☕',
+            '.class': '☕',
+            '.jar': '☕',
+            '.kt': '💜',
+            '.swift': '🦅',
+            '.rb': '💎',
+            '.php': '🐘',
+            '.c': '🇨',
+            '.cpp': '🇨🇵',
+            '.cc': '🇨🇵',
+            '.h': '📋',
+            '.hpp': '📋',
+            '.zig': '⚡',
+            '.lua': '🌙',
+            '.r': '📊',
+            '.R': '📊',
+            '.lock': '🔒',
+        }
+        
+        return icons.get(ext, '📄')
+    
+    @staticmethod
+    def read_file_safe(file_path: str, max_size: int = MAX_FILE_SIZE) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Safely read a file with size limit.
+        
+        Returns: (content, error_message)
+        - If success: (content, None)
+        - If error: (None, error_message)
+        """
+        resolved = FileUtils.validate_path(file_path)
+        
+        if not resolved:
+            return None, "Invalid path or access denied"
+        
+        if not resolved.exists():
+            return None, f"File not found: {file_path}"
+        
+        if resolved.is_dir():
+            return None, "Path is a directory, not a file"
+        
+        # Check size
+        size = resolved.stat().st_size
+        if size > max_size:
+            return None, f"File too large ({size / (1024*1024):.1f} MB > {max_size / (1024*1024):.1f} MB limit)"
+        
+        try:
+            with open(resolved, 'r', encoding='utf-8', errors='replace') as f:
+                return f.read(), None
+        except Exception as e:
+            return None, f"Error reading file: {str(e)}"
+    
+    @staticmethod
+    def list_directory(dir_path: str) -> Tuple[Optional[List[dict]], Optional[str]]:
+        """
+        List directory contents safely.
+        
+        Returns: (items, error_message)
+        """
+        resolved = FileUtils.validate_path(dir_path)
+        
+        if not resolved:
+            return None, "Invalid path or access denied"
+        
+        if not resolved.exists():
+            return None, f"Directory not found: {dir_path}"
+        
+        if not resolved.is_dir():
+            return None, "Path is not a directory"
+        
+        try:
+            items = []
+            for entry in sorted(resolved.iterdir()):
+                # Skip hidden files
+                if entry.name.startswith('.'):
+                    continue
+                items.append(FileUtils.get_file_info(entry))
+            return items, None
+        except Exception as e:
+            return None, f"Error reading directory: {str(e)}"
+    
+    @staticmethod
+    def search_files(query: str, max_results: int = 50) -> List[dict]:
+        """
+        Search for files by name across the project.
+        
+        Returns list of matching file info dicts.
+        """
+        results = []
+        query_lower = query.lower()
+        
+        try:
+            for root, dirs, files in os.walk(PROJECT_ROOT):
+                # Skip hidden directories and common ignores
+                dirs[:] = [d for d in dirs if not d.startswith('.') and 
+                          d not in ('node_modules', 'dist', 'build', '.git', '__pycache__', 'coverage')]
+                
+                for name in files:
+                    if query_lower in name.lower():
+                        file_path = Path(root) / name
+                        try:
+                            info = FileUtils.get_file_info(file_path)
+                            results.append(info)
+                            if len(results) >= max_results:
+                                return results
+                        except (OSError, PermissionError):
+                            continue
+                        
+        except Exception:
+            pass
+        
+        return results
+    
+    @staticmethod
+    def get_language_from_ext(ext: str) -> str:
+        """Get language identifier from file extension"""
+        languages = {
+            '.ts': 'typescript', '.tsx': 'typescript',
+            '.js': 'javascript', '.jsx': 'javascript',
+            '.json': 'json',
+            '.yaml': 'yaml', '.yml': 'yaml',
+            '.star': 'python',  # Starlark is Python-like
+            '.py': 'python',
+            '.md': 'markdown',
+            '.prisma': 'prisma',
+            '.dockerfile': 'dockerfile',
+            '.sh': 'bash',
+            '.css': 'css', '.scss': 'scss', '.less': 'less',
+            '.html': 'html', '.htm': 'html',
+            '.sql': 'sql',
+            '.go': 'go',
+            '.rs': 'rust',
+            '.java': 'java',
+        }
+        
+        return languages.get(ext, 'text')
+
+
+if __name__ == '__main__':
+    # Quick test
+    print(f"Project root: {PROJECT_ROOT}")
+    
+    # Test validate_path
+    test_paths = [
+        '.',
+        'services/product/staff',
+        '../outside',  # Should fail
+        '/etc/passwd',  # Should fail
+    ]
+    
+    for path in test_paths:
+        result = FileUtils.validate_path(path)
+        print(f"Path '{path}': {result}")

package/ext/ide-components/shared/http_utils.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+"""
+Shared HTTP handler utilities for Tilt IDE components.
+Provides a base handler class with common HTTP functionality.
+"""
+
+import json
+from http.server import BaseHTTPRequestHandler
+from pathlib import Path
+from typing import Optional
+
+
+class BaseIDEHandler(BaseHTTPRequestHandler):
+    """
+    Base HTTP handler for Tilt IDE components.
+    
+    Provides common functionality:
+    - JSON/HTML response helpers
+    - HTML escaping for XSS prevention
+    - Page rendering with shared template
+    - Suppressed logging
+    """
+    
+    # Shared template fallback (used when base.html is not found)
+    DEFAULT_TEMPLATE = '''<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title}</title>
+    <link rel="stylesheet" href="/static/styles.css">
+</head>
+<body>
+    <header class="header">
+        <h1>{icon} {title}</h1>
+        {controls}
+    </header>
+    <div class="container">
+        {sidebar}
+        <main class="content">{content}</main>
+    </div>
+    {scripts}
+</body>
+</html>'''
+    
+    def log_message(self, format, *args):
+        """Suppress default request logging."""
+        pass
+    
+    def send_json_response(self, data: dict, status: int = 200) -> None:
+        """
+        Send a JSON response with CORS headers.
+        
+        Args:
+            data: Response data to serialize as JSON
+            status: HTTP status code (default: 200)
+        """
+        self.send_response(status)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode())
+    
+    def send_html_response(self, html: str, status: int = 200) -> None:
+        """
+        Send an HTML response with CORS headers.
+        
+        Args:
+            html: HTML content to send
+            status: HTTP status code (default: 200)
+        """
+        self.send_response(status)
+        self.send_header('Content-Type', 'text/html; charset=utf-8')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.end_headers()
+        self.wfile.write(html.encode())
+    
+    def send_css_response(self, css: str) -> None:
+        """
+        Send a CSS response.
+        
+        Args:
+            css: CSS content to send
+        """
+        self.send_response(200)
+        self.send_header('Content-Type', 'text/css')
+        self.end_headers()
+        self.wfile.write(css.encode())
+    
+    def send_error_response(self, status: int, message: str) -> None:
+        """
+        Send an error response.
+        
+        Args:
+            status: HTTP status code
+            message: Error message
+        """
+        self.send_response(status)
+        self.send_header('Content-Type', 'text/plain')
+        self.end_headers()
+        self.wfile.write(message.encode())
+    
+    @staticmethod
+    def escape_html(text: str) -> str:
+        """
+        Escape HTML special characters to prevent XSS attacks.
+        
+        Args:
+            text: Raw text to escape
+            
+        Returns:
+            Escaped text safe for HTML insertion
+        """
+        return (text
+                .replace('&', '&amp;')
+                .replace('<', '&lt;')
+                .replace('>', '&gt;')
+                .replace('"', '&quot;')
+                .replace("'", '&#x27;'))
+    
+    def render_page(
+        self,
+        title: str,
+        content: str,
+        icon: str = '📄',
+        sidebar: str = '',
+        controls: str = '',
+        scripts: str = ''
+    ) -> str:
+        """
+        Render a full HTML page using the base template.
+        
+        Args:
+            title: Page title
+            content: Main content HTML
+            icon: Emoji icon for the page header
+            sidebar: Sidebar HTML (optional)
+            controls: Header controls HTML (optional)
+            scripts: Scripts to include before </body> (optional)
+            
+        Returns:
+            Complete HTML page as string
+        """
+        # Try to load template from file
+        template = self._load_template()
+        
+        # Build sidebar wrapper if content provided
+        sidebar_html = f'<aside class="sidebar">{sidebar}</aside>' if sidebar else ''
+        
+        # Use string replacement to avoid conflicts with JS braces
+        result = template.replace('{title}', self.escape_html(title))
+        result = result.replace('{icon}', icon)
+        result = result.replace('{favicon}', icon)
+        result = result.replace('{controls}', controls)
+        result = result.replace('{sidebar}', sidebar_html)
+        result = result.replace('{content}', content)
+        result = result.replace('{scripts}', scripts)
+        
+        return result
+    
+    def _load_template(self) -> str:
+        """Load base template from file or return default."""
+        try:
+            template_path = self._get_template_path()
+            if template_path and template_path.exists():
+                with open(template_path, 'r', encoding='utf-8') as f:
+                    return f.read()
+        except Exception:
+            pass
+        return self.DEFAULT_TEMPLATE
+    
+    def _get_template_path(self) -> Optional[Path]:
+        """Get path to base template. Override in subclasses if needed."""
+        # Default: look in shared/templates/ relative to this file
+        shared_dir = Path(__file__).parent
+        return shared_dir / 'templates' / 'base.html'
+    
+    def handle_health_check(self, service_name: str, features: Optional[list] = None) -> None:
+        """
+        Handle a standard health check request.
+        
+        Args:
+            service_name: Name of the service for the response
+            features: Optional list of service features/capabilities
+        """
+        response = {
+            'status': 'ok',
+            'service': service_name
+        }
+        if features:
+            response['features'] = features
+        self.send_json_response(response)
+
+
+def run_server(server_class, port: int, service_name: str, service_description: str) -> None:
+    """
+    Run an HTTP server with standard configuration.
+    
+    Args:
+        server_class: The HTTP handler class to use
+        port: Port number to listen on
+        service_name: Name of the service for startup message
+        service_description: Brief description of the service
+    """
+    from http.server import HTTPServer
+    
+    server = HTTPServer(('127.0.0.1', port), server_class)
+    print(f"{service_name} running at http://localhost:{port}")
+    if service_description:
+        print(f"   {service_description}")
+    
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+        server.shutdown()
+
+
+# Backwards compatibility: standalone functions that delegate to class methods
+def send_json_response(handler: BaseHTTPRequestHandler, data: dict, status: int = 200) -> None:
+    """Standalone function for sending JSON responses (legacy compatibility)."""
+    BaseIDEHandler.send_json_response(handler, data, status)
+
+
+def send_html_response(handler: BaseHTTPRequestHandler, html: str, status: int = 200) -> None:
+    """Standalone function for sending HTML responses (legacy compatibility)."""
+    BaseIDEHandler.send_html_response(handler, html, status)
+
+
+def escape_html(text: str) -> str:
+    """Standalone function for HTML escaping (legacy compatibility)."""
+    return BaseIDEHandler.escape_html(text)