waos-cli 0.1.0

cargo waos: writes a new program, builds a program as a component, runs it in the WaOS on this machine, and packages it as a signed .wapk.
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

//! Starting the WaOS app installed on this machine, for a run when no WaOS answers, with its log
//! kept where the user's logs are.
//!
//! The invariant: the app is found as the system finds an installed app, by its identifier,
//! never by a path in a checkout: whoever writes a program has WaOS installed, as Expo Go is
//! installed for a project's author.

use std::path::PathBuf;

use anyhow::Result;

/// The app's identifier, as `apps/waos`'s `[package.metadata.waft]` sets it.
pub const BUNDLE_IDENTIFIER: &str = "dev.waos.app";

/// What WaOS is started with: its library's panel closed, so a development run shows only the
/// program; the panel opens at a click on WaOS's Dock icon.
#[cfg(target_os = "macos")]
const PANEL_CLOSED: &str = "--panel-closed";

/// What WaOS reads from its environment, passed on when set here: `RUST_LOG`, what its log
/// holds, and `WAOS_NATIVE_UNWIND_INFO`, whether it compiles programs with what a native profiler
/// or debugger needs to walk through their frames.
#[cfg(target_os = "macos")]
const PASSED_ON: [&str; 2] = ["RUST_LOG", "WAOS_NATIVE_UNWIND_INFO"];

/// Starts WaOS.app, as the Finder would but with its library's panel closed ([`PANEL_CLOSED`]),
/// and answers where its log goes once the system has taken the request; the app answers on its
/// socket a moment later.
///
/// What WaOS writes to standard error, its log, is appended to `~/Library/Logs/WaOS.log`, and
/// the variables of [`PASSED_ON`] set here are passed on. All three take effect only when the
/// system starts the app: a WaOS running already keeps its own.
#[cfg(target_os = "macos")]
pub fn start() -> Result<PathBuf> {
    use std::ffi::OsString;
    use std::process::Command;

    use anyhow::{Context, bail};

    let log = log_path();
    let mut open = Command::new("open");
    open.args(["-b", BUNDLE_IDENTIFIER])
        .arg("--stderr")
        .arg(&log);
    for name in PASSED_ON {
        if let Some(value) = std::env::var_os(name) {
            let mut variable = OsString::from(format!("{name}="));
            variable.push(value);
            open.arg("--env").arg(variable);
        }
    }
    // What follows `--args` is WaOS's own command line, and comes last.
    open.args(["--args", PANEL_CLOSED]);
    let status = open.status().context("running open")?;
    if !status.success() {
        bail!(
            "WaOS.app is not installed: build it with `cargo waft build macos -p waos-app` and open it once, so the system knows where it is"
        );
    }
    Ok(log)
}

/// Where a WaOS started here keeps its log: the user's logs, where Console finds it.
#[cfg(target_os = "macos")]
fn log_path() -> PathBuf {
    let home = std::env::home_dir().unwrap_or_else(|| PathBuf::from("/"));
    home.join("Library/Logs/WaOS.log")
}

#[cfg(not(target_os = "macos"))]
pub fn start() -> Result<PathBuf> {
    anyhow::bail!(
        "no WaOS answers, and only macOS's WaOS.app ({BUNDLE_IDENTIFIER}) is known how to start: start WaOS yourself"
    )
}