aegis-framework 0.1.0

package/aegis/core/aegis.py

@@ -0,0 +1,97 @@
+"""
+Aegis App - Main Application Class
+High-level API for creating Aegis applications
+"""
+
+import os
+import json
+from aegis.core.window import AegisWindow
+
+
+class AegisApp:
+    """
+    Main entry point for Aegis applications
+    
+    Usage:
+        app = AegisApp()
+        app.run()
+    """
+    
+    def __init__(self, config_path=None):
+        """
+        Initialize Aegis application
+        
+        Args:
+            config_path: Path to aegis.config.json (optional)
+        """
+        self.config = self._load_config(config_path)
+        self.window = None
+        self.project_dir = os.getcwd()
+        
+    def _load_config(self, config_path=None):
+        """Load configuration from aegis.config.json"""
+        if config_path is None:
+            config_path = 'aegis.config.json'
+        
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                return json.load(f)
+        
+        # Default configuration
+        return {
+            'name': 'Aegis App',
+            'title': 'Aegis App',
+            'version': '1.0.0',
+            'main': 'index.html',
+            'preload': 'preload.js',
+            'width': 1200,
+            'height': 800,
+            'resizable': True,
+            'frame': True,
+            'devTools': True,
+            'contextMenu': True
+        }
+    
+    def create_window(self, **options):
+        """
+        Create a new window with optional overrides
+        
+        Args:
+            **options: Override config options for this window
+        """
+        window_config = {**self.config, **options}
+        self.window = AegisWindow(window_config)
+        
+        # Inject Aegis API
+        preload_path = os.path.join(self.project_dir, self.config.get('preload', 'preload.js'))
+        self.window.inject_aegis_api(preload_path)
+        
+        return self.window
+    
+    def run(self):
+        """Start the application"""
+        if self.window is None:
+            self.create_window()
+        
+        # Load main HTML file
+        main_file = os.path.join(self.project_dir, self.config.get('main', 'index.html'))
+        self.window.load_file(main_file)
+        
+        # Start the main loop
+        self.window.run()
+
+
+def run_app(config_path=None):
+    """
+    Convenience function to run an Aegis app
+    
+    Args:
+        config_path: Optional path to config file
+    """
+    app = AegisApp(config_path)
+    app.run()
+
+
+# Allow running as module: python -m aegis.core.aegis
+if __name__ == '__main__':
+    run_app()

package/aegis/core/bridge.py

