aegis-framework 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Diego
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,239 @@
+# ⚡ Aegis Framework
+
+**A lightweight alternative to Electron for Linux desktop apps.**
+
+Create desktop applications with HTML, CSS, and JavaScript that package into ~200KB AppImages instead of 150MB!
+
+## 📊 Size Comparison
+
+| Framework | Typical App Size | Aegis App |
+|-----------|-----------------|-----------|
+| **Electron** | 150-200 MB | - |
+| **Aegis** | - | **~200 KB** |
+
+**That's 700x smaller!**
+
+## 🚀 Installation
+
+```bash
+# Install globally via npm
+npm install -g aegis-framework
+
+# Or use npx without installing
+npx aegis-framework init my-app
+```
+
+### System Requirements (Linux only)
+
+```bash
+# Ubuntu/Debian
+sudo apt install python3 python3-gi gir1.2-webkit2-4.1
+
+# Fedora
+sudo dnf install python3 python3-gobject webkit2gtk4.1
+
+# Arch
+sudo pacman -S python python-gobject webkit2gtk-4.1
+```
+
+## 🏁 Quick Start
+
+```bash
+# Create a new project
+aegis init my-app
+
+# Enter the directory
+cd my-app
+
+# Start development server
+aegis dev
+
+# Build AppImage
+aegis build
+```
+
+## 📁 Project Structure
+
+```
+my-app/
+├── aegis.config.json    # Configuration
+├── src/
+│   ├── index.html       # Main HTML
+│   ├── styles.css       # Styles
+│   ├── app.js           # JavaScript
+│   └── preload.js       # Security config
+└── assets/
+    └── icon.png         # App icon
+```
+
+## 🔌 API Reference
+
+### File Operations
+
+```javascript
+// Read directory
+const dir = await Aegis.read({ path: '/home/user' });
+console.log(dir.entries);
+
+// Read file
+const file = await Aegis.read({ path: '/home/user', file: 'data.txt' });
+console.log(file.content);
+
+// Write file
+await Aegis.write({
+    path: '/home/user',
+    file: 'output.txt',
+    content: 'Hello World!'
+});
+
+// Check existence
+const info = await Aegis.exists({ path: '/home/user/file.txt' });
+
+// Create directory
+await Aegis.mkdir({ path: '/home/user/new-folder' });
+
+// Delete
+await Aegis.remove({ path: '/home/user/old-file.txt' });
+
+// Copy
+await Aegis.copy({ src: '/path/from', dest: '/path/to' });
+
+// Move/Rename
+await Aegis.move({ src: '/path/from', dest: '/path/to' });
+```
+
+### Dialogs
+
+```javascript
+// Message dialog
+await Aegis.dialog.message({
+    type: 'info',  // info, warning, error, question
+    title: 'Hello',
+    message: 'World!'
+});
+
+// Confirmation dialog
+const result = await Aegis.dialog.message({
+    type: 'question',
+    title: 'Confirm',
+    message: 'Are you sure?',
+    buttons: 'yesno'
+});
+if (result.response) { /* User clicked Yes */ }
+
+// Open file dialog
+const file = await Aegis.dialog.open({
+    title: 'Select File',
+    filters: [{ name: 'Images', extensions: ['png', 'jpg'] }]
+});
+
+// Save file dialog
+const savePath = await Aegis.dialog.save({
+    title: 'Save As',
+    defaultName: 'document.txt'
+});
+```
+
+### App Control
+
+```javascript
+// Window controls
+await Aegis.app.minimize();
+await Aegis.app.maximize();
+await Aegis.app.quit();
+
+// Get system paths (localized!)
+const home = await Aegis.app.getPath({ name: 'home' });
+const docs = await Aegis.app.getPath({ name: 'documents' });
+// Also: desktop, downloads, music, pictures, videos
+```
+
+### Window Control (Frameless)
+
+```javascript
+// Make element draggable for window movement
+Aegis.window.moveBar('#titlebar', { exclude: '.btn' });
+
+// Setup resize handles
+Aegis.window.resizeHandles({
+    '.resize-n': 'n',
+    '.resize-s': 's',
+    '.resize-se': 'se'
+    // etc: e, w, ne, nw, sw
+});
+
+// Get/set size
+const size = await Aegis.window.getSize();
+await Aegis.window.setSize({ width: 1024, height: 768 });
+
+// Get/set position
+const pos = await Aegis.window.getPosition();
+await Aegis.window.setPosition({ x: 100, y: 100 });
+```
+
+### Run Commands
+
+```javascript
+// Shell command
+const result = await Aegis.run({ sh: 'ls -la' });
+console.log(result.output);
+
+// Python code
+const py = await Aegis.run({ py: '2 + 2' });
+console.log(py.output);  // "4"
+```
+
+## 🔒 Security (preload.js)
+
+Control which APIs are exposed to your frontend:
+
+```javascript
+// src/preload.js
+Aegis.expose([
+    'read',     // Allow file reading
+    'write',    // Allow file writing
+    'dialog',   // Allow dialogs
+    'app',      // Allow app control
+    'window',   // Allow window control
+    // Omit 'run' to prevent command execution!
+]);
+```
+
+## ⚙️ Configuration (aegis.config.json)
+
+```json
+{
+    "name": "my-app",
+    "title": "My Application",
+    "version": "1.0.0",
+    "main": "src/index.html",
+    "preload": "src/preload.js",
+    "width": 1200,
+    "height": 800,
+    "frame": true,
+    "resizable": true,
+    "icon": "assets/icon.png"
+}
+```
+
+Set `"frame": false` for frameless window (custom titlebar).
+
+## 🤔 Why Aegis?
+
+| Feature | Electron | Aegis |
+|---------|----------|-------|
+| Size | ~150 MB | **~200 KB** |
+| Backend | Node.js | **Python** |
+| Renderer | Chromium (bundled) | **WebKit2GTK (system)** |
+| Platform | Cross-platform | **Linux** |
+| RAM Usage | High | **Low** |
+
+Aegis uses the WebKit that's already installed on Linux systems, so apps are tiny!
+
+## 📜 License
+
+MIT © Diego
+
+---
+
+Made with ❤️ for the Linux community

