M0: desktop app: toolbar, browser, timeline, GPU viewport, view cube, sketch tools, dialogs, control channel

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

apps/solvecraft/Cargo.toml

@@ -1,5 +1,20 @@
 [package]
 name = "solvecraft"
+description = "SolveCraft desktop app"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
+publish = false
+default-run = "solvecraft"
+
+[lints]
+workspace = true
+
+[dependencies]
+solvecraft-engine = { workspace = true }
+solvecraft-ui-egui = { workspace = true }
+eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11"] }
+egui = { workspace = true }
+serde_json = { workspace = true }
+log = { workspace = true }
+rfd = { workspace = true }

apps/solvecraft/src/control_server.rs

@@ -0,0 +1,62 @@
+//! Loopback JSON-lines control server: one request per line, one reply per line.
+//! Agents and tests drive the app through it (adapted from CADCraft, MIT OR Apache-2.0).
+
+use std::io::{BufRead, BufReader, Write};
+use std::net::{TcpListener, TcpStream};
+use std::sync::mpsc::{Receiver, Sender, channel};
+use std::time::Duration;
+
+use serde_json::{Value, json};
+use solvecraft_ui_egui::ControlRequest;
+
+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!("solvecraft: control server failed to bind 127.0.0.1:{port}: {e}");
+            return rx;
+        }
+    };
+    eprintln!("solvecraft: 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/solvecraft/src/main.rs

@@ -1 +1,109 @@
-fn main() {}
+//! SolveCraft desktop app.
+//!
+//! Usage: `solvecraft [--control <port>] [--sample] [design.solvecraft]`
+//!
+//! `--control <port>` (or `SOLVECRAFT_CONTROL_PORT`) starts a localhost JSON-lines control
+//! server: `{"id":1,"method":"engine.execute","params":{"command":"PrimitiveBox","params":{…}}}`.
+//! See `solvecraft_ui_egui::control` and docs/control-protocol.md.
+#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
+
+mod control_server;
+
+use solvecraft_engine::Session;
+use solvecraft_ui_egui::{Services, SolveApp};
+
+struct App(SolveApp);
+
+impl eframe::App for App {
+    fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        self.0.logic(ctx);
+        if self.0.quit_requested {
+            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+        }
+    }
+    fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
+        self.0.raw_input_hook(raw);
+    }
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
+        self.0.ui(ui);
+    }
+}
+
+fn services() -> Services {
+    Services {
+        pick_open: Some(Box::new(|| {
+            rfd::FileDialog::new()
+                .add_filter("SolveCraft design", &["solvecraft"])
+                .add_filter("All files", &["*"])
+                .pick_file()
+                .map(|p| p.to_string_lossy().to_string())
+        })),
+        pick_save: Some(Box::new(|name: &str, exts: &[&str]| {
+            rfd::FileDialog::new().set_file_name(name).add_filter("File", exts).save_file().map(|p| p.to_string_lossy().to_string())
+        })),
+    }
+}
+
+const DEPTH_BITS: u8 = 24;
+const MSAA: u16 = 4;
+
+fn main() -> eframe::Result {
+    let mut control_port: Option<u16> = std::env::var("SOLVECRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
+    let mut files = Vec::new();
+    let mut sample = 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()),
+            "--sample" => sample = true,
+            "--version" | "-V" => {
+                println!("solvecraft {}", env!("CARGO_PKG_VERSION"));
+                return Ok(());
+            }
+            "--help" | "-h" => {
+                println!("usage: solvecraft [--control PORT] [--sample] [design.solvecraft]");
+                return Ok(());
+            }
+            _ => files.push(a),
+        }
+    }
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_title("SolveCraft")
+            .with_inner_size([1600.0, 1000.0])
+            .with_min_inner_size([960.0, 600.0])
+            .with_drag_and_drop(true)
+            .with_app_id("ai.storyteller.solvecraft"),
+        depth_buffer: DEPTH_BITS,
+        multisampling: MSAA,
+        ..Default::default()
+    };
+    eframe::run_native(
+        "SolveCraft",
+        options,
+        Box::new(move |cc| {
+            let mut app = SolveApp::new(Session::default(), services());
+            if let Some(rs) = &cc.wgpu_render_state {
+                app.set_wgpu(rs, DEPTH_BITS, u32::from(MSAA));
+            }
+            if let Some(port) = control_port {
+                let rx = control_server::start(port, cc.egui_ctx.clone());
+                app = app.with_control(rx);
+            }
+            if sample {
+                if let Err(e) = app.session.run_script(&solvecraft_engine::sample::script()) {
+                    app.set_status(format!("sample: {e}"), true);
+                }
+                app.session.doc_mut().name = "Sample Plate".into();
+                app.session.mark_saved();
+                app.session.undo.clear();
+            }
+            for f in &files {
+                app.open_path(f);
+            }
+            Ok(Box::new(App(app)))
+        }),
+    )
+}