@ionyx-apps/cli 0.4.8 → 0.4.9

package/ionyx-cli/src/templates/react/src-ionyx/main.rs

@@ -1,5 +1,48 @@
-//! my-ionyx-app backend - Ionyx Framework
+use ionyx::{config, security, protocol};
 
-fn main() -> anyhow::Result<()> {
-    ionyx::Builder::default().run()
+#[tokio::main]
+async fn main() {
+    println!("🚀 Ionyx Application starting...");
+
+    // Load application configuration
+    let app_config = match config::Config::load().await {
+        Ok(config) => {
+            println!("✅ Configuration loaded successfully");
+            config
+        }
+        Err(e) => {
+            eprintln!("⚠️  Failed to load config, using defaults: {}", e);
+            config::Config::default()
+        }
+    };
+
+    // Initialize security manager for demonstration
+    let security_manager: crate::security::SecurityManager = security::SecurityManager::new(app_config.clone());
+
+    // Demonstrate comprehensive security manager functionality
+    let test_paths = ["./app-data", "/system", "../outside"];
+    for &test_path in &test_paths {
+        let is_secure = security_manager.is_path_allowed(test_path);
+        println!("🔒 Security check: '{}' -> {}",
+                 test_path,
+                 if is_secure { "ALLOWED" } else { "DENIED" });
+    }
+
+    // Demonstrate security validation
+    if let Ok(()) = security_manager.validate_path_operation("./app-data", "read") {
+        println!("🔒 Security validation: Path operation approved");
+    }
+
+    // Initialize protocol handler for demonstration
+    let _protocol_handler = protocol::CustomProtocolHandler::new();
+    println!("🌐 Protocol handler initialized");
+
+    // Create and run the Ionyx application with automatic Vite server startup
+    println!("🚀 Launching Ionyx application...");
+    let builder = ionyx::Builder::new().config(app_config);
+
+    if let Err(e) = builder.run() {
+        eprintln!("❌ Application failed to start: {}", e);
+        std::process::exit(1);
+    }
 }

package/ionyx-cli/src/templates/src-ionyx/Cargo.toml

@@ -4,14 +4,24 @@ name = "my-ionyx-app"
 version = "0.4.2"
 edition = "2021"
 
-[[bin]]
-name = "my-ionyx-app"
-path = "main.rs"
-
 [dependencies]
 include_dir = "0.7"
-ionyx = "1.0.0"
+# Web framework dependencies
+wry = "0.54"
+tao = "0.34"
+tokio = { version = "1.50", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 anyhow = "1.0"
+toml = "0.8"
+tracing = "0.1"
+tracing-subscriber = "0.3"
+os_info = "3"
+gethostname = "0.4"
+
+[[bin]]
+name = "my-ionyx-app"
+path = "main.rs"
 
 [profile.release]
 opt-level = 3

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

@@ -0,0 +1,380 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use tracing::{debug, error, info};
+use std::sync::Arc;
+
+use crate::config::Config;
+use crate::ipc_bridge::{AppInfo, IpcBridgeManager};
+use crate::security::SecurityManager;
+use rfd::AsyncFileDialog;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcRequest {
+    pub id: String,
+    pub command: String,
+    pub payload: Value,
+}
+
+use crate::fusion::FusionManager;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IpcResponse {
+    pub id: String,
+    pub success: bool,
+    pub data: Option<Value>,
+    pub error: Option<String>,
+}
+
+pub struct IpcBridge {
+    config: Config,
+    security: SecurityManager,
+    dispatcher: crate::IpcDispatcher,
+    bridge_manager: IpcBridgeManager,
+    fusion_manager: Arc<FusionManager>,
+}
+
+impl IpcBridge {
+    pub fn new(config: Config, dispatcher: crate::IpcDispatcher, fusion_manager: Arc<FusionManager>) -> Self {
+        let security = SecurityManager::new(config.clone());
+        let bridge_manager = IpcBridgeManager::new(config.clone(), config.app.name.clone());
+        Self {
+            config,
+            security,
+            dispatcher,
+            bridge_manager,
+            fusion_manager,
+        }
+    }
+
+    pub async fn handle_request_with_response(&self, request: String) -> Result<()> {
+        debug!("Received IPC request: {}", request);
+
+        let ipc_request: IpcRequest = serde_json::from_str(&request)
+            .map_err(|e| anyhow::anyhow!("Failed to parse IPC request: {}", e))?;
+
+        info!("Processing IPC command: {}", ipc_request.command);
+
+        // Process the command and get the result
+        let response = match self.process_command(&ipc_request).await {
+            Ok(data) => {
+                info!(
+                    "IPC command '{}' completed successfully",
+                    ipc_request.command
+                );
+                IpcResponse {
+                    id: ipc_request.id,
+                    success: true,
+                    data: Some(data),
+                    error: None,
+                }
+            }
+            Err(e) => {
+                error!("IPC command '{}' failed: {}", ipc_request.command, e);
+                IpcResponse {
+                    id: ipc_request.id,
+                    success: false,
+                    data: None,
+                    error: Some(e.to_string()),
+                }
+            }
+        };
+
+        debug!("IPC request processed with response: {:?}", response);
+
+        // Send response back to frontend using dispatcher
+        self.dispatcher.resolve_promise(
+            &response.id,
+            response.success,
+            response.data,
+            response.error,
+        );
+
+        Ok(())
+    }
+
+    async fn process_command(&self, request: &IpcRequest) -> Result<Value> {
+        match request.command.as_str() {
+            "fs.readFile" => self.handle_read_file(&request.payload).await,
+            "fs.writeFile" => self.handle_write_file(&request.payload).await,
+            "fs.exists" => self.handle_file_exists(&request.payload).await,
+            "fs.readdir" => self.handle_read_dir(&request.payload).await,
+            "os.info" => self.handle_os_info().await,
+            "dialog.openFile" => self.handle_open_file_dialog(&request.payload).await,
+            "dialog.saveFile" => self.handle_save_file_dialog(&request.payload).await,
+            "network.request" => self.handle_network_request(&request.payload).await,
+            "app.getVersion" => self.handle_get_version().await,
+            "app.getConfig" => self.handle_get_config().await,
+            // IPC Bridge commands
+            "bridge.registerApp" => self.handle_bridge_register_app(&request.payload).await,
+            "bridge.unregisterApp" => self.handle_bridge_unregister_app(&request.payload).await,
+            "bridge.getApps" => self.handle_bridge_get_apps(&request.payload).await,
+            "bridge.sendToApp" => self.handle_bridge_send_to_app(&request.payload).await,
+            "bridge.broadcast" => self.handle_bridge_broadcast(&request.payload).await,
+            "fusion.update" => self.handle_fusion_update(&request.payload).await,
+            _ => Err(anyhow::anyhow!("Unknown command: {}", request.command)),
+        }
+    }
+
+    async fn handle_fusion_update(&self, payload: &Value) -> Result<Value> {
+        let key = payload["key"].as_str().ok_or_else(|| anyhow::anyhow!("Missing key"))?;
+        let value = payload["value"].clone();
+        
+        info!("Fusion update from JS: {} = {:?}", key, value);
+        self.fusion_manager.set(key, value);
+        
+        Ok(json!({ "success": true }))
+    }
+
+    async fn handle_read_file(&self, payload: &Value) -> Result<Value> {
+        let path: String = serde_json::from_value(payload["path"].clone())?;
+
+        self.security.validate_path_operation(&path, "read")?;
+        let content = tokio::fs::read_to_string(&path).await?;
+        Ok(json!({ "content": content }))
+    }
+
+    async fn handle_write_file(&self, payload: &Value) -> Result<Value> {
+        let path: String = serde_json::from_value(payload["path"].clone())?;
+        let content: String = serde_json::from_value(payload["content"].clone())?;
+
+        self.security.validate_path_operation(&path, "write")?;
+        tokio::fs::write(&path, content).await?;
+        Ok(json!({ "success": true }))
+    }
+
+    async fn handle_file_exists(&self, payload: &Value) -> Result<Value> {
+        let path: String = serde_json::from_value(payload["path"].clone())?;
+
+        self.security.validate_path_operation(&path, "exists")?;
+        let exists = tokio::fs::metadata(&path).await.is_ok();
+        Ok(json!({ "exists": exists }))
+    }
+
+    async fn handle_read_dir(&self, payload: &Value) -> Result<Value> {
+        let path: String = serde_json::from_value(payload["path"].clone())?;
+
+        self.security.validate_path_operation(&path, "read")?;
+        let mut entries = Vec::new();
+        let mut dir = tokio::fs::read_dir(&path).await?;
+
+        while let Some(entry) = dir.next_entry().await? {
+            let metadata = entry.metadata().await?;
+            entries.push(json!({
+                "name": entry.file_name().to_string_lossy(),
+                "path": entry.path().to_string_lossy(),
+                "isFile": metadata.is_file(),
+                "isDir": metadata.is_dir(),
+                "size": metadata.len(),
+                "modified": metadata.modified()
+                    .ok()
+                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+                    .map(|d| d.as_secs())
+            }));
+        }
+
+        Ok(json!({ "entries": entries }))
+    }
+
+    async fn handle_os_info(&self) -> Result<Value> {
+        if !self.config.permissions.os_info {
+            return Err(anyhow::anyhow!("OS info access is disabled"));
+        }
+
+        Ok(json!({
+            "platform": std::env::consts::OS,
+            "arch": std::env::consts::ARCH,
+            "version": os_info::get().version().to_string(),
+            "hostname": gethostname::gethostname().to_string_lossy().to_string()
+        }))
+    }
+
+    async fn handle_open_file_dialog(&self, _payload: &Value) -> Result<Value> {
+        if !self.config.permissions.dialogs {
+            return Err(anyhow::anyhow!("Dialog access is disabled"));
+        }
+
+        let file = AsyncFileDialog::new()
+            .set_title("Open File")
+            .pick_file()
+            .await;
+
+        match file {
+            Some(handle) => Ok(json!({ "filePath": handle.path().to_string_lossy() })),
+            None => Ok(json!({ "filePath": null })),
+        }
+    }
+
+    async fn handle_save_file_dialog(&self, _payload: &Value) -> Result<Value> {
+        if !self.config.permissions.dialogs {
+            return Err(anyhow::anyhow!("Dialog access is disabled"));
+        }
+
+        let file = AsyncFileDialog::new()
+            .set_title("Save File")
+            .save_file()
+            .await;
+
+        match file {
+            Some(handle) => Ok(json!({ "filePath": handle.path().to_string_lossy() })),
+            None => Ok(json!({ "filePath": null })),
+        }
+    }
+
+    async fn handle_network_request(&self, payload: &Value) -> Result<Value> {
+        if !self.config.permissions.network {
+            return Err(anyhow::anyhow!("Network access is disabled"));
+        }
+
+        let url: String = serde_json::from_value(payload["url"].clone())?;
+        let method: String = payload["method"].as_str().unwrap_or("GET").to_string();
+
+        // Basic HTTP request implementation
+        let client = reqwest::Client::new();
+        let request = match method.as_str() {
+            "GET" => client.get(&url),
+            "POST" => {
+                let body = payload.get("body").cloned().unwrap_or(json!(null));
+                client.post(&url).json(&body)
+            }
+            "PUT" => {
+                let body = payload.get("body").cloned().unwrap_or(json!(null));
+                client.put(&url).json(&body)
+            }
+            "DELETE" => client.delete(&url),
+            _ => return Err(anyhow::anyhow!("Unsupported HTTP method: {}", method)),
+        };
+
+        let response = request.send().await?;
+        let status = response.status().as_u16();
+        let headers = response
+            .headers()
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
+            .collect::<std::collections::HashMap<_, _>>();
+        let body = response.text().await?;
+
+        Ok(json!({
+            "status": status,
+            "headers": headers,
+            "body": body
+        }))
+    }
+
+    async fn handle_get_version(&self) -> Result<Value> {
+        Ok(json!({
+            "name": self.config.app.name.clone(),
+            "version": self.config.app.version.clone()
+        }))
+    }
+
+    async fn handle_get_config(&self) -> Result<Value> {
+        Ok(json!({
+            "window": self.config.window,
+            "permissions": self.config.permissions
+        }))
+    }
+
+    // IPC Bridge methods
+    async fn handle_bridge_register_app(&self, payload: &Value) -> Result<Value> {
+        let name: String = serde_json::from_value(payload["name"].clone())?;
+        let version: String = serde_json::from_value(payload["version"].clone())?;
+        let capabilities: Vec<String> = serde_json::from_value(payload["capabilities"].clone())?;
+
+        info!("Registering app via bridge: {} v{}", name, version);
+
+        let app_info = AppInfo {
+            name: name.clone(),
+            version: version.clone(),
+            pid: std::process::id(),
+            capabilities,
+        };
+
+        self.bridge_manager.register_app(app_info.clone()).await?;
+
+        Ok(json!({
+            "registered": true,
+            "app": {
+                "name": app_info.name,
+                "version": app_info.version,
+                "pid": app_info.pid,
+                "capabilities": app_info.capabilities,
+                "registered_at": chrono::Utc::now().to_rfc3339()
+            },
+            "message": format!("App '{}' registered successfully", name)
+        }))
+    }
+
+    async fn handle_bridge_unregister_app(&self, payload: &Value) -> Result<Value> {
+        let name: String = serde_json::from_value(payload["name"].clone())?;
+
+        info!("Unregistering app via bridge: {}", name);
+
+        self.bridge_manager.unregister_app(&name).await?;
+
+        Ok(json!({
+            "unregistered": true,
+            "app": name,
+            "message": format!("App '{}' unregistered successfully", name)
+        }))
+    }
+
+    async fn handle_bridge_get_apps(&self, _payload: &Value) -> Result<Value> {
+        info!("Getting registered apps via bridge");
+
+        let apps: Vec<AppInfo> = self.bridge_manager.get_registered_apps().await?;
+
+        Ok(json!({
+            "apps": apps,
+            "total_count": apps.len(),
+            "message": "Retrieved registered applications"
+        }))
+    }
+
+    async fn handle_bridge_send_to_app(&self, payload: &Value) -> Result<Value> {
+        let target_app: String = serde_json::from_value(payload["target_app"].clone())?;
+        let command: String = serde_json::from_value(payload["command"].clone())?;
+        let command_payload: Value = payload["payload"].clone();
+
+        info!("Sending to app via bridge {}: {}", target_app, command);
+
+        let request = crate::ipc_bridge::IpcBridgeRequest {
+            source_app: self.config.app.name.clone(),
+            target_app: target_app.clone(),
+            command,
+            payload: command_payload,
+            id: format!("bridge_msg_{}", chrono::Utc::now().timestamp_millis()),
+        };
+
+        let response = self.bridge_manager.send_to_app(request).await?;
+
+        Ok(json!({
+            "sent": true,
+            "delivery": response,
+            "message": format!("Message sent to '{}' successfully", target_app)
+        }))
+    }
+
+    async fn handle_bridge_broadcast(&self, payload: &Value) -> Result<Value> {
+        let message: Value = payload["message"].clone();
+
+        info!("Broadcasting message via bridge: {:?}", message);
+
+        let request = crate::ipc_bridge::IpcBridgeRequest {
+            source_app: self.config.app.name.clone(),
+            target_app: "*".to_string(), // Convention for broadcast
+            command: "system.broadcast".to_string(),
+            payload: message,
+            id: format!("broadcast_{}", chrono::Utc::now().timestamp_millis()),
+        };
+
+        // Use process_bridge_request directly for broadcast logic
+        let response = self.bridge_manager.send_to_app_direct(request).await?;
+
+        Ok(json!({
+            "broadcast_sent": true,
+            "broadcast": response,
+            "message": "Broadcast sent to all recipients successfully"
+        }))
+    }
+}

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

@@ -0,0 +1,47 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FusionState {
+    pub data: HashMap<String, Value>,
+}
+
+pub struct FusionManager {
+    state: Arc<Mutex<FusionState>>,
+}
+
+impl FusionManager {
+    pub fn new() -> Self {
+        Self {
+            state: Arc::new(Mutex::new(FusionState {
+                data: HashMap::new(),
+            })),
+        }
+    }
+
+    pub fn set(&self, key: &str, value: Value) {
+        let mut state = self.state.lock().unwrap();
+        state.data.insert(key.to_string(), value);
+    }
+
+    #[allow(dead_code)]
+    pub fn get(&self, key: &str) -> Option<Value> {
+        let state = self.state.lock().unwrap();
+        state.data.get(key).cloned()
+    }
+
+    pub fn get_all(&self) -> Value {
+        let state = self.state.lock().unwrap();
+        serde_json::to_value(&state.data).unwrap_or(Value::Object(serde_json::Map::new()))
+    }
+
+    pub fn generate_sync_script(&self) -> String {
+        let data = self.get_all();
+        format!(
+            "if (window.ionyx) {{ window.ionyx._fusion_sync({}); }}",
+            data.to_string()
+        )
+    }
+}

package/ionyx-cli/src/templates/src-ionyx/ionyx.js

@@ -0,0 +1,100 @@
+// Ionyx IPC Bridge JavaScript
+(function() {
+  const _promises = {};
+  let _fusion_data = {};
+
+  window.ionyx = {
+    _promises,
+    _fusion_sync: (data) => {
+      console.log("🧬 Fusion Sync:", data);
+      _fusion_data = data;
+    },
+    resolveResponse: (responseId, response) => {
+      const promiseHandlers = _promises[responseId];
+      if (promiseHandlers) {
+        console.log("📥 Received IPC response:", response);
+        clearTimeout(promiseHandlers.timeoutId);
+        if (response.success) {
+          promiseHandlers.resolve(response.data);
+        } else {
+          promiseHandlers.reject(new Error(response.error));
+        }
+        delete _promises[responseId];
+      }
+    },
+    invoke: (command, payload = {}) => {
+      return new Promise((resolve, reject) => {
+        const id = `${Date.now()}_${Math.random().toString(36).substr(2, 9)}_${command}`;
+        const request = {
+          id,
+          command,
+          payload: payload || {}
+        };
+        
+        console.log("🚀 Sending IPC request:", request);
+        
+        const timeoutId = setTimeout(() => {
+          console.error("❌ IPC request timeout for:", command);
+          reject(new Error("IPC request timeout"));
+          delete _promises[id];
+        }, 15000);
+        
+        _promises[id] = { resolve, reject, timeoutId };
+        
+        if (window.ipc && typeof window.ipc.postMessage === 'function') {
+          console.log("📤 Sending via window.ipc.postMessage");
+          window.ipc.postMessage(JSON.stringify(request));
+        } else {
+          console.error("❌ window.ipc not available");
+          clearTimeout(timeoutId);
+          reject(new Error("IPC not available natively through window.ipc"));
+          delete _promises[id];
+        }
+      });
+    }
+  };
+
+  // Add Tauri-like namespaces
+  const invoke = window.ionyx.invoke;
+  
+  window.ionyx.fs = {
+    readFile: (path) => invoke("fs.readFile", { path }),
+    writeFile: (path, content) => invoke("fs.writeFile", { path, content }),
+    exists: (path) => invoke("fs.exists", { path }),
+    readDir: (path) => invoke("fs.readdir", { path })
+  };
+  
+  window.ionyx.os = {
+    info: () => invoke("os.info")
+  };
+  
+  window.ionyx.dialog = {
+    openFile: () => invoke("dialog.openFile", {}),
+    saveFile: () => invoke("dialog.saveFile", {})
+  };
+  
+  window.ionyx.app = {
+    getVersion: () => invoke("app.getVersion"),
+    getConfig: () => invoke("app.getConfig")
+  };
+  
+  window.ionyx.network = {
+    request: (url, method = "GET", body = null) => invoke("network.request", { url, method, body })
+  };
+
+  // Inspired by NW.js Unified Context: 
+  // Native Fusion allows direct access to shared state.
+  window.fusion = new Proxy({}, {
+    get: (target, prop) => {
+      return _fusion_data[prop];
+    },
+    set: (target, prop, value) => {
+       _fusion_data[prop] = value;
+       invoke("fusion.update", { key: prop, value });
+       return true;
+    }
+  });
+
+})();
+
+console.log("🔧 Ionyx IPC Bridge injected successfully.");