package/aegis/__init__.py

@@ -0,0 +1,19 @@
+"""
+Aegis - Lightweight AppImage Framework
+A modern alternative to Electron using WebKit2GTK and Python
+"""
+
+__version__ = "0.1.0"
+__author__ = "Diego"
+
+# Lazy imports to allow CLI to work without GTK installed
+def __getattr__(name):
+    if name == 'AegisApp':
+        from aegis.core.aegis import AegisApp
+        return AegisApp
+    elif name == 'AegisWindow':
+        from aegis.core.window import AegisWindow
+        return AegisWindow
+    raise AttributeError(f"module 'aegis' has no attribute '{name}'")
+
+__all__ = ['AegisApp', 'AegisWindow']

package/aegis/builder/__init__.py

@@ -0,0 +1,5 @@
+"""Aegis Builder - AppImage packaging"""
+
+from aegis.builder.builder import AegisBuilder
+
+__all__ = ['AegisBuilder']

package/aegis/builder/builder.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""
+Aegis Builder - AppImage Packaging System
+
+Creates lightweight AppImages from Aegis projects.
+"""
+
+import os
+import sys
+import json
+import shutil
+import stat
+import subprocess
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+
+class AegisBuilder:
+    """
+    Builds AppImages from Aegis projects
+    """
+    
+    APPIMAGETOOL_URL = "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage"
+    
+    def __init__(self, project_dir: str = '.'):
+        self.project_dir = Path(project_dir).resolve()
+        self.config = self._load_config()
+        
+    def _load_config(self) -> dict:
+        """Load project configuration"""
+        config_path = self.project_dir / 'aegis.config.json'
+        if config_path.exists():
+            with open(config_path) as f:
+                return json.load(f)
+        return {}
+    
+    def build(self, output_dir: str = 'dist', name: Optional[str] = None) -> str:
+        """
+        Build the AppImage
+        
+        Args:
+            output_dir: Output directory for the AppImage
+            name: Custom name for the AppImage
+            
+        Returns:
+            Path to the created AppImage
+        """
+        app_name = name or self.config.get('name', 'AegisApp')
+        output_path = Path(output_dir).resolve()
+        appdir = output_path / f'{app_name}.AppDir'
+        
+        print(f"📦 Building: {app_name}")
+        
+        # Clean and create AppDir
+        if appdir.exists():
+            shutil.rmtree(appdir)
+        appdir.mkdir(parents=True)
+        
+        # Create AppDir structure
+        self._create_appdir_structure(appdir, app_name)
+        
+        # Copy project files
+        self._copy_project_files(appdir)
+        
+        # Copy Aegis runtime
+        self._copy_aegis_runtime(appdir)
+        
+        # Create AppRun script
+        self._create_apprun(appdir, app_name)
+        
+        # Create .desktop file
+        self._create_desktop_file(appdir, app_name)
+        
+        # Create icon
+        self._create_icon(appdir, app_name)
+        
+        # Download appimagetool if needed
+        appimagetool = self._ensure_appimagetool(output_path)
+        
+        # Build AppImage
+        appimage_path = output_path / f'{app_name}-x86_64.AppImage'
+        self._build_appimage(appdir, appimage_path, appimagetool)
+        
+        return str(appimage_path)
+    
+    def _create_appdir_structure(self, appdir: Path, app_name: str):
+        """Create AppDir directory structure"""
+        dirs = [
+            'usr/bin',
+            'usr/lib/aegis',
+            'usr/share/applications',
+            'usr/share/icons/hicolor/256x256/apps',
+            'usr/share/aegis/runtime',
+            'app'
+        ]
+        for d in dirs:
+            (appdir / d).mkdir(parents=True, exist_ok=True)
+        
+        print("  📁 Created AppDir structure")
+    
+    def _copy_project_files(self, appdir: Path):
+        """Copy project files to AppDir"""
+        app_dir = appdir / 'app'
+        
+        # Copy all project files except dist, __pycache__, etc.
+        exclude = {'.git', '__pycache__', 'dist', '.venv', 'node_modules', '*.AppDir'}
+        
+        for item in self.project_dir.iterdir():
+            if item.name in exclude or item.suffix == '.AppDir':
+                continue
+            
+            dest = app_dir / item.name
+            if item.is_dir():
+                shutil.copytree(item, dest, ignore=shutil.ignore_patterns(*exclude))
+            else:
+                shutil.copy2(item, dest)
+        
+        print("  📄 Copied project files")
+    
+    def _copy_aegis_runtime(self, appdir: Path):
+        """Copy Aegis runtime files"""
+        aegis_dir = Path(__file__).parent.parent
+        runtime_dir = appdir / 'usr/share/aegis'
+        
+        # Create directory
+        runtime_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Copy core modules
+        shutil.copytree(
+            aegis_dir / 'core',
+            runtime_dir / 'core',
+            ignore=shutil.ignore_patterns('__pycache__', '*.pyc'),
+            dirs_exist_ok=True
+        )
+        
+        # Copy runtime (JS API)
+        shutil.copytree(
+            aegis_dir / 'runtime',
+            runtime_dir / 'runtime',
+            ignore=shutil.ignore_patterns('__pycache__', '*.pyc'),
+            dirs_exist_ok=True
+        )
+        
+        # Create __init__.py
+        init_content = '''"""Aegis Runtime"""
+from aegis.core.aegis import AegisApp
+'''
+        with open(runtime_dir / '__init__.py', 'w') as f:
+            f.write(init_content)
+        
+        print("  ⚡ Copied Aegis runtime")
+    
+    def _create_apprun(self, appdir: Path, app_name: str):
+        """Create AppRun script"""
+        apprun_content = '''#!/bin/bash
+# Aegis AppRun Script
+
+# Get the directory where AppImage is mounted
+APPDIR="$(dirname "$(readlink -f "$0")")"
+
+# Set up Python path
+export PYTHONPATH="$APPDIR/usr/share:$PYTHONPATH"
+
+# Change to app directory
+cd "$APPDIR/app"
+
+# Run Aegis app
+exec python3 -c "
+import sys
+sys.path.insert(0, '$APPDIR/usr/share')
+from aegis.core.aegis import AegisApp
+app = AegisApp()
+app.run()
+"
+'''
+        apprun_path = appdir / 'AppRun'
+        with open(apprun_path, 'w') as f:
+            f.write(apprun_content)
+        
+        # Make executable
+        apprun_path.chmod(apprun_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        
+        print("  🚀 Created AppRun script")
+    
+    def _create_desktop_file(self, appdir: Path, app_name: str):
+        """Create .desktop file"""
+        desktop_content = f'''[Desktop Entry]
+Type=Application
+Name={self.config.get('title', app_name)}
+Exec=AppRun
+Icon={app_name.lower()}
+Categories=Utility;
+Comment={self.config.get('description', 'An Aegis application')}
+Terminal=false
+'''
+        # Write to AppDir root and usr/share/applications
+        for path in [appdir / f'{app_name}.desktop', 
+                     appdir / 'usr/share/applications' / f'{app_name}.desktop']:
+            with open(path, 'w') as f:
+                f.write(desktop_content)
+        
+        print("  📋 Created .desktop file")
+    
+    def _create_icon(self, appdir: Path, app_name: str):
+        """Create or copy app icon"""
+        icon_source = self.project_dir / self.config.get('icon', 'assets/icon.png')
+        
+        if icon_source.exists():
+            # Copy existing icon
+            shutil.copy2(icon_source, appdir / f'{app_name.lower()}.png')
+            shutil.copy2(
+                icon_source, 
+                appdir / 'usr/share/icons/hicolor/256x256/apps' / f'{app_name.lower()}.png'
+            )
+            print("  🎨 Copied app icon")
+        else:
+            # Create a simple placeholder icon (1x1 transparent PNG)
+            # In production, you'd want to generate a proper icon
+            placeholder = appdir / f'{app_name.lower()}.png'
+            self._create_placeholder_icon(placeholder)
+            shutil.copy2(
+                placeholder,
+                appdir / 'usr/share/icons/hicolor/256x256/apps' / f'{app_name.lower()}.png'
+            )
+            print("  🎨 Created placeholder icon")
+    
+    def _create_placeholder_icon(self, path: Path):
+        """Create a simple placeholder PNG icon"""
+        # Minimal valid PNG (1x1 transparent pixel)
+        # In a real scenario, we'd generate a proper icon with cairo or PIL
+        png_data = bytes([
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,  # PNG signature
+            0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,  # IHDR chunk
+            0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,  # 1x1
+            0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4,
+            0x89, 0x00, 0x00, 0x00, 0x0A, 0x49, 0x44, 0x41,
+            0x54, 0x78, 0x9C, 0x63, 0x00, 0x01, 0x00, 0x00,
+            0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00,
+            0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE,
+            0x42, 0x60, 0x82
+        ])
+        with open(path, 'wb') as f:
+            f.write(png_data)
+    
+    def _ensure_appimagetool(self, output_path: Path) -> Path:
+        """Download appimagetool if not present"""
+        tool_path = output_path / 'appimagetool'
+        
+        if not tool_path.exists():
+            print("  📥 Downloading appimagetool...")
+            urllib.request.urlretrieve(self.APPIMAGETOOL_URL, tool_path)
+            tool_path.chmod(tool_path.stat().st_mode | stat.S_IXUSR)
+        
+        return tool_path
+    
+    def _build_appimage(self, appdir: Path, output: Path, appimagetool: Path):
+        """Build the final AppImage"""
+        print("  🔨 Building AppImage...")
+        
+        env = os.environ.copy()
+        env['ARCH'] = 'x86_64'
+        
+        result = subprocess.run(
+            [str(appimagetool), str(appdir), str(output)],
+            env=env,
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            print(f"  ❌ appimagetool error: {result.stderr}")
+            raise RuntimeError(f"appimagetool failed: {result.stderr}")
+        
+        # Clean up AppDir
+        shutil.rmtree(appdir)
+        
+        print(f"  ✅ AppImage created: {output.name}")
+
+
+def build_project(project_dir: str = '.', output_dir: str = 'dist', name: str = None) -> str:
+    """
+    Convenience function to build a project
+    
+    Args:
+        project_dir: Path to the project
+        output_dir: Output directory
+        name: Custom AppImage name
+        
+    Returns:
+        Path to the created AppImage
+    """
+    builder = AegisBuilder(project_dir)
+    return builder.build(output_dir, name)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        build_project(sys.argv[1])
+    else:
+        build_project()

package/aegis/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Aegis CLI - Command Line Interface"""
+
+from aegis.cli.cli import main, AegisCLI
+
+__all__ = ['main', 'AegisCLI']