- bench/ FastAPI server: fixed 9-stage pipeline parsed from the base workflow, serial render jobs, WS progress mirroring ComfyUI's push events, /api/view + ComfyUI-compatible /view, /upload/image, /easy-media/* aliases for the ported editor - dual backend: self-contained mock renderer (numpy+ffmpeg, deterministic per prompt/seed, native + RTX-upscaled mp4 branches) and a ComfyUI bridge (substitutes the plan into base_workflow.json, converts to the /prompt API format, polls history, downloads outputs) - timeline port: frontend/src/bench mounts the unmodified MultiTrack editor against a comfyAPI shim (fetchApi/toast/dialog/custom events); build.bench.ts emits bench/ui-dist served by the server - packaging: PyInstaller onedir spec + Tauri2 sidecar docs - tests: bench/tests contract suite + scripts/test_bench_pipeline.py e2e (API+WS+render); prebuilt bench UI committed
111 lines
3.3 KiB
Markdown
111 lines
3.3 KiB
Markdown
# Using the bench as a Tauri 2 sidecar
|
|
|
|
The bench is a self-contained Python HTTP server (FastAPI + uvicorn). Packaged
|
|
with PyInstaller it becomes an `moxie-bench` binary your Tauri 2 app spawns at
|
|
startup and talks to over `http://127.0.0.1:<port>`.
|
|
|
|
## 1. Build the sidecar
|
|
|
|
```bash
|
|
# in the MMnode repo
|
|
pip install -r bench/requirements.txt pyinstaller
|
|
cd frontend && bun install && bun run build:bench:release && cd ..
|
|
pyinstaller bench/moxie_bench.spec
|
|
# -> dist/moxie-bench/moxie-bench(.exe) + _internal/
|
|
```
|
|
|
|
Ship the whole `dist/moxie-bench/` folder (onedir layout: the binary needs
|
|
`_internal/` beside it).
|
|
|
|
## 2. Bundle it with the Tauri app
|
|
|
|
`tauri.conf.json` (resources approach — simplest and cross-platform):
|
|
|
|
```json
|
|
{
|
|
"bundle": {
|
|
"resources": {
|
|
"../MMnode/dist/moxie-bench/": "moxie-bench/"
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
The folder lands in the app resource dir; resolve it at runtime with
|
|
`@tauri-apps/api/path` → `resourceDir()`.
|
|
|
|
## 3. Spawn and wait for health
|
|
|
|
Rust side (tauri plugin-shell or std::process):
|
|
|
|
```rust
|
|
use std::process::{Command, Stdio};
|
|
use std::time::Duration;
|
|
|
|
let sidecar = app.path().resource_dir()?.join("moxie-bench/moxie-bench");
|
|
let port: u16 = 8787; // pick a free port, pass it through
|
|
let mut child = Command::new(sidecar)
|
|
.arg("--port").arg(port.to_string())
|
|
.arg("--host").arg("127.0.0.1")
|
|
.arg("--backend").arg("auto") // mock when no ComfyUI is reachable
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::null())
|
|
.spawn()?;
|
|
|
|
// poll until ready before loading the webview UI
|
|
async fn wait_healthy(port: u16) -> bool {
|
|
let url = format!("http://127.0.0.1:{port}/api/health");
|
|
for _ in 0..60 {
|
|
if let Ok(resp) = reqwest::get(&url).await {
|
|
if resp.status().is_success() { return true; }
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
}
|
|
false
|
|
}
|
|
```
|
|
|
|
## 4. Drive it from the webview
|
|
|
|
Everything the bench UI does is plain HTTP/WS on the same origin — the Tauri
|
|
webview can call the same endpoints:
|
|
|
|
| Action | Call |
|
|
|---|---|
|
|
| health/backend | `GET /api/health`, `GET /api/config` |
|
|
| base workflow + timeline | `GET /api/workflow` |
|
|
| render plan preview | `GET /api/plan` |
|
|
| queue a render | `POST /api/render {track_data, overrides}` |
|
|
| live progress | WebSocket `ws://127.0.0.1:<port>/api/ws` |
|
|
| job list / detail | `GET /api/jobs`, `GET /api/jobs/{id}` |
|
|
| play/save outputs | `GET /api/view?filename=...&type=output&job=<job_id>` |
|
|
|
|
`POST /api/render` body:
|
|
|
|
```json
|
|
{
|
|
"track_data": { "tracks": [ ... editor JSON ... ] },
|
|
"overrides": {
|
|
"width": 1920, "height": 1080, "frame_rate": 24,
|
|
"steps": 4, "seed": 12345, "project_name": "MM-myproject",
|
|
"backend": "auto"
|
|
}
|
|
}
|
|
```
|
|
|
|
## 5. Backends
|
|
|
|
- `mock` — self-contained synthetic renderer (numpy + ffmpeg). Deterministic
|
|
per (prompt, seed); real mp4 + audio on both output branches. Use it to
|
|
develop the Tauri integration with zero model downloads.
|
|
- `comfy` — drives a running ComfyUI (`--comfyui-url`, default
|
|
`http://127.0.0.1:8188`) with the exact base workflow. Real generation, same
|
|
API surface. Start ComfyUI headless: `python main.py --listen 127.0.0.1`.
|
|
- `auto` (default) — comfy when reachable, else mock.
|
|
|
|
## 6. Shutdown
|
|
|
|
Kill the spawned process on app exit (Rust `child.kill()` / `Drop`), or send
|
|
SIGTERM. The server has no state beyond `work/` on disk; job history lives in
|
|
memory.
|