@ionyx-apps/cli 0.4.8 → 0.4.9

package/ionyx-cli/src/templates/src-ionyx/ipc_bridge.rs

@@ -0,0 +1,206 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use tracing::{error, info};
+
+use crate::config::Config;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcBridgeRequest {
+    pub source_app: String,
+    pub target_app: String,
+    pub command: String,
+    pub payload: Value,
+    pub id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcBridgeResponse {
+    pub id: String,
+    pub success: bool,
+    pub data: Option<Value>,
+    pub error: Option<String>,
+    pub source_app: String,
+    pub target_app: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppInfo {
+    pub name: String,
+    pub version: String,
+    pub pid: u32,
+    pub capabilities: Vec<String>,
+}
+
+pub struct IpcBridgeManager {
+    apps: Arc<RwLock<HashMap<String, AppInfo>>>,
+    config: Config,
+}
+
+impl IpcBridgeManager {
+    pub fn new(config: Config, _app_name: String) -> Self {
+        let apps = Arc::new(RwLock::new(HashMap::new()));
+
+        Self { apps, config }
+    }
+
+    pub async fn register_app(&self, app_info: AppInfo) -> Result<()> {
+        info!("Registering app: {} (PID: {})", app_info.name, app_info.pid);
+
+        let mut apps = self.apps.write().await;
+        apps.insert(app_info.name.clone(), app_info);
+
+        info!("App registered successfully. Total apps: {}", apps.len());
+        Ok(())
+    }
+
+    pub async fn unregister_app(&self, app_name: &str) -> Result<()> {
+        info!("Unregistering app: {}", app_name);
+
+        let mut apps = self.apps.write().await;
+        apps.remove(app_name);
+
+        info!("App unregistered successfully. Total apps: {}", apps.len());
+        Ok(())
+    }
+
+    pub async fn get_registered_apps(&self) -> Result<Vec<AppInfo>> {
+        let apps = self.apps.read().await;
+        Ok(apps.values().cloned().collect())
+    }
+
+    pub async fn send_to_app(&self, request: IpcBridgeRequest) -> Result<IpcBridgeResponse> {
+        info!(
+            "Sending IPC request from {} to {}: {}",
+            request.source_app, request.target_app, request.command
+        );
+
+        let source_app = request.source_app.clone();
+        let target_app = request.target_app.clone();
+
+        // Check if target app exists
+        let apps = self.apps.read().await;
+        if !apps.contains_key(&target_app) {
+            return Err(anyhow::anyhow!("Target app '{}' not found", target_app));
+        }
+
+        // Check if source app has permission to send to target app
+        if !self
+            .check_permissions(&source_app, &target_app, &request.command)
+            .await?
+        {
+            return Err(anyhow::anyhow!(
+                "Permission denied for command '{}' from '{}' to '{}'",
+                request.command,
+                source_app,
+                target_app
+            ));
+        }
+
+        // Process the request
+        let response = match self.process_bridge_request(&request).await {
+            Ok(data) => IpcBridgeResponse {
+                id: request.id,
+                success: true,
+                data: Some(data),
+                error: None,
+                source_app,
+                target_app,
+            },
+            Err(e) => IpcBridgeResponse {
+                id: request.id,
+                success: false,
+                data: None,
+                error: Some(e.to_string()),
+                source_app,
+                target_app,
+            },
+        };
+
+        info!(
+            "IPC request processed: {} -> {} ({})",
+            response.source_app, response.target_app, response.success
+        );
+
+        Ok(response)
+    }
+
+    pub async fn send_to_app_direct(&self, request: IpcBridgeRequest) -> Result<IpcBridgeResponse> {
+        self.process_bridge_request(&request)
+            .await
+            .map(|data| IpcBridgeResponse {
+                id: request.id,
+                success: true,
+                data: Some(data),
+                error: None,
+                source_app: request.source_app,
+                target_app: request.target_app,
+            })
+    }
+
+    async fn check_permissions(
+        &self,
+        _source_app: &str,
+        _target_app: &str,
+        _command: &str,
+    ) -> Result<bool> {
+        if self.config.permissions.bridge {
+            Ok(true)
+        } else {
+            error!("Bridge permission is disabled in config");
+            Ok(false)
+        }
+    }
+
+    async fn process_bridge_request(&self, request: &IpcBridgeRequest) -> Result<Value> {
+        match request.command.as_str() {
+            "app.getInfo" => {
+                let apps = self.apps.read().await;
+                if let Some(app_info) = apps.get(&request.target_app) {
+                    Ok(json!({
+                        "name": app_info.name,
+                        "version": app_info.version,
+                        "pid": app_info.pid,
+                        "capabilities": app_info.capabilities
+                    }))
+                } else {
+                    Err(anyhow::anyhow!("App '{}' not found", request.target_app))
+                }
+            }
+            "app.list" => {
+                let apps = self.apps.read().await;
+                let app_list: Vec<Value> = apps
+                    .values()
+                    .map(|app| {
+                        json!({
+                            "name": app.name,
+                            "version": app.version,
+                            "pid": app.pid,
+                            "capabilities": app.capabilities
+                        })
+                    })
+                    .collect();
+                Ok(json!(app_list))
+            }
+            "system.broadcast" => {
+                // Broadcast message to all registered apps
+                info!(
+                    "Broadcasting message from {}: {:?}",
+                    request.source_app, request.payload
+                );
+                Ok(json!({
+                    "broadcast_sent": true,
+                    "message": "Message broadcasted to all apps",
+                    "recipients": self.apps.read().await.len()
+                }))
+            }
+            _ => Err(anyhow::anyhow!(
+                "Unknown bridge command: {}",
+                request.command
+            )),
+        }
+    }
+}

package/ionyx-cli/src/templates/src-ionyx/lib.rs

@@ -1,136 +1,226 @@
 use anyhow::Result;
-use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::env;
+use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
-use wry::webview::WebView;
-use tracing::{info, error, debug};
-use crate::security::SecurityManager;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IpcRequest {
-    pub id: String,
-    pub command: String,
-    pub payload: serde_json::Value,
+use tao::event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy};
+use tracing::{error, info};
+use wry::{WebContext, WebViewBuilder};
+
+mod bridge;
+mod config;
+mod ipc_bridge;
+mod protocol;
+mod security;
+mod window;
+mod fusion;
+
+use fusion::FusionManager;
+
+use bridge::IpcBridge;
+use config::Config;
+
+// IPC Dispatcher for resolving frontend promises
+#[derive(Debug, Clone)]
+pub struct IpcDispatcher {
+    proxy: EventLoopProxy<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IpcResponse {
-    pub id: String,
-    pub success: bool,
-    pub data: Option<serde_json::Value>,
-    pub error: Option<String>,
-}
-
-pub struct IpcBridge {
-    config: crate::config::Config,
-    security: SecurityManager,
-}
-
-impl IpcBridge {
-    pub fn new(config: crate::config::Config) -> Self {
-        Self {
-            config,
-            security: SecurityManager::new(config.clone()),
-        }
+impl IpcDispatcher {
+    pub fn new(proxy: EventLoopProxy<String>) -> Self {
+        Self { proxy }
     }
 
-    pub async fn handle_request(
+    pub fn resolve_promise(
         &self,
-        request: String,
-        webview: &Arc<Mutex<Option<WebView>>>,
-        proxy: &tao::event_loop::EventLoopProxy<UserEvent>,
-    ) -> Result<()> {
-        info!("📨 Processing IPC request: {}", request);
-
-        let ipc_request: IpcRequest = serde_json::from_str(&request)
-            .map_err(|e| anyhow::anyhow!("Failed to parse IPC request: {}", e))?;
-
-        // Security check
-        if !self.security.is_command_allowed(&ipc_request.command) {
-            return Err(anyhow::anyhow!("Command 
-
- not allowed", ipc_request.command));
-        }
-
-        // Process command
-        let response = match self.process_command(&ipc_request).await {
-            Ok(data) => IpcResponse {
-                id: ipc_request.id,
-                success: true,
-                data: Some(data),
-                error: None,
-            },
-            Err(e) => IpcResponse {
-                id: ipc_request.id,
-                success: false,
-                data: None,
-                error: Some(e.to_string()),
-            },
-        };
+        request_id: &str,
+        success: bool,
+        data: Option<serde_json::Value>,
+        error: Option<String>,
+    ) {
+        let response = json!({
+            "id": request_id,
+            "success": success,
+            "data": data,
+            "error": error
+        });
 
-        // Send response back to frontend
-        let response_json = serde_json::to_string(&response)?;
         let js_code = format!(
-            "if (window.ionyx && window.ionyx.resolveResponse) {{ window.ionyx.resolveResponse(
-
-, {}); }}",
-            response.id,
-            response_json
+            "if (window.ionyx && window.ionyx.resolveResponse) {{ window.ionyx.resolveResponse('{}', {}); }}",
+            request_id,
+            response
         );
 
-        // Send JavaScript code to main thread
-        proxy.send_event(UserEvent::JavaScript(js_code));
-
-        info!("✅ IPC response sent for: {}", ipc_request.command);
-        Ok(())
-    }
-
-    async fn process_command(&self, request: &IpcRequest) -> Result<serde_json::Value> {
-        match request.command.as_str() {
-            "app.getVersion" => self.handle_get_version().await,
-            "app.getConfig" => self.handle_get_config().await,
-            "fs.exists" => self.handle_fs_exists(&request.payload).await,
-            "os.info" => self.handle_os_info().await,
-            _ => Err(anyhow::anyhow!("Unknown command: {}", request.command)),
+        if let Err(e) = self.proxy.send_event(js_code) {
+            error!("Failed to send IPC response to event loop: {}", e);
         }
     }
+}
+
+pub struct Builder;
 
-    async fn handle_get_version(&self) -> Result<serde_json::Value> {
-        Ok(serde_json::json!({
-            "name": "my-ionyx-app",
-            "version": "1.0.0",
-            "platform": std::env::consts::OS,
-            "arch": std::env::consts::ARCH
-        }))
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
     }
+}
 
-    async fn handle_get_config(&self) -> Result<serde_json::Value> {
-        Ok(serde_json::json!({
-            "window": self.config.window,
-            "permissions": self.config.ionyx.permissions,
-            "security": self.config.ionyx.security
-        }))
+impl Builder {
+    pub fn new() -> Self {
+        Self
     }
 
-    async fn handle_fs_exists(&self, payload: &serde_json::Value) -> Result<serde_json::Value> {
-        let path = payload["path"]
-            .as_str()
-            .ok_or_else(|| "default")
-            .to_string();
+    pub fn run(self) -> Result<()> {
+        let rt = tokio::runtime::Runtime::new()?;
+        rt.block_on(async {
+            self.run_async().await
+        })
+    }
 
-        let path_buf = PathBuf::from(&path);
-        let exists = path_buf.exists();
-        
-        self.security.check_file_access(&path_buf)?;
+    async fn run_async(self) -> Result<()> {
+        // Initialize logging
+        tracing_subscriber::fmt::init();
+
+        info!("Starting Ionyx Framework Application");
+
+        // Load configuration
+        let config = Config::load().await?;
+        info!("Loaded configuration: {}", config.app.name);
+
+        // Create event loop
+        let event_loop: EventLoop<String> = EventLoopBuilder::with_user_event().build();
+        let _web_context = WebContext::new(Some(Default::default()));
+
+        // Create window
+        let window = config
+            .window
+            .apply_to_builder(tao::window::WindowBuilder::new())
+            .build(&event_loop)?;
+
+        // Get the current working directory
+        let current_dir = env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        let dist_dir = if current_dir.ends_with("dist") {
+            // If we're already in the dist directory, use current directory
+            current_dir.clone()
+        } else {
+            // Otherwise, look for dist subdirectory
+            current_dir.join("dist")
+        };
 
-        Ok(serde_json::json!({ "exists": exists }))
-    }
+        info!("Current working directory: {:?}", current_dir);
+        info!("Dist directory: {:?}", dist_dir);
+
+        // Create Fusion Manager
+        let fusion_manager = Arc::new(FusionManager::new());
+        // Initialize with basic app info (Inspired by NW.js context)
+        fusion_manager.set("app_name", serde_json::Value::String(config.app.name.clone()));
+        fusion_manager.set("app_version", serde_json::Value::String(config.app.version.clone()));
+        fusion_manager.set("os", serde_json::Value::String(os_info::get().os_type().to_string()));
+
+        // Create IPC bridge
+        let ipc_bridge = std::sync::Arc::new(IpcBridge::new(
+            config.clone(),
+            IpcDispatcher::new(event_loop.create_proxy()),
+            fusion_manager.clone(),
+        ));
+
+        // Import Windows-specific trait for WebView extensions
+        #[cfg(target_os = "windows")]
+        use wry::WebViewBuilderExtWindows;
+
+        // Determine webview URL based on build mode
+        let webview = if cfg!(debug_assertions) {
+            // Development mode: use IONYX_URL from environment
+            let dev_url = std::env::var("IONYX_URL")
+                .unwrap_or_else(|_| {
+                    format!("http://127.0.0.1:{}", config.development.port)
+                });
+
+            info!("Development mode: Connecting to {}", dev_url);
+
+            let builder = WebViewBuilder::new()
+                .with_initialization_script(include_str!("ionyx.js"))
+                .with_initialization_script(&fusion_manager.generate_sync_script())
+                .with_ipc_handler(move |request| {
+                    let bridge = ipc_bridge.clone();
+                    let request_body = request.body().clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = bridge.handle_request_with_response(request_body).await {
+                            error!("IPC request failed: {}", e);
+                        }
+                    });
+                })
+                .with_navigation_handler(|url| {
+                    // Allow localhost and file:// protocols in debug mode
+                    url.starts_with("http://localhost:") ||
+                    url.starts_with("https://localhost:") ||
+                    url.starts_with("http://127.0.0.1:") ||
+                    url.starts_with("https://127.0.0.1:") ||
+                    url.starts_with("file://") ||
+                    url.starts_with("ionyx://")
+                })
+                .with_url(&dev_url)
+                .with_devtools(true);
+
+            #[cfg(target_os = "windows")]
+            let builder = builder.with_additional_browser_args("--enable-unsafe-webgpu --enable-features=WebGPU");
+
+            builder
+        } else {
+            // Release mode: serve embedded assets from binary
+            info!("Release mode: Loading embedded assets from binary");
+
+            let builder = WebViewBuilder::new()
+                .with_initialization_script(include_str!("ionyx.js"))
+                .with_initialization_script(&fusion_manager.generate_sync_script())
+                .with_ipc_handler(move |request| {
+                    let bridge = ipc_bridge.clone();
+                    let request_body = request.body().clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = bridge.handle_request_with_response(request_body).await {
+                            error!("IPC request failed: {}", e);
+                        }
+                    });
+                })
+                .with_custom_protocol("ionyx".to_string(), move |_, request| {
+                    let handler = crate::protocol::CustomProtocolHandler::new();
+                    handler.handle_request(request)
+                })
+                .with_url("ionyx://index.html");
+
+            #[cfg(target_os = "windows")]
+            let builder = builder.with_additional_browser_args("--enable-unsafe-webgpu --enable-features=WebGPU");
+
+            builder
+        };
 
-    async fn handle_os_info(&self) -> Result<serde_json::Value> {
-        Ok(serde_json::json!({
-            "platform": std::env::consts::OS,
-            "arch": std::env::consts::ARCH,
-            "hostname": gethostname::get().unwrap_or_else(|_| "unknown".to_string()),
-            "version": os_info::get()
-        }))
+        let webview = Arc::new(Mutex::new(webview.build(&window)?));
+
+        // Run event loop
+        event_loop.run(move |event, _, control_flow| {
+            *control_flow = ControlFlow::Wait;
+
+            match event {
+                tao::event::Event::UserEvent(js_code) => {
+                    // Execute JavaScript code from IPC dispatcher
+                    info!("Executing JavaScript code: {}", js_code);
+                    if let Ok(webview_guard) = webview.lock() {
+                        if let Err(e) = webview_guard.evaluate_script(&js_code) {
+                            error!("Failed to execute JavaScript code: {}", e);
+                        } else {
+                            info!("JavaScript code executed successfully");
+                        }
+                    }
+                }
+                tao::event::Event::WindowEvent {
+                    event: tao::event::WindowEvent::CloseRequested,
+                    ..
+                } => {
+                    info!("Window close requested");
+                    *control_flow = ControlFlow::Exit;
+                }
+                _ => (),
+            }
+        });
     }
-}
+}