M0.9–M0.10: egui frontend (AE-style panels, viewer, timeline, effect controls, dialogs), desktop app with control channel, host wiring; cargo fmt

Co-Authored-By: Claude Opus 5.5 <[email protected]>

apps/effectcraft/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "effectcraft"
+description = "EffectCraft desktop app"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+default-run = "effectcraft"
+
+[lints]
+workspace = true
+
+[dependencies]
+effectcraft-engine = { workspace = true }
+effectcraft-host = { workspace = true }
+effectcraft-ui-egui = { workspace = true }
+egui = { workspace = true }
+eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11"] }
+serde_json = { workspace = true }
+rfd = { workspace = true }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+# Same winit as eframe: macOS event-loop options (no app activation when driven by an agent).
+winit = { version = "0.30", default-features = false }

apps/effectcraft/src/control_server.rs

@@ -0,0 +1,61 @@
+//! Localhost JSON-lines control server (one request per line, one reply per line). Loopback only.
+
+use std::io::{BufRead, BufReader, Write};
+use std::net::{TcpListener, TcpStream};
+use std::sync::mpsc::{Receiver, Sender, channel};
+use std::time::Duration;
+
+use effectcraft_ui_egui::ControlRequest;
+use serde_json::{Value, json};
+
+pub fn start(port: u16, ctx: egui::Context) -> Receiver<ControlRequest> {
+    let (tx, rx) = channel::<ControlRequest>();
+    let listener = match TcpListener::bind(("127.0.0.1", port)) {
+        Ok(l) => l,
+        Err(e) => {
+            eprintln!("effectcraft: control server failed to bind 127.0.0.1:{port}: {e}");
+            return rx;
+        }
+    };
+    eprintln!("effectcraft: control server listening on 127.0.0.1:{port}");
+    std::thread::spawn(move || {
+        for stream in listener.incoming().flatten() {
+            let tx = tx.clone();
+            let ctx = ctx.clone();
+            std::thread::spawn(move || serve(stream, tx, ctx));
+        }
+    });
+    rx
+}
+
+fn serve(stream: TcpStream, tx: Sender<ControlRequest>, ctx: egui::Context) {
+    let Ok(read) = stream.try_clone() else { return };
+    let mut out = stream;
+    for line in BufReader::new(read).lines() {
+        let Ok(line) = line else { break };
+        if line.trim().is_empty() {
+            continue;
+        }
+        let reply = match serde_json::from_str::<Value>(&line) {
+            Ok(msg) => {
+                let id = msg.get("id").cloned().unwrap_or(Value::Null);
+                let method = msg.get("method").and_then(Value::as_str).unwrap_or("").to_string();
+                let params = msg.get("params").cloned().unwrap_or(json!({}));
+                let (req, rrx) = ControlRequest::new(method, params);
+                if tx.send(req).is_err() {
+                    break;
+                }
+                ctx.request_repaint();
+                let mut r = rrx.recv_timeout(Duration::from_secs(60)).unwrap_or_else(|_| json!({"ok": false, "error": "timeout"}));
+                if let Some(o) = r.as_object_mut() {
+                    o.insert("id".into(), id);
+                }
+                r
+            }
+            Err(e) => json!({"ok": false, "error": format!("bad JSON: {e}")}),
+        };
+        if writeln!(out, "{reply}").is_err() {
+            break;
+        }
+    }
+}

apps/effectcraft/src/main.rs

@@ -0,0 +1,93 @@
+//! EffectCraft desktop app.
+//!
+//! Usage: `effectcraft [--control <port>] [--demo|--empty|--home] [project.ecproj | media files…]`
+//!
+//! `--control <port>` (or `EFFECTCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server;
+//! see `effectcraft_ui_egui::control` for the methods.
+
+mod control_server;
+
+use effectcraft_ui_egui::EffectcraftApp;
+use serde_json::json;
+
+fn main() -> eframe::Result {
+    let mut control_port: Option<u16> = std::env::var("EFFECTCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
+    let mut files = Vec::new();
+    let mut demo = true;
+    let mut home = false;
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match a.as_str() {
+            "--control" => control_port = args.next().and_then(|p| p.parse().ok()),
+            "--demo" => demo = true,
+            "--empty" => demo = false,
+            "--home" => home = true,
+            "--version" => {
+                println!("effectcraft {}", env!("CARGO_PKG_VERSION"));
+                return Ok(());
+            }
+            _ => files.push(a),
+        }
+    }
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_title("EffectCraft")
+            .with_inner_size([1680.0, 1020.0])
+            .with_min_inner_size([960.0, 600.0])
+            .with_drag_and_drop(true)
+            // Started for an agent (`--control`): open without taking the user's keyboard focus.
+            .with_active(control_port.is_none()),
+        event_loop_builder: agent_event_loop(control_port.is_some()),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "EffectCraft",
+        options,
+        Box::new(move |cc| {
+            let mut session = effectcraft_host::session();
+            let project = files.iter().find(|f| f.ends_with(".ecproj")).cloned();
+            if let Some(p) = project {
+                if let Err(e) = session.execute("file.open", json!({"path": p})) {
+                    eprintln!("effectcraft: {e}");
+                }
+            } else if demo {
+                let _ = session.execute("file.openDemoProject", json!({}));
+            }
+            let media: Vec<String> = files.iter().filter(|f| !f.ends_with(".ecproj")).cloned().collect();
+            if !media.is_empty() {
+                if let Err(e) = session.execute("file.import", json!({"paths": media})) {
+                    eprintln!("effectcraft: {e}");
+                }
+            }
+            let mut app = EffectcraftApp::new(session);
+            app.ui.start_screen = home;
+            app.hooks.pick_files = Some(Box::new(|exts: &[&str]| {
+                rfd::FileDialog::new().add_filter("Media", exts).pick_files().unwrap_or_default().into_iter().map(|p| p.to_string_lossy().to_string()).collect()
+            }));
+            app.hooks.pick_save = Some(Box::new(|name: &str| {
+                rfd::FileDialog::new().add_filter("EffectCraft Project", &["ecproj"]).set_file_name(name).save_file().map(|p| p.to_string_lossy().to_string())
+            }));
+            app.hooks.pick_open_project =
+                Some(Box::new(|| rfd::FileDialog::new().add_filter("EffectCraft Project", &["ecproj"]).pick_file().map(|p| p.to_string_lossy().to_string())));
+            if let Some(port) = control_port {
+                let rx = control_server::start(port, cc.egui_ctx.clone());
+                app = app.with_control(rx);
+            }
+            Ok(Box::new(app))
+        }),
+    )
+}
+
+/// Driven by an agent (`--control`): don't activate the app on launch, so the user's keyboard
+/// focus stays where it is (macOS; winit activates ignoring other apps by default).
+fn agent_event_loop(agent: bool) -> Option<eframe::EventLoopBuilderHook> {
+    #[cfg(target_os = "macos")]
+    if agent {
+        return Some(Box::new(|b| {
+            use winit::platform::macos::EventLoopBuilderExtMacOS;
+            b.with_activate_ignoring_other_apps(false);
+        }));
+    }
+    let _ = agent;
+    None
+}