monolith

public

Star0

Fork 0

Watch0

19 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `5b7cddd2e177`

tarball

atagen <boss@atagen.co>2026-10-16 10:44 UTC

5 files changed+112-33

monolith: parse the command line with pound

Any argument that was not a client subcommand used to be taken as a program to start, so `monolith --help` launched a second compositor spawning `--help`. Starting a program now goes through an explicit `run` subcommand, and bare `monolith` still runs the compositor.

Modified file: Cargo.lock+40 additions@@ -400,6 +400,7 @@ dependencies = [
  "monolith-layout",
  "monolith-protocols",
  "monolith-render-vk",
+ "pound",
  "serde_json",
  "slotmap",
  "smithay",
@@ -535,6 +536,35 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 
 [[package]]
+name = "pound"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a1548289dfa12bd53954303a19ef93cfc3d834f9211e3e182bf12aef41f003"
+dependencies = [
+ "pound-derive",
+]
+
+[[package]]
+name = "pound-derive"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b0f793b0c8b1db299b1a3bd960b8bd7b5aadc58b2291b647c8c0faa91b14af4"
+dependencies = [
+ "pound-derive-impl",
+]
+
+[[package]]
+name = "pound-derive-impl"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a6ddc2609d7787602494304b1b676676cddcc2f775db9aae178d4f47c6b7a45"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "venial",
+]
+
+[[package]]
 name = "presser"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1088,6 +1118,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
+name = "venial"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a42528baceab6c7784446df2a10f4185078c39bf73dc614f154353f1a6b1229"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"

Modified file: crates/monolith/Cargo.toml+1

@@ -18,6 +18,7 @@ monolith-ipc.workspace = true

1818 monolith-layout.workspace = true

1919 monolith-protocols.workspace = true

2020 monolith-render-vk.workspace = true

21+pound = "0.5"

2122 serde_json.workspace = true

2223 slotmap.workspace = true

2324 smithay = { workspace = true, features = ["desktop"] }

Modified file: crates/monolith/src/ipc.rs+5 additions−19 deletions@@ -2,7 +2,7 @@
 //! subcommands that talk to it.
 
 use crate::state::{State, identity};
-use monolith_ipc::{Answer, Command, Envelope, Query, Reply, Request, VERSION};
+use monolith_ipc::{Answer, Envelope, Query, Reply, Request, VERSION};
 use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{EventLoop, Interest, LoopHandle, Mode, PostAction};
 use std::io::{BufRead, BufReader, ErrorKind, Read, Write};
@@ -208,26 +208,12 @@ fn snapshot(state: &State) -> monolith_ipc::State {
     }
 }
 
