@ionyx-apps/cli 0.4.7 → 0.4.9

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

@@ -1,5 +1,270 @@
-//! my-ionyx-app backend - Ionyx Framework
+use ionyx::{config, security, protocol};
+use anyhow::Result;
+use serde_json::json;
+use std::env;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use std::process::{Command, Stdio};
+use std::io::{BufRead, BufReader};
+use std::thread;
+use std::time::Duration;
+use tao::event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy};
+use tracing::{error, info};
+use wry::{WebContext, WebViewBuilder};
 
-fn main() -> anyhow::Result<()> {
-    ionyx::Builder::default().run()
+#[derive(Debug, Clone)]
+struct IpcDispatcher {
+    proxy: EventLoopProxy<String>,
+}
+
+impl IpcDispatcher {
+    pub fn new(proxy: EventLoopProxy<String>) -> Self {
+        Self { proxy }
+    }
+
+    pub fn resolve_promise(
+        &self,
+        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
+        });
+
+        let js_code = format!(
+            "if (window.ionyx && window.ionyx.resolveResponse) {{ window.ionyx.resolveResponse('{}', {}); }}",
+            request_id,
+            response
+        );
+
+        if let Err(e) = self.proxy.send_event(js_code) {
+            error!("Failed to send IPC response to event loop: {}", e);
+        }
+    }
+}
+
+fn start_vite_dev_server() -> Result<std::process::Child> {
+    info!("🚀 Starting Vite dev server...");
+
+    // Get the project root (parent of src-ionyx directory)
+    let project_root = env::current_dir()
+        .map_err(|e| anyhow::anyhow!("Failed to get current directory: {}", e))?
+        .parent()
+        .unwrap_or(&env::current_dir().unwrap())
+        .to_path_buf();
+
+    info!("📁 Project root: {:?}", project_root);
+
+    let mut child = Command::new("npm")
+        .args(&["run", "dev", "--", "--host", "127.0.0.1", "--port", "5173"])
+        .current_dir(&project_root)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| anyhow::anyhow!("Failed to start Vite dev server: {}", e))?;
+
+    Ok(child)
+}
+
+fn monitor_vite_server(mut child: std::process::Child) -> Result<()> {
+    info!("👀 Monitoring Vite dev server output...");
+
+    if let Some(stdout) = child.stdout.take() {
+        let reader = BufReader::new(stdout);
+        thread::spawn(move || {
+            for line in reader.lines() {
+                match line {
+                    Ok(line) => {
+                        println!("📝 Vite: {}", line);
+                        // Check for ready indicators
+                        if line.contains("ready") || line.contains("Ready") ||
+                           line.contains("Local:") || line.contains("http://") {
+                            info!("✅ Vite dev server is ready!");
+                        }
+                    }
+                    Err(e) => error!("Error reading Vite output: {}", e),
+                }
+            }
+        });
+    }
+
+    // Also monitor stderr
+    if let Some(stderr) = child.stderr.take() {
+        let reader = BufReader::new(stderr);
+        thread::spawn(move || {
+            for line in reader.lines() {
+                match line {
+                    Ok(line) => {
+                        if !line.contains("webpack") && !line.contains("built in") {
+                            eprintln!("⚠️  Vite stderr: {}", line);
+                        }
+                    }
+                    Err(e) => error!("Error reading Vite stderr: {}", e),
+                }
+            }
+        });
+    }
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize logging
+    tracing_subscriber::fmt::init();
+
+    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()
+        }
+    };
+
+    // Display app information
+    println!("📱 App: {} v{}", app_config.app.name, app_config.app.version);
+    println!("🔧 Debug mode: {}", cfg!(debug_assertions));
+
+    // Initialize security manager for demonstration
+    // Explicitly use the security module to ensure the import is recognized
+    let security_manager: ionyx::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");
+
+    // Start Vite dev server
+    let vite_child = start_vite_dev_server()?;
+    monitor_vite_server(vite_child)?;
+
+    // Wait for Vite to be ready
+    println!("⏳ Waiting for Vite dev server to be ready...");
+    thread::sleep(Duration::from_secs(5));
+
+    // 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 = tao::window::WindowBuilder::new()
+        .with_title("my-ionyx-app")
+        .with_inner_size(tao::dpi::LogicalSize::new(1200.0, 800.0))
+        .with_resizable(true)
+        .build(&event_loop)?;
+
+    // Dev URL
+    let dev_url = "http://127.0.0.1:5173";
+    println!("🌐 Connecting to Vite dev server at {}", dev_url);
+
+    // Create IPC dispatcher
+    let ipc_dispatcher = Arc::new(IpcDispatcher::new(event_loop.create_proxy()));
+    let webview = Arc::new(Mutex::new(
+        WebViewBuilder::new()
+            .with_initialization_script(include_str!("ionyx.js"))
+            .with_ipc_handler(move |request| {
+                let dispatcher = ipc_dispatcher.clone();
+                let request_body = request.body().clone();
+                tokio::spawn(async move {
+                    if let Ok(request_str) = String::from_utf8(request_body) {
+                        if let Ok(ipc_request) = serde_json::from_str::<serde_json::Value>(&request_str) {
+                            if let Some(command) = ipc_request.get("command").and_then(|c| c.as_str()) {
+                                if let Some(id) = ipc_request.get("id").and_then(|i| i.as_str()) {
+                                    match command {
+                                        "app.getVersion" => {
+                                            let data = json!({
+                                                "name": "my-ionyx-app",
+                                                "version": "0.4.2",
+                                                "platform": std::env::consts::OS
+                                            });
+                                            dispatcher.resolve_promise(id, true, Some(data), None);
+                                            info!("✅ IPC response sent for: {}", command);
+                                        }
+                                        "os.info" => {
+                                            let data = json!({
+                                                "platform": std::env::consts::OS,
+                                                "arch": std::env::consts::ARCH,
+                                                "version": "1.0.0",
+                                                "hostname": "localhost"
+                                            });
+                                            dispatcher.resolve_promise(id, true, Some(data), None);
+                                            info!("✅ IPC response sent for: {}", command);
+                                        }
+                                        _ => {
+                                            let error = format!("Unknown command: {}", command);
+                                            dispatcher.resolve_promise(id, false, None, Some(error));
+                                            error!("Unknown IPC command: {}", command);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+            })
+            .with_navigation_handler(|url| {
+                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)
+            .build(&window)?
+    ));
+
+    println!("✅ Ionyx application initialized successfully!");
+    println!("🎉 Both Vite dev server and Ionyx application are running!");
+    println!("🌐 Open http://127.0.0.1:5173 to access your application");
+
+    // Run event loop
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            tao::event::Event::UserEvent(js_code) => {
+                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,
+                ..
+            } => {
+                println!("👋 Application closing...");
+                *control_flow = ControlFlow::Exit;
+            }
+            _ => (),
+        }
+    });
 }

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

@@ -0,0 +1,98 @@
+use std::borrow::Cow;
+use wry::http::{Request, Response, StatusCode};
+use std::path::PathBuf;
+
+#[cfg(not(debug_assertions))]
+use include_dir::{include_dir, Dir};
+
+// Configuration'dan frontendDist path'ini oku
+fn get_frontend_dist_path() -> PathBuf {
+    // Önce Ionyx config dosyasını okumaya çalış
+    if let Ok(config_content) = std::fs::read_to_string("ionyx.config.toml") {
+        for line in config_content.lines() {
+            if line.trim().starts_with("frontendDist") {
+                if let Some(path_str) = line.split('=').nth(1) {
+                    let clean_path = path_str.trim().trim_matches('"');
+                    return PathBuf::from(clean_path);
+                }
+            }
+        }
+    }
+    
+    PathBuf::from("../frontend/dist")
+}
+
+#[cfg(not(debug_assertions))]
+static EMBEDDED_ASSETS: Dir<'static> = include_dir!("$CARGO_MANIFEST_DIR/../frontend/dist");
+
+pub struct CustomProtocolHandler;
+
+impl CustomProtocolHandler {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn handle_request(&self, request: Request<Vec<u8>>) -> Response<Cow<'static, [u8]>> {
+        let uri_path = request.uri().path();
+        
+        #[cfg(debug_assertions)]
+        {
+            let _uri_path = uri_path;
+            let _dist_path = get_frontend_dist_path();
+            let _unused_ct = Self::get_content_type("index.html");
+            return Response::builder()
+                .status(StatusCode::NOT_FOUND)
+                .header("Content-Type", "text/plain")
+                .body(Cow::Borrowed(&b"Debug mode: Assets are served from Vite (localhost:5173)"[..]))
+                .unwrap();
+        }
+
+        #[cfg(not(debug_assertions))]
+        {
+            let clean_path = uri_path.trim_start_matches('/');
+            let file_path = if clean_path.is_empty() { "index.html" } else { clean_path };
+
+            match EMBEDDED_ASSETS.get_file(file_path) {
+                Some(file) => {
+                    let content_type = Self::get_content_type(file_path);
+                    Response::builder()
+                        .status(StatusCode::OK)
+                        .header("Content-Type", content_type)
+                        .body(Cow::Borrowed(file.contents()))
+                        .unwrap()
+                }
+                None => {
+                    if let Some(index_file) = EMBEDDED_ASSETS.get_file("index.html") {
+                        Response::builder()
+                            .status(StatusCode::OK)
+                            .header("Content-Type", "text/html")
+                            .body(Cow::Borrowed(index_file.contents()))
+                            .unwrap()
+                    } else {
+                        Response::builder()
+                            .status(StatusCode::NOT_FOUND)
+                            .body(Cow::Borrowed(&b"404 Not Found"[..]))
+                            .unwrap()
+                    }
+                }
+            }
+        }
+    }
+
+    fn get_content_type(file_path: &str) -> &'static str {
+        let path = std::path::Path::new(file_path);
+        match path.extension().and_then(|s| s.to_str()) {
+            Some("html") => "text/html",
+            Some("css") => "text/css",
+            Some("js") => "application/javascript",
+            Some("json") => "application/json",
+            Some("svg") => "image/svg+xml",
+            Some("png") => "image/png",
+            Some("jpg") | Some("jpeg") => "image/jpeg",
+            Some("gif") => "image/gif",
+            Some("woff") => "font/woff",
+            Some("woff2") => "font/woff2",
+            _ => "application/octet-stream",
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct WindowConfig {
+    pub title: String,
+    pub width: u32,
+    pub height: u32,
+    pub resizable: bool,
+    pub fullscreen: bool,
+    pub min_width: Option<u32>,
+    pub min_height: Option<u32>,
+    pub max_width: Option<u32>,
+    pub max_height: Option<u32>,
+    pub icon: Option<String>,
+}

package/ionyx-cli/src/templates/svelte/index.html

@@ -8,6 +8,7 @@
   </head>
   <body>
     <div id="app"></div>
+    <script src="ionyx-bridge.js"></script>
     <script type="module" src="frontend/src/main.ts"></script>
   </body>
 </html>

package/ionyx-cli/src/templates/svelte/ionyx-bridge.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.");

package/ionyx-cli/src/templates/svelte/package.json

@@ -8,7 +8,12 @@
     "build": "vite build",
     "preview": "vite preview",
     "ionyx:dev": "cd src-ionyx && cargo run --bin my-ionyx-app",
-    "ionyx:build": "cd src-ionyx && cargo build --release",
+    "ionyx:build": "cd src-ionyx && cargo build --release && npm run bundle:create",
+    "bundle:create": "node -e \"const fs=require('fs');const path=require('path');const dist=path.join(__dirname,'dist');if(!fs.existsSync(dist))fs.mkdirSync(dist);const target=path.join(__dirname,'src-ionyx','target','release','my-ionyx-app.exe');if(fs.existsSync(target)){const bundle=path.join(dist,'my-ionyx-app-v1.0.0.exe');fs.copyFileSync(target,bundle);console.log('✅ Bundle created:',bundle);}else{console.log('❌ Executable not found');}\"",
+    "bundle": "npm run bundle:create",
+    "bundle:windows": "npm run bundle:create",
+    "bundle:macos": "npm run bundle:create",
+    "bundle:linux": "npm run bundle:create",
     "ionyx": "npx ionyx",
     "ionyx:dev2": "npx ionyx dev",
     "ionyx:build2": "npx ionyx build",

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

@@ -4,22 +4,24 @@ name = "my-ionyx-app"
 version = "0.4.2"
 edition = "2021"
 
-[workspace]
-
-[lib]
-name = "my_ionyx_app"
-path = "src/lib.rs"
-
-[[bin]]
-name = "my-ionyx-app"
-path = "main.rs"
-
 [dependencies]
 include_dir = "0.7"
-ionyx = { path = "../../../../../../src-ionyx" }
-anyhow = "1.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/svelte/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/vanilla/index.html

@@ -77,6 +77,7 @@
       </div>
       <p>Edit this file and reload to see changes!</p>
     </div>
+    <script src="ionyx-bridge.js"></script>
     <script type="module" src="frontend/main.js"></script>
   </body>
 </html>