opencode/packages/process-daemon/build.rs

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

fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-changed=ghostty-revision");
    println!("cargo:rerun-if-changed=src/ghostty/ffi.rs");
    println!("cargo:rerun-if-env-changed=GHOSTTY_SOURCE_DIR");
    println!("cargo:rerun-if-env-changed=OPENCODE_ZIG_CPU");

    let revision = include_str!("ghostty-revision").trim();
    assert_eq!(
        include_str!("src/ghostty/ffi.rs")
            .lines()
            .find_map(|line| line.strip_prefix("// Ghostty revision: ")),
        Some(revision),
        "regenerate the bindings with script/ghostty-bindings"
    );
    let out = PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR"));
    let source = match env::var_os("GHOSTTY_SOURCE_DIR") {
        Some(path) => {
            let path = PathBuf::from(path);
            for relative in ["src", "pkg", "include", "build.zig", "build.zig.zon"] {
                println!("cargo:rerun-if-changed={}", path.join(relative).display());
            }
            path
        }
        None => {
            let path = out.join(format!("ghostty-{revision}"));
            if !path.join(".checkout-complete").exists() {
                if !path.join(".git").exists() {
                    run(Command::new("git").args(["init"]).arg(&path));
                }
                run(Command::new("git").arg("-C").arg(&path).args([
                    "fetch",
                    "--depth=1",
                    "https://github.com/ghostty-org/ghostty.git",
                    revision,
                ]));
                run(Command::new("git").arg("-C").arg(&path).args([
                    "-c",
                    "core.longpaths=true",
                    "checkout",
                    "--detach",
                    revision,
                ]));
                std::fs::write(path.join(".checkout-complete"), revision)
                    .expect("record Ghostty checkout");
            }
            path
        }
    };

    // The checked-in declarations must match the native headers exactly.
    // Local overrides are useful for builds, but not for silently changing ABI.
    let head = Command::new("git")
        .arg("-C")
        .arg(&source)
        .args(["rev-parse", "HEAD"])
        .output()
        .expect("read Ghostty revision");
    assert!(
        head.status.success(),
        "GHOSTTY_SOURCE_DIR must be a Git checkout"
    );
    assert_eq!(
        String::from_utf8(head.stdout)
            .expect("Ghostty revision UTF-8")
            .trim(),
        revision,
        "Ghostty headers and bindings are pinned together; regenerate before changing the revision"
    );
    run(Command::new("git").arg("-C").arg(&source).args([
        "-c",
        "core.longpaths=true",
        "diff",
        "--quiet",
        "HEAD",
        "--",
        "include/ghostty",
    ]));

    let target = env::var("TARGET").expect("TARGET");
    let install = out.join("ghostty-install");
    let mut build = Command::new("zig");
    build.current_dir(&source).args([
        "build",
        "-Demit-lib-vt=true",
        "-Demit-xcframework=false",
        "-Dapp-runtime=none",
    ]);
    build.arg(if env::var("DEBUG").as_deref() == Ok("true") {
        "-Doptimize=Debug"
    } else if matches!(env::var("OPT_LEVEL").as_deref(), Ok("s" | "z")) {
        "-Doptimize=ReleaseSmall"
    } else {
        "-Doptimize=ReleaseFast"
    });
    // Release builds pin a portable CPU. Unix releases use script/release-bin/zig;
    // Windows cannot run that shell wrapper, so it sets this instead.
    if let Ok(cpu) = env::var("OPENCODE_ZIG_CPU") {
        build.arg(format!("-Dcpu={cpu}"));
    }
    build.arg("--prefix").arg(&install);
    build.arg("--cache-dir").arg(out.join("zig-cache"));
    if env::var("HOST").as_deref() != Ok(target.as_str()) {
        let zig_target = match target.as_str() {
            "x86_64-unknown-linux-gnu" => "x86_64-linux-gnu",
            "aarch64-unknown-linux-gnu" => "aarch64-linux-gnu",
            "x86_64-unknown-linux-musl" => "x86_64-linux-musl",
            "aarch64-unknown-linux-musl" => "aarch64-linux-musl",
            "x86_64-apple-darwin" => "x86_64-macos",
            "aarch64-apple-darwin" => "aarch64-macos",
            "x86_64-pc-windows-msvc" => "x86_64-windows-msvc",
            "aarch64-pc-windows-msvc" => "aarch64-windows-msvc",
            _ => panic!("unsupported Ghostty target: {target}"),
        };
        build.arg(format!("-Dtarget={zig_target}"));
    }
    run(&mut build);

    let library = install.join("lib");
    let windows = target.contains("windows");
    assert!(
        library
            .join(if windows {
                "ghostty-vt-static.lib"
            } else {
                "libghostty-vt.a"
            })
            .is_file()
    );
    println!("cargo:rustc-link-search=native={}", library.display());
    // ghostty-vt.lib is the Windows DLL import library, not the static archive.
    println!(
        "cargo:rustc-link-lib={}",
        if windows {
            "static:+verbatim=ghostty-vt-static.lib"
        } else {
            "static=ghostty-vt"
        }
    );
}

fn run(command: &mut Command) {
    let status = command
        .status()
        .unwrap_or_else(|error| panic!("{command:?}: {error}"));
    assert!(status.success(), "{command:?} failed: {status}");
}