-/// Runs a client subcommand, if `args` names one.
-pub fn client(args: &[String]) -> Option<ExitCode> {
-    let (sub, rest) = args.split_first()?;
-    let request = match sub.as_str() {
-        "msg" => match Command::parse(rest) {
-            Ok(cmd) => Request::Run(cmd),
-            Err(e) => return Some(fail(&e.to_string())),
-        },
-        "get" => match rest {
-            [q] if q == "state" => Request::Get(Query::State),
-            [q] if q == "version" => Request::Get(Query::Version),
-            _ => return Some(fail("get takes state or version")),
-        },
-        "subscribe" => Request::Subscribe {},
-        _ => return None,
-    };
-    Some(talk(request))
+/// Sends `request` to the running compositor and prints the reply.
+pub fn client(request: Request) -> ExitCode {
+    talk(request)
 }
 
-fn fail(msg: &str) -> ExitCode {
+pub fn fail(msg: &str) -> ExitCode {
     eprintln!("monolith: {msg}");
     ExitCode::FAILURE
 }

Modified file: crates/monolith/src/main.rs+64 additions−13 deletions@@ -6,23 +6,75 @@ mod launch;
 mod nested;
 mod state;
 
+use monolith_ipc::{Command, Query, Request};
+use pound::{Parse, ValueEnum};
 use smithay::reexports::calloop::EventLoop;
 use smithay::reexports::wayland_server::Display;
 use state::State;
+use std::path::PathBuf;
 use std::process::ExitCode;
 use tracing_subscriber::EnvFilter;
 
+/// a tiling Wayland compositor
+#[derive(Parse)]
+#[pound(name = "monolith")]
+struct Cli {
+    #[pound(subcommand)]
+    cmd: Option<Cmd>,
+}
+
+#[derive(Parse)]
+enum Cmd {
+    /// run the compositor, the default
+    Run {
+        /// read this config instead of ~/.config/monolith/config.toml
+        #[pound(long)]
+        config: Option<String>,
+        /// a program to start inside, with its arguments
+        #[pound(trailing)]
+        program: Vec<String>,
+    },
+    /// send a command to the running compositor, e.g. `msg focus left`
+    Msg {
+        #[pound(trailing)]
+        command: Vec<String>,
+    },
+    /// print the running compositor's state or version
+    Get { what: What },
+    /// print the state as a JSON line after every change
+    Subscribe,
+}
+
+#[derive(ValueEnum)]
+enum What {
+    State,
+    Version,
+}
+
 fn main() -> ExitCode {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    if let Some(code) = ipc::client(&args) {
-        return code;
-    }
+    let (config, program) = match Cli::parse().cmd {
+        None => (None, Vec::new()),
+        Some(Cmd::Run { config, program }) => (config.map(PathBuf::from), program),
+        Some(Cmd::Msg { command }) => {
+            return match Command::parse(&command) {
+                Ok(cmd) => ipc::client(Request::Run(cmd)),
+                Err(e) => ipc::fail(&e.to_string()),
+            };
+        }
+        Some(Cmd::Get { what }) => {
+            return ipc::client(Request::Get(match what {
+                What::State => Query::State,
+                What::Version => Query::Version,
+            }));
+        }
+        Some(Cmd::Subscribe) => return ipc::client(Request::Subscribe {}),
+    };
     tracing_subscriber::fmt()
         .with_env_filter(
             EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
         )
         .init();
-    match run(&args) {
+    match run(config, &program) {
         Ok(()) => ExitCode::SUCCESS,
         Err(e) => {
             tracing::error!("{e}");
@@ -31,20 +83,19 @@ fn main() -> ExitCode {
     }
 }
 
-/// Runs the compositor. Any arguments are a program to start inside it.
-fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+fn run(config: Option<PathBuf>, program: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     let mut event_loop: EventLoop<'static, State> = EventLoop::try_new()?;
     let display: Display<State> = Display::new()?;
-    let mut state = State::new(&mut event_loop, display)?;
+    let mut state = State::new(&mut event_loop, display, config)?;
     nested::init(&mut event_loop, &mut state)?;
     ipc::init(&event_loop, &mut state)?;
     tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running nested");
 
-    let startup = state.config.startup.clone();
-    for argv in startup
-        .iter()
-        .chain((!args.is_empty()).then_some(&args.to_vec()))
-    {
+    let mut startup = state.config.startup.clone();
+    if !program.is_empty() {
+        startup.push(program.to_vec());
+    }
+    for argv in &startup {
         if let Err(e) = state.spawn(argv) {
             tracing::warn!("startup: {e}");
         }

Modified file: crates/monolith/src/state.rs+2 additions−1 deletions@@ -71,9 +71,10 @@ impl State {
     pub fn new(
         event_loop: &mut EventLoop<State>,
         display: Display<State>,
+        config_path: Option<PathBuf>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let dh = display.handle();
-        let config_path = Config::path();
+        let config_path = config_path.or_else(Config::path);
         let config = Config::load(config_path.as_deref()).unwrap_or_else(|e| {
             tracing::error!("config: {e}, using the built-in default");
             Config::parse(monolith_config::DEFAULT).expect("the default config parses")

monolith

Commit 5b7cddd2e177

Commit `5b7cddd2e177`