ai-usagebar 1.22.0

Omarchy/Waybar widgets + TUI for tracking multi-provider AI plan usage
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Build the tray WebView (Vite) before compiling the Windows/macOS host.

use std::path::{Path, PathBuf};
use std::process::Command;

fn main() {
    let manifest = Path::new(env!("CARGO_MANIFEST_DIR"));
    let popover = manifest.join("windows").join("popover");
    println!("cargo:rerun-if-changed={}", popover.join("src").display());
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("index.html").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("package.json").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("package-lock.json").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("vite.config.ts").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("components.json").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("dist").join("index.html").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("dist").join("popover.js").display()
    );
    println!(
        "cargo:rerun-if-changed={}",
        popover.join("dist").join("popover.css").display()
    );

    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
    if os != "windows" && os != "macos" {
        return;
    }

    if npm_available() {
        ensure_deps(&popover);
        npm(&popover, &["run", "build"]);
        assert_dist(&popover);
    }
    // The hosts `include_str!` from OUT_DIR, never from the source tree: a
    // read-only checkout (the Nix sandbox) has no dist and cannot take a stub,
    // so the stub goes where cargo lets a build script write.
    let staged =
        PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR is set by cargo")).join("popover");
    std::fs::create_dir_all(&staged).expect("create OUT_DIR/popover");
    if dist_complete(&popover) {
        for name in DIST_FILES {
            std::fs::copy(popover.join("dist").join(name), staged.join(name))
                .unwrap_or_else(|error| panic!("copy {name} into OUT_DIR: {error}"));
        }
    } else {
        write_stub_dist(&staged);
    }
}

const DIST_FILES: [&str; 3] = ["index.html", "popover.js", "popover.css"];

fn npm_available() -> bool {
    npm_command()
        .arg("--version")
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status()
        .map(|status| status.success())
        .unwrap_or(false)
}

fn dist_complete(dir: &Path) -> bool {
    DIST_FILES
        .iter()
        .all(|name| dir.join("dist").join(name).is_file())
}

/// A placeholder page for a build without Node: the tray links and says why
/// the popover is empty instead of failing the whole workspace build.
fn write_stub_dist(staged: &Path) {
    let stub: [(&str, &str); 3] = [
        (
            "index.html",
            "<!doctype html><title>ai-usagebar</title><p>popover dist missing: run npm run build in windows/popover</p>\n",
        ),
        ("popover.js", "/* stub */\n"),
        ("popover.css", "/* stub */\n"),
    ];
    for (name, body) in stub {
        std::fs::write(staged.join(name), body)
            .unwrap_or_else(|error| panic!("write stub {name} into OUT_DIR: {error}"));
    }
}

fn ensure_deps(dir: &Path) {
    if dir.join("node_modules").join("vite").exists() {
        return;
    }
    if dir.join("package-lock.json").exists() {
        npm(dir, &["ci"]);
    } else {
        npm(dir, &["install"]);
    }
}

fn assert_dist(dir: &Path) {
    for name in DIST_FILES {
        let path: PathBuf = dir.join("dist").join(name);
        if !path.is_file() {
            panic!(
                "Windows tray UI build did not emit {} — `npm run build` in {}",
                path.display(),
                dir.display()
            );
        }
    }
}

fn npm_command() -> std::process::Command {
    // npm is a .cmd shim on Windows; `Command::new("npm")` cannot spawn it
    // (CreateProcess does not execute .cmd files), so go through cmd /C —
    // exactly like `npm()`. One helper for every caller so the availability
    // probe and the invocation can never disagree again (#229: the probe
    // called npm directly, always failed on Windows, and the release shipped
    // the stub popover).
    if cfg!(windows) {
        let mut cmd = Command::new("cmd");
        cmd.args(["/C", "npm"]);
        cmd
    } else {
        Command::new("npm")
    }
}

fn npm(dir: &Path, args: &[&str]) {
    let mut command = npm_command();
    let status = command
        .args(args)
        .current_dir(dir)
        .status()
        .unwrap_or_else(|error| panic!("npm {} failed to start: {error}", args.join(" ")));
    if !status.success() {
        panic!(
            "npm {} failed in {} (status {status}). Install Node.js 20+, then retry.",
            args.join(" "),
            dir.display()
        );
    }
}