elit 3.5.6 → 3.5.8

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "elit-desktop"
-version = "3.5.6"
+version = "3.5.8"
 edition = "2021"
 build = "desktop/build.rs"
 

package/README.md

@@ -955,7 +955,7 @@ The package also exports `elit/test`, `elit/test-runtime`, and `elit/test-report
 
 Latest release notes live in [CHANGELOG.md](CHANGELOG.md).
 
-Highlights in `v3.5.6`:
+Highlights in `v3.5.8`:
 
 - Added `elit pm` for detached background process management of shell commands, file targets, and WAPK apps.
 - Added `pm.apps[]` and `pm.dataDir` in `elit.config.*` for config-first process manager workflows.

package/desktop/build.rs

@@ -0,0 +1,83 @@
+#[cfg(windows)]
+fn main() {
+    use std::env;
+    use std::fs::File;
+    use std::io::BufWriter;
+    use std::path::{Path, PathBuf};
+
+    #[path = "icon.rs"]
+    mod icon;
+
+    use image::ImageFormat;
+    use icon::load_icon_bitmap;
+
+    println!("cargo:rerun-if-env-changed=ELIT_DESKTOP_EXE_ICON");
+    println!("cargo:rerun-if-env-changed=WAPK_EXE_ICON");
+
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| ".".to_string()));
+
+    let mut icon_path = env::var("ELIT_DESKTOP_EXE_ICON")
+        .ok()
+        .or_else(|| env::var("WAPK_EXE_ICON").ok())
+        .map(PathBuf::from);
+
+    if icon_path.is_none() {
+        let ico = manifest_dir.join("icon.ico");
+        let png = manifest_dir.join("icon.png");
+        let svg = manifest_dir.join("icon.svg");
+        if ico.exists() {
+            icon_path = Some(ico);
+        } else if png.exists() {
+            icon_path = Some(png);
+        } else if svg.exists() {
+            icon_path = Some(svg);
+        }
+    }
+
+    let Some(icon_path) = icon_path else {
+        return;
+    };
+
+    println!("cargo:rerun-if-changed={}", icon_path.display());
+
+    let resource_icon = match icon_path.extension().and_then(|s| s.to_str()).map(|s| s.to_ascii_lowercase()) {
+        Some(ext) if ext == "ico" => Some(icon_path.clone()),
+        Some(ext) if ext == "png" || ext == "svg" => {
+            let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap_or_else(|_| ".".to_string()));
+            let out_ico = out_dir.join("wapk-auto-icon.ico");
+            if let Err(err) = convert_icon_to_ico(&icon_path, &out_ico) {
+                println!("cargo:warning=Failed to convert icon to ICO: {err}");
+                None
+            } else {
+                Some(out_ico)
+            }
+        }
+        _ => {
+            println!(
+                "cargo:warning=Unsupported icon format for ELIT_DESKTOP_EXE_ICON: {}",
+                icon_path.display()
+            );
+            None
+        }
+    };
+
+    if let Some(icon_file) = resource_icon {
+        let mut res = winres::WindowsResource::new();
+        res.set_icon(icon_file.to_string_lossy().as_ref());
+        if let Err(err) = res.compile() {
+            println!("cargo:warning=Failed to embed exe icon resource: {err}");
+        }
+    }
+
+    fn convert_icon_to_ico(input_icon: &Path, output_ico: &Path) -> Result<(), String> {
+        let rgba = load_icon_bitmap(input_icon)?.into_dynamic_image()?;
+        let file = File::create(output_ico).map_err(|e| format!("create ICO failed: {e}"))?;
+        let mut writer = BufWriter::new(file);
+        rgba.write_to(&mut writer, ImageFormat::Ico)
+            .map_err(|e| format!("write ICO failed: {e}"))?;
+        Ok(())
+    }
+}
+
+#[cfg(not(windows))]
+fn main() {}

package/desktop/icon.rs

@@ -0,0 +1,106 @@
+use std::path::Path;
+
+use image::{DynamicImage, RgbaImage};
+
+const DEFAULT_ICON_SIDE: u32 = 256;
+
+pub struct IconBitmap {
+    rgba: Vec<u8>,
+    width: u32,
+    height: u32,
+}
+
+impl IconBitmap {
+    #[allow(dead_code)]
+    pub fn into_rgba(self) -> (Vec<u8>, u32, u32) {
+        (self.rgba, self.width, self.height)
+    }
+
+    #[allow(dead_code)]
+    pub fn into_dynamic_image(self) -> Result<DynamicImage, String> {
+        let Some(image) = RgbaImage::from_raw(self.width, self.height, self.rgba) else {
+            return Err(String::from("icon decode produced an invalid RGBA buffer"));
+        };
+        Ok(DynamicImage::ImageRgba8(image))
+    }
+}
+
+pub fn load_icon_bitmap(path: &Path) -> Result<IconBitmap, String> {
+    match icon_extension(path).as_deref() {
+        Some("svg") => load_svg_icon_bitmap(path),
+        _ => load_raster_icon_bitmap(path),
+    }
+}
+
+fn icon_extension(path: &Path) -> Option<String> {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .map(|ext| ext.to_ascii_lowercase())
+}
+
+fn load_raster_icon_bitmap(path: &Path) -> Result<IconBitmap, String> {
+    let image = image::open(path)
+        .map_err(|err| format!("decode icon failed for {}: {err}", path.display()))?;
+    bitmap_from_dynamic_image(image)
+}
+
+fn load_svg_icon_bitmap(path: &Path) -> Result<IconBitmap, String> {
+    use resvg::{tiny_skia, usvg};
+
+    let svg = std::fs::read(path)
+        .map_err(|err| format!("read SVG failed for {}: {err}", path.display()))?;
+    let options = usvg::Options::default();
+    let tree = usvg::Tree::from_data(&svg, &options)
+        .map_err(|err| format!("parse SVG failed for {}: {err}", path.display()))?;
+
+    let size = tree.size();
+    let width = size.width().ceil().max(1.0) as u32;
+    let height = size.height().ceil().max(1.0) as u32;
+    let side = width.max(height).max(DEFAULT_ICON_SIDE);
+
+    let mut pixmap = tiny_skia::Pixmap::new(side, side)
+        .ok_or_else(|| format!("allocate SVG pixmap failed for {}", path.display()))?;
+
+    let scale = (side as f32 / width as f32).min(side as f32 / height as f32);
+    let scaled_width = width as f32 * scale;
+    let scaled_height = height as f32 * scale;
+    let translate_x = ((side as f32 - scaled_width) / 2.0).max(0.0);
+    let translate_y = ((side as f32 - scaled_height) / 2.0).max(0.0);
+    let transform = tiny_skia::Transform::from_translate(translate_x, translate_y)
+        .post_scale(scale, scale);
+
+    resvg::render(&tree, transform, &mut pixmap.as_mut());
+
+    Ok(IconBitmap {
+        rgba: pixmap.take(),
+        width: side,
+        height: side,
+    })
+}
+
+fn bitmap_from_dynamic_image(image: DynamicImage) -> Result<IconBitmap, String> {
+    let squared = to_square_rgba(image);
+    let width = squared.width();
+    let height = squared.height();
+
+    Ok(IconBitmap {
+        rgba: squared.into_raw(),
+        width,
+        height,
+    })
+}
+
+fn to_square_rgba(image: DynamicImage) -> RgbaImage {
+    let rgba = image.to_rgba8();
+    let (width, height) = rgba.dimensions();
+    if width == height {
+        return rgba;
+    }
+
+    let side = width.max(height);
+    let mut square = RgbaImage::new(side, side);
+    let x = (side - width) / 2;
+    let y = (side - height) / 2;
+    image::imageops::overlay(&mut square, &rgba, i64::from(x), i64::from(y));
+    square
+}

package/desktop/lib.rs

@@ -0,0 +1,2 @@
+pub mod icon;
+pub mod native_renderer;

package/desktop/main.rs

@@ -0,0 +1,235 @@
+#![cfg_attr(target_os = "windows", windows_subsystem = "windows")]
+
+mod runtime;
+mod icon;
+mod window;
+
+use std::env;
+
+const EMBED_MAGIC_V1: &[u8; 8] = b"WAPKJS\x00\x01";
+const EMBED_MAGIC_V2: &[u8; 8] = b"WAPKRT\x00\x02";
+
+struct EmbeddedApp {
+    runtime: String,
+    code: String,
+}
+
+fn embedded_runtime_name(code: u8) -> Option<&'static str> {
+    match code {
+        1 => Some("quickjs"),
+        2 => Some("bun"),
+        3 => Some("node"),
+        4 => Some("deno"),
+        _ => None,
+    }
+}
+
+fn read_embedded_js(
+    file: &mut std::fs::File,
+    file_size: u64,
+    js_size: usize,
+    trailer_size: usize,
+) -> Option<String> {
+    use std::io::{Read, Seek, SeekFrom};
+
+    let js_offset = (file_size as usize).checked_sub(trailer_size + js_size)?;
+    file.seek(SeekFrom::Start(js_offset as u64)).ok()?;
+
+    let mut js_bytes = vec![0u8; js_size];
+    file.read_exact(&mut js_bytes).ok()?;
+    String::from_utf8(js_bytes).ok()
+}
+
+/// Read JS embedded in this binary (appended after the PE).
+/// V1 layout: [exe bytes][js bytes][js_size: u64 LE][EMBED_MAGIC_V1: 8 bytes]
+/// V2 layout: [exe bytes][js bytes][js_size: u64 LE][runtime_code: u8][EMBED_MAGIC_V2: 8 bytes]
+fn try_embedded_app() -> Option<EmbeddedApp> {
+    use std::io::{Read, Seek, SeekFrom};
+
+    let exe_path = std::env::current_exe().ok()?;
+    let mut f = std::fs::File::open(&exe_path).ok()?;
+    let file_size = f.metadata().ok()?.len();
+
+    if file_size >= 17 {
+        f.seek(SeekFrom::End(-17)).ok()?;
+        let mut trailer = [0u8; 17];
+        f.read_exact(&mut trailer).ok()?;
+
+        if &trailer[9..17] == EMBED_MAGIC_V2 {
+            let js_size = u64::from_le_bytes(trailer[0..8].try_into().ok()?) as usize;
+            let runtime = embedded_runtime_name(trailer[8])?.to_string();
+            let code = read_embedded_js(&mut f, file_size, js_size, 17)?;
+            return Some(EmbeddedApp { runtime, code });
+        }
+    }
+
+    if file_size >= 16 {
+        f.seek(SeekFrom::End(-16)).ok()?;
+        let mut trailer = [0u8; 16];
+        f.read_exact(&mut trailer).ok()?;
+
+        if &trailer[8..16] == EMBED_MAGIC_V1 {
+            let js_size = u64::from_le_bytes(trailer[0..8].try_into().ok()?) as usize;
+            let code = read_embedded_js(&mut f, file_size, js_size, 16)?;
+            return Some(EmbeddedApp {
+                runtime: String::from("quickjs"),
+                code,
+            });
+        }
+    }
+
+    None
+}
+
+fn print_help() {
+    eprintln!(
+        r#"elit-desktop — native WebView runtime for Elit
+
+Usage:
+  elit-desktop [OPTIONS] <script.js>
+
+Options:
+  --runtime <name>   JS runtime to use (default: quickjs)
+                     Choices: quickjs | bun | node | deno
+  --help             Show this help
+
+Examples:
+  elit-desktop app.js
+  elit-desktop --runtime bun app.js
+  elit-desktop --runtime node app.js
+"#
+    );
+}
+
+/// Look for `<exe-stem>.js` next to the running binary (enables standalone app.exe).
+fn auto_detect_script() -> Option<String> {
+    let exe  = std::env::current_exe().ok()?;
+    let stem = exe.file_stem()?.to_str()?.to_string();
+    let dir  = exe.parent()?;
+    let candidate = dir.join(format!("{}.js", stem));
+    if candidate.exists() {
+        Some(candidate.to_string_lossy().into_owned())
+    } else {
+        None
+    }
+}
+
+fn parse_args() -> (String, String) {
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    // No args → try auto-detect bundled script, otherwise show help
+    if args.is_empty() {
+        if let Some(script) = auto_detect_script() {
+            return (String::from("quickjs"), script);
+        }
+        print_help();
+        std::process::exit(0);
+    }
+
+    if args.iter().any(|a| a == "--help" || a == "-h") {
+        print_help();
+        std::process::exit(0);
+    }
+
+    let mut runtime = String::from("quickjs");
+    let mut script  = String::new();
+    let mut i = 0;
+
+    while i < args.len() {
+        match args[i].as_str() {
+            "--runtime" | "-r" => {
+                i += 1;
+                if i < args.len() {
+                    runtime = args[i].clone();
+                }
+            }
+            arg if !arg.starts_with('-') => {
+                script = arg.to_string();
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    if script.is_empty() {
+        if let Some(auto) = auto_detect_script() {
+            return (runtime, auto);
+        }
+        eprintln!("Error: no script file specified.");
+        print_help();
+        std::process::exit(1);
+    }
+
+    (runtime, script)
+}
+
+fn main() {
+    // ── Embedded JS (single-file distribution) ──────────────────────────────
+    if let Some(EmbeddedApp { runtime, code }) = try_embedded_app() {
+        match runtime.as_str() {
+            #[cfg(feature = "runtime-quickjs")]
+            "quickjs" => {
+                window::run(move |proxy, ipc_rx| {
+                    runtime::quickjs::run(&code, proxy, ipc_rx);
+                });
+            }
+
+            #[cfg(feature = "runtime-external")]
+            rt @ ("bun" | "node" | "nodejs" | "deno") => {
+                let name = rt.to_string();
+                window::run(move |proxy, ipc_rx| {
+                    runtime::external::run_embedded(&name, &code, proxy, ipc_rx);
+                });
+            }
+
+            other => {
+                eprintln!(
+                    "Error: embedded runtime '{}' is not available in this build.",
+                    other
+                );
+                std::process::exit(1);
+            }
+        }
+        return;
+    }
+
+    let (runtime_name, script_path) = parse_args();
+
+    // Validate file exists
+    if !std::path::Path::new(&script_path).exists() {
+        eprintln!("Error: '{}' not found.", script_path);
+        std::process::exit(1);
+    }
+
+    match runtime_name.as_str() {
+        // ── Embedded QuickJS (default) ──────────────────────────────────────
+        #[cfg(feature = "runtime-quickjs")]
+        "quickjs" => {
+            let code = std::fs::read_to_string(&script_path)
+                .unwrap_or_else(|_| panic!("Cannot read '{}'", script_path));
+
+            window::run(move |proxy, ipc_rx| {
+                runtime::quickjs::run(&code, proxy, ipc_rx);
+            });
+        }
+
+        // ── External runtime (Bun / Node / Deno) ────────────────────────────
+        #[cfg(feature = "runtime-external")]
+        rt @ ("bun" | "node" | "nodejs" | "deno") => {
+            let path = script_path.clone();
+            let name = rt.to_string();
+
+            window::run(move |proxy, ipc_rx| {
+                runtime::external::run(&name, &path, proxy, ipc_rx);
+            });
+        }
+
+        other => {
+            eprintln!(
+                "Error: unknown runtime '{}'.\nAvailable: quickjs, bun, node, deno",
+                other
+            );
+            std::process::exit(1);
+        }
+    }
+}

package/desktop/native_main.rs

@@ -0,0 +1,128 @@
+#![cfg_attr(target_os = "windows", windows_subsystem = "windows")]
+
+use std::env;
+
+use elit_desktop::native_renderer;
+
+const EMBED_NATIVE_MAGIC_V1: &[u8; 8] = b"ELITNUI1";
+
+fn read_embedded_payload(
+    file: &mut std::fs::File,
+    file_size: u64,
+    payload_size: usize,
+    trailer_size: usize,
+) -> Option<String> {
+    use std::io::{Read, Seek, SeekFrom};
+
+    let payload_offset = (file_size as usize).checked_sub(trailer_size + payload_size)?;
+    file.seek(SeekFrom::Start(payload_offset as u64)).ok()?;
+
+    let mut payload_bytes = vec![0u8; payload_size];
+    file.read_exact(&mut payload_bytes).ok()?;
+    String::from_utf8(payload_bytes).ok()
+}
+
+fn try_embedded_payload() -> Option<String> {
+    use std::io::{Read, Seek, SeekFrom};
+
+    let exe_path = std::env::current_exe().ok()?;
+    let mut file = std::fs::File::open(&exe_path).ok()?;
+    let file_size = file.metadata().ok()?.len();
+
+    if file_size < 16 {
+        return None;
+    }
+
+    file.seek(SeekFrom::End(-16)).ok()?;
+    let mut trailer = [0u8; 16];
+    file.read_exact(&mut trailer).ok()?;
+
+    if &trailer[8..16] != EMBED_NATIVE_MAGIC_V1 {
+        return None;
+    }
+
+    let payload_size = u64::from_le_bytes(trailer[0..8].try_into().ok()?) as usize;
+    read_embedded_payload(&mut file, file_size, payload_size, 16)
+}
+
+fn print_help() {
+    eprintln!(
+        r#"elit-desktop-native — native UI runtime for Elit
+
+Usage:
+  elit-desktop-native [payload.json]
+
+Options:
+  --help             Show this help
+
+Examples:
+  elit-desktop-native app.json
+"#
+    );
+}
+
+fn auto_detect_payload() -> Option<String> {
+    let exe = std::env::current_exe().ok()?;
+    let stem = exe.file_stem()?.to_str()?.to_string();
+    let dir = exe.parent()?;
+    let candidate = dir.join(format!("{}.json", stem));
+    if candidate.exists() {
+        Some(candidate.to_string_lossy().into_owned())
+    } else {
+        None
+    }
+}
+
+fn parse_payload_path() -> String {
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    if args.iter().any(|arg| arg == "--help" || arg == "-h") {
+        print_help();
+        std::process::exit(0);
+    }
+
+    if args.is_empty() {
+        if let Some(payload) = auto_detect_payload() {
+            return payload;
+        }
+
+        print_help();
+        std::process::exit(0);
+    }
+
+    let payload_path = args
+        .iter()
+        .find(|arg| !arg.starts_with('-'))
+        .cloned();
+
+    if let Some(payload_path) = payload_path {
+        return payload_path;
+    }
+
+    if let Some(payload) = auto_detect_payload() {
+        return payload;
+    }
+
+    eprintln!("Error: no payload file specified.");
+    print_help();
+    std::process::exit(1);
+}
+
+fn main() {
+    let payload_json = if let Some(embedded_payload) = try_embedded_payload() {
+        embedded_payload
+    } else {
+        let payload_path = parse_payload_path();
+        std::fs::read_to_string(&payload_path).unwrap_or_else(|error| {
+            eprintln!("Error: failed to read native desktop payload '{}': {}", payload_path, error);
+            std::process::exit(1);
+        })
+    };
+
+    let payload: native_renderer::NativeDesktopPayload = serde_json::from_str(&payload_json).unwrap_or_else(|error| {
+        eprintln!("Error: failed to parse native desktop payload: {}", error);
+        std::process::exit(1);
+    });
+
+    native_renderer::run(payload);
+}