maestro/crates/maestro-web/build.rs

//! Resolve the SPA bundle that gets embedded at compile time.
//!
//! `static_bundle.rs` embeds a directory via `include_dir!`, and the directory
//! it reads is whatever this script puts in `MAESTRO_WEB_BUNDLE_DIR`.
//!
//! Two modes:
//!
//! * `MAESTRO_WEB_DIST` set — the bundle was built elsewhere (Nix, CI, a
//!   release pipeline) and that directory is embedded as-is. No node, no pnpm.
//! * unset — the default developer path: run `pnpm install --frozen-lockfile
//!   && pnpm build` in `web/` and embed `web/dist`. pnpm and node are HARD
//!   requirements here; a missing toolchain fails with an actionable message
//!   rather than silently shipping the placeholder.

use std::env;
use std::path::PathBuf;
use std::process::Command;

fn main() {
    println!("cargo:rerun-if-env-changed=MAESTRO_WEB_DIST");

    let dist_dir = match env::var_os("MAESTRO_WEB_DIST") {
        Some(prebuilt) => PathBuf::from(prebuilt),
        None => build_with_pnpm(),
    };

    // Sanity-check that the directory really holds a bundle. A green build
    // that embeds an empty/placeholder dir is worse than a loud failure here.
    let index_html = dist_dir.join("index.html");
    let produced = std::fs::metadata(&index_html)
        .map(|m| m.is_file() && m.len() > 0)
        .unwrap_or(false);
    if !produced {
        panic!(
            "no SPA bundle at {} (missing or empty index.html) — \
             check the vite `outDir`, or the MAESTRO_WEB_DIST override.",
            index_html.display()
        );
    }

    // `include_dir!` expands `$VAR` in its path argument against the env rustc
    // is invoked with, which is what `cargo:rustc-env` sets.
    println!(
        "cargo:rustc-env=MAESTRO_WEB_BUNDLE_DIR={}",
        dist_dir.display()
    );
}

/// The default path: build `web/` in-tree with pnpm and return `web/dist`.
fn build_with_pnpm() -> PathBuf {
    let manifest_dir =
        PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR set by cargo"));
    let web_dir = manifest_dir.join("../../web");

    // Rebuild the bundle only when a frontend input changes — not on every
    // unrelated Rust recompile.
    for rel in [
        "src",
        "index.html",
        "package.json",
        "pnpm-lock.yaml",
        "vite.config.ts",
    ] {
        println!("cargo:rerun-if-changed={}", web_dir.join(rel).display());
    }

    // Also watch the embedded OUTPUT directory. The input watches above decide
    // whether THIS script re-runs and regenerates `web/dist`; but `include_dir!`
    // in `static_bundle.rs` reads that directory, and cargo has no other
    // declared dependency on those output files. Without this watch, an
    // incremental build could regenerate `web/dist` yet keep the OLD bundle
    // embedded. Tying the crate's recompilation to the regenerated output makes
    // the fresh assets actually get re-embedded.
    let dist_dir = web_dir.join("dist");
    println!("cargo:rerun-if-changed={}", dist_dir.display());

    require_tool("pnpm");
    require_tool("node");

    run(
        Command::new("pnpm")
            .args(["install", "--frozen-lockfile"])
            .current_dir(&web_dir),
        "pnpm install --frozen-lockfile",
    );
    run(
        Command::new("pnpm").arg("build").current_dir(&web_dir),
        "pnpm build",
    );

    dist_dir
}

fn require_tool(tool: &str) {
    let ok = Command::new(tool)
        .arg("--version")
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false);
    if !ok {
        panic!(
            "maestro-web requires `{tool}` to build its embedded SPA bundle. \
             Install pnpm + node (https://pnpm.io), or point MAESTRO_WEB_DIST \
             at a prebuilt bundle."
        );
    }
}

fn run(cmd: &mut Command, label: &str) {
    let status = cmd
        .status()
        .unwrap_or_else(|e| panic!("failed to spawn `{label}`: {e}"));
    if !status.success() {
        panic!("`{label}` failed with {status}");
    }
}