@@ -0,0 +1,270 @@
+"""
+Aegis Bridge - Python ↔ JavaScript Communication
+Handles IPC messaging between frontend and backend
+"""
+
+import json
+import os
+import subprocess
+import threading
+from typing import Callable, Dict, Any, Optional
+
+
+class AegisBridge:
+    """
+    Manages communication between Python backend and JavaScript frontend
+    """
+    
+    def __init__(self):
+        self._handlers: Dict[str, Callable] = {}
+        self._allowed_actions: set = set()
+        self._register_default_handlers()
+    
+    def _register_default_handlers(self):
+        """Register built-in action handlers"""
+        self.register('read', self._handle_read)
+        self.register('write', self._handle_write)
+        self.register('run', self._handle_run)
+        self.register('exists', self._handle_exists)
+        self.register('mkdir', self._handle_mkdir)
+        self.register('remove', self._handle_remove)
+        self.register('copy', self._handle_copy)
+        self.register('move', self._handle_move)
+        self.register('env', self._handle_env)
+    
+    def register(self, action: str, handler: Callable):
+        """
+        Register a custom action handler
+        
+        Args:
+            action: Action name (e.g., 'myAction')
+            handler: Function that takes payload dict and returns result dict
+        """
+        self._handlers[action] = handler
+    
+    def allow(self, *actions: str):
+        """
+        Set which actions are allowed (preload security)
+        
+        Args:
+            *actions: Action names to allow
+        """
+        self._allowed_actions.update(actions)
+    
+    def allow_all(self):
+        """Allow all registered actions"""
+        self._allowed_actions = set(self._handlers.keys())
+    
+    def is_allowed(self, action: str) -> bool:
+        """Check if an action is allowed"""
+        # If no restrictions set, allow all
+        if not self._allowed_actions:
+            return True
+        return action in self._allowed_actions
+    
+    def process(self, action: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process an action request
+        
+        Args:
+            action: Action name
+            payload: Action payload
+            
+        Returns:
+            Result dictionary
+        """
+        if not self.is_allowed(action):
+            raise PermissionError(f"Action '{action}' is not allowed by preload")
+        
+        handler = self._handlers.get(action)
+        if not handler:
+            raise ValueError(f"Unknown action: {action}")
+        
+        return handler(payload)
+    
+    # ==================== Built-in Handlers ====================
+    
+    def _handle_read(self, payload: Dict) -> Dict:
+        """Read file contents"""
+        path = payload.get('path', '.')
+        file = payload.get('file')
+        encoding = payload.get('encoding', 'utf-8')
+        binary = payload.get('binary', False)
+        
+        if file:
+            full_path = os.path.join(path, file)
+        else:
+            full_path = path
+        
+        if os.path.isdir(full_path):
+            # List directory
+            entries = []
+            for entry in os.listdir(full_path):
+                entry_path = os.path.join(full_path, entry)
+                stat = os.stat(entry_path)
+                entries.append({
+                    'name': entry,
+                    'isDirectory': os.path.isdir(entry_path),
+                    'isFile': os.path.isfile(entry_path),
+                    'size': stat.st_size,
+                    'modified': stat.st_mtime
+                })
+            return {'entries': entries, 'path': full_path}
+        else:
+            # Read file
+            mode = 'rb' if binary else 'r'
+            with open(full_path, mode, encoding=None if binary else encoding) as f:
+                content = f.read()
+                if binary:
+                    import base64
+                    content = base64.b64encode(content).decode('ascii')
+            return {'content': content, 'path': full_path}
+    
+    def _handle_write(self, payload: Dict) -> Dict:
+        """Write file contents"""
+        path = payload.get('path', '.')
+        file = payload.get('file')
+        content = payload.get('content', '')
+        encoding = payload.get('encoding', 'utf-8')
+        append = payload.get('append', False)
+        binary = payload.get('binary', False)
+        
+        if file:
+            full_path = os.path.join(path, file)
+        else:
+            full_path = path
+        
+        # Create parent directories
+        parent = os.path.dirname(full_path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        
+        mode = 'ab' if append and binary else 'a' if append else 'wb' if binary else 'w'
+        
+        with open(full_path, mode, encoding=None if binary else encoding) as f:
+            if binary:
+                import base64
+                f.write(base64.b64decode(content))
+            else:
+                f.write(content)
+        
+        return {'success': True, 'path': full_path}
+    
+    def _handle_run(self, payload: Dict) -> Dict:
+        """Execute commands"""
+        if 'py' in payload:
+            # Execute Python code
+            code = payload['py']
+            local_vars = {}
+            try:
+                # Try eval first (for expressions)
+                result = eval(code)
+                return {'output': str(result), 'exitCode': 0}
+            except SyntaxError:
+                # Fall back to exec (for statements)
+                exec(code, {}, local_vars)
+                return {'output': str(local_vars), 'exitCode': 0}
+            except Exception as e:
+                return {'error': str(e), 'exitCode': 1}
+        
+        elif 'sh' in payload:
+            # Execute shell command
+            cmd = payload['sh']
+            cwd = payload.get('cwd', os.getcwd())
+            timeout = payload.get('timeout', None)
+            
+            try:
+                result = subprocess.run(
+                    cmd,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    cwd=cwd,
+                    timeout=timeout
+                )
+                return {
+                    'output': result.stdout,
+                    'error': result.stderr,
+                    'exitCode': result.returncode
+                }
+            except subprocess.TimeoutExpired:
+                return {'error': 'Command timed out', 'exitCode': -1}
+            except Exception as e:
+                return {'error': str(e), 'exitCode': -1}
+        
+        return {'error': 'No py or sh command specified', 'exitCode': -1}
+    
+    def _handle_exists(self, payload: Dict) -> Dict:
+        """Check if path exists"""
+        path = payload.get('path')
+        return {
+            'exists': os.path.exists(path),
+            'isFile': os.path.isfile(path),
+            'isDirectory': os.path.isdir(path)
+        }
+    
+    def _handle_mkdir(self, payload: Dict) -> Dict:
+        """Create directory"""
+        path = payload.get('path')
+        recursive = payload.get('recursive', True)
+        
+        if recursive:
+            os.makedirs(path, exist_ok=True)
+        else:
+            os.mkdir(path)
+        
+        return {'success': True, 'path': path}
+    
+    def _handle_remove(self, payload: Dict) -> Dict:
+        """Remove file or directory"""
+        import shutil
+        path = payload.get('path')
+        recursive = payload.get('recursive', False)
+        
+        if os.path.isdir(path):
+            if recursive:
+                shutil.rmtree(path)
+            else:
+                os.rmdir(path)
+        else:
+            os.remove(path)
+        
+        return {'success': True}
+    
+    def _handle_copy(self, payload: Dict) -> Dict:
+        """Copy file or directory"""
+        import shutil
+        src = payload.get('src')
+        dest = payload.get('dest')
+        
+        if os.path.isdir(src):
+            shutil.copytree(src, dest)
+        else:
+            shutil.copy2(src, dest)
+        
+        return {'success': True, 'dest': dest}
+    
+    def _handle_move(self, payload: Dict) -> Dict:
+        """Move/rename file or directory"""
+        import shutil
+        src = payload.get('src')
+        dest = payload.get('dest')
+        
+        shutil.move(src, dest)
+        return {'success': True, 'dest': dest}
+    
+    def _handle_env(self, payload: Dict) -> Dict:
+        """Get/set environment variables"""
+        name = payload.get('name')
+        value = payload.get('value')
+        
+        if value is not None:
+            # Set environment variable
+            os.environ[name] = value
+            return {'success': True}
+        elif name:
+            # Get single variable
+            return {'value': os.environ.get(name)}
+        else:
+            # Get all variables
+            return {'env': dict(os.environ)}

package/aegis/core/preload.py

@@ -0,0 +1,160 @@
+"""
+Aegis Preload Security System
+Parses preload.js to determine which APIs should be exposed
+"""
+
+import re
+import json
+import os
+from typing import Set, Dict, Any, List
+
+
+class PreloadManager:
+    """
+    Manages the preload security configuration
+    
+    The preload.js file defines which Aegis APIs are exposed to the frontend.
+    This provides a security layer to prevent malicious code from accessing
+    sensitive system operations.
+    """
+    
+    def __init__(self):
+        self.allowed_apis: Set[str] = set()
+        self.custom_handlers: Dict[str, str] = {}
+        self.config: Dict[str, Any] = {}
+    
+    def load(self, preload_path: str) -> bool:
+        """
+        Load and parse a preload.js file
+        
+        Args:
+            preload_path: Path to preload.js
+            
+        Returns:
+            True if loaded successfully
+        """
+        if not os.path.exists(preload_path):
+            return False
+        
+        with open(preload_path, 'r') as f:
+            content = f.read()
+        
+        self._parse_preload(content)
+        return True
+    
+    def _parse_preload(self, content: str):
+        """Parse preload.js content to extract configuration"""
+        
+        # Look for Aegis.expose() calls
+        # Aegis.expose(['read', 'write', 'run'])
+        expose_pattern = r'Aegis\.expose\s*\(\s*\[(.*?)\]\s*\)'
+        matches = re.findall(expose_pattern, content, re.DOTALL)
+        
+        for match in matches:
+            # Extract API names from the array
+            apis = re.findall(r'["\'](\w+(?:\.\w+)*)["\']', match)
+            self.allowed_apis.update(apis)
+        
+        # Look for Aegis.exposeAll() - expose everything
+        if 'Aegis.exposeAll()' in content:
+            self.allowed_apis = {'*'}
+        
+        # Look for Aegis.config() calls
+        config_pattern = r'Aegis\.config\s*\(\s*(\{.*?\})\s*\)'
+        config_matches = re.findall(config_pattern, content, re.DOTALL)
+        
+        for match in config_matches:
+            try:
+                # Try to parse as JSON (basic JS object syntax)
+                # Replace single quotes with double quotes for JSON
+                json_str = match.replace("'", '"')
+                self.config.update(json.loads(json_str))
+            except json.JSONDecodeError:
+                pass
+        
+        # Look for custom handler definitions
+        # Aegis.handle('myAction', async (data) => { ... })
+        handler_pattern = r'Aegis\.handle\s*\(\s*["\'](\w+)["\']\s*,'
+        handler_matches = re.findall(handler_pattern, content)
+        
+        for handler_name in handler_matches:
+            self.custom_handlers[handler_name] = content
+    
+    def is_api_allowed(self, api_name: str) -> bool:
+        """
+        Check if an API is allowed
+        
+        Args:
+            api_name: Full API name (e.g., 'read', 'dialog.open')
+            
+        Returns:
+            True if the API is allowed
+        """
+        # If exposeAll was used, everything is allowed
+        if '*' in self.allowed_apis:
+            return True
+        
+        # Check exact match
+        if api_name in self.allowed_apis:
+            return True
+        
+        # Check namespace match (e.g., 'dialog' allows 'dialog.open')
+        namespace = api_name.split('.')[0]
+        if namespace in self.allowed_apis:
+            return True
+        
+        # If no APIs are explicitly allowed, allow all by default
+        # (for backwards compatibility and ease of use)
+        if not self.allowed_apis:
+            return True
+        
+        return False
+    
+    def get_allowed_list(self) -> List[str]:
+        """Get list of allowed APIs"""
+        return list(self.allowed_apis)
+    
+    def generate_js_config(self) -> str:
+        """Generate JavaScript configuration for the frontend"""
+        if '*' in self.allowed_apis:
+            allowed_js = '["*"]'
+        else:
+            allowed_js = json.dumps(list(self.allowed_apis))
+        
+        return f"""
+// Aegis Preload Configuration (auto-generated)
+window.__aegisAllowedAPIs = {allowed_js};
+window.__aegisConfig = {json.dumps(self.config)};
+"""
+
+
+def create_default_preload() -> str:
+    """Generate default preload.js content"""
+    return '''/**
+ * Aegis Preload Configuration
+ * 
+ * This file controls which Aegis APIs are exposed to your frontend.
+ * For security, only expose the APIs you actually need.
+ */
+
+// Expose specific APIs
+Aegis.expose([
+    'read',        // File reading
+    'write',       // File writing
+    'run',         // Command execution
+    'dialog',      // Native dialogs (open, save, message)
+    'app',         // App control (quit, minimize, maximize)
+    'exists',      // Check file/directory existence
+    'mkdir',       // Create directories
+    'env'          // Environment variables
+]);
+
+// Or expose everything (not recommended for production):
+// Aegis.exposeAll();
+
+// Optional: Configure Aegis behavior
+Aegis.config({
+    allowRemoteContent: false,
+    enableDevTools: true
+});
+'''