add request list command

Status	File	+	-
M	`README.md`	2	1
M	`garwarp-ipc/src/lib.rs`	47	0
M	`garwarp/src/daemon.rs`	56	0
M	`garwarpctl/src/main.rs`	32	0

README.mdmodified


 4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
 5. Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`
 6. Transition mock request: `cargo run -p garwarpctl -- transition req-1 :1.2 awaiting_user`
+7. List known requests: `cargo run -p garwarpctl -- list`
+8. Inspect request snapshot: `cargo run -p garwarpctl -- inspect req-1`
 
 ## Runtime Tuning
 1. `GARWARP_REQUEST_TIMEOUT_MS`: timeout before in-flight requests are marked `expired`.

garwarp-ipc/src/lib.rsmodified

  pub enum ControlRequest {
      Status,
      Stop,
++    ListRequests,
      InspectRequest {
          id: String,
      },
          match self {
              Self::Status => "status".to_string(),
              Self::Stop => "stop".to_string(),
++            Self::ListRequests => "list".to_string(),
              Self::InspectRequest { id } => format!("inspect id={id}"),
              Self::BeginRequest {
                  id,
          if trimmed == "stop" {
              return Some(Self::Stop);
+         }
++        if trimmed == "list" {
++            return Some(Self::ListRequests);
++        }
          let mut parts = trimmed.split_whitespace();
          match parts.next() {
  pub enum ControlResponse {
      Status(StatusResponse),
      AckStopping,
++    RequestList {
++        ids: Vec<String>,
++    },
      AckRequest {
          id: String,
          state: String,
                  status.in_flight_requests
              ),
              Self::AckStopping => "ack stopping\n".to_string(),
++            Self::RequestList { ids } => {
++                let ids = if ids.is_empty() {
++                    "-".to_string()
++                } else {
++                    ids.join(",")
++                };
++                format!("list ids={ids}\n")
++            }
              Self::AckRequest { id, state } => {
                  format!("ack request id={} state={}\n", id, state)
+             }
                  Some(other) => Err(ParseError::UnknownToken(other.to_string())),
                  None => Err(ParseError::MissingField("ack")),
              },
++            Some("list") => {
++                let mut ids = None;
++                for part in parts {
++                    let (key, value) = part
++                        .split_once('=')
++                        .ok_or(ParseError::InvalidField(part.to_string()))?;
++                    match key {
++                        "ids" => {
++                            if value == "-" {
++                                ids = Some(Vec::new());
++                            } else {
++                                let parsed =
++                                    value.split(',').map(str::to_string).collect::<Vec<_>>();
++                                if parsed.iter().any(|id| id.is_empty()) {
++                                    return Err(ParseError::InvalidField(part.to_string()));
++                                }
++                                ids = Some(parsed);
++                            }
++                        }
++                        _ => return Err(ParseError::InvalidField(part.to_string())),
++                    }
++                }
++                Ok(Self::RequestList {
++                    ids: ids.ok_or(ParseError::MissingField("ids"))?,
++                })
++            }
              Some("snapshot") => {
                  let mut id = None;
                  let mut state = None;
          for request in [
              ControlRequest::Status,
              ControlRequest::Stop,
++            ControlRequest::ListRequests,
              ControlRequest::InspectRequest {
                  id: "req-1".to_string(),
              },
      fn response_ack_roundtrip() {
          for response in [
              ControlResponse::AckStopping,
++            ControlResponse::RequestList {
++                ids: vec!["req-1".to_string(), "req-2".to_string()],
++            },
++            ControlResponse::RequestList { ids: Vec::new() },
              ControlResponse::AckRequest {
                  id: "req-1".to_string(),
                  state: "pending".to_string(),

garwarp/src/daemon.rsmodified

              state.running = false;
              ControlResponse::AckStopping
+         }
++        Some(ControlRequest::ListRequests) => {
++            let ids = state
++                .requests
++                .records()
++                .into_iter()
++                .map(|record| record.id)
++                .collect::<Vec<_>>();
++            ControlResponse::RequestList { ids }
++        }
          Some(ControlRequest::InspectRequest { id }) => {
              let validation = validate_request_id(&id);
              if let Err(error) = validation {
          assert!(!state.running);
+     }
++    #[test]
++    fn list_requests_returns_sorted_ids() {
++        let (mut client, server) = UnixStream::pair().expect("pair should be created");
++        client
++            .write_all(b"list\n")
++            .expect("list request should be written");
++
++        let mut state = DaemonState {
++            health: HealthStatus::Healthy,
++            requests: RequestRegistry::new(Duration::from_secs(5)),
++            running: true,
++        };
++        state
++            .requests
++            .begin_at(
++                "req-b",
++                RequestOwner::new(":1.2", None),
++                None,
++                Instant::now(),
++            )
++            .expect("request should be created");
++        state
++            .requests
++            .begin_at(
++                "req-a",
++                RequestOwner::new(":1.3", None),
++                None,
++                Instant::now(),
++            )
++            .expect("request should be created");
++
++        handle_connection(server, &mut state).expect("list should be handled");
++
++        let mut response_line = String::new();
++        let mut reader = BufReader::new(client);
++        reader
++            .read_line(&mut response_line)
++            .expect("response should be readable");
++        let response = ControlResponse::parse_line(&response_line).expect("response should parse");
++        assert_eq!(
++            response,
++            ControlResponse::RequestList {
++                ids: vec!["req-a".to_string(), "req-b".to_string()],
++            }
++        );
++    }
++
      #[test]
      fn invalid_request_uses_stable_error_reason() {
          let (mut client, server) = UnixStream::pair().expect("pair should be created");

garwarpctl/src/main.rsmodified

  enum Command {
      Status,
      Stop,
++    List,
      Inspect {
          id: String,
      },
          [] => Ok(Command::Status),
          [command] if command == "status" => Ok(Command::Status),
          [command] if command == "stop" => Ok(Command::Stop),
++        [command] if command == "list" => Ok(Command::List),
          [command, id] if command == "inspect" => Ok(Command::Inspect { id: id.clone() }),
          [command] if command == "version" || command == "--version" || command == "-V" => {
              Ok(Command::Version)
                  )),
+             }
+         }
++        Command::List => {
++            let response = send_request(ControlRequest::ListRequests)?;
++            match response {
++                ControlResponse::RequestList { ids } => {
++                    if ids.is_empty() {
++                        println!("ids=-");
++                    } else {
++                        for id in ids {
++                            println!("id={id}");
++                        }
++                    }
++                    Ok(())
++                }
++                ControlResponse::Error { code, reason } => Err(io::Error::other(format!(
++                    "daemon error: code={code} reason={reason}"
++                ))),
++                other => Err(io::Error::new(
++                    io::ErrorKind::InvalidData,
++                    format!("unexpected response: {other:?}"),
++                )),
++            }
++        }
          Command::Inspect { id } => {
              let response = send_request(ControlRequest::InspectRequest { id })?;
              match response {
      println!("commands:");
      println!("  status (default)");
      println!("  stop");
++    println!("  list");
      println!("  inspect <id>");
      println!("  begin <id> <sender> [app_id|-] [parent_window|-]");
      println!("  transition <id> <sender> <awaiting_user|fulfilled|cancelled|failed> [app_id|-]");
          );
+     }
++    #[test]
++    fn parse_list_command() {
++        let args = vec!["list".to_string()];
++        let command = parse_command(&args).expect("list command should parse");
++        assert_eq!(command, Command::List);
++    }
++
      #[test]
      fn parse_transition_target_rejects_unknown_state() {
          let parsed = parse_transition_target("bogus");

`@@ -23,7 +23,8 @@` Current scaffold includes:
23	4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`	23	4. Verify D-Bus activation: `./scripts/test-dbus-activation.sh`
24	5. Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`	24	5. Create mock request: `cargo run -p garwarpctl -- begin req-1 :1.2 - x11:0x2a`
25	6. Transition mock request: `cargo run -p garwarpctl -- transition req-1 :1.2 awaiting_user`	25	6. Transition mock request: `cargo run -p garwarpctl -- transition req-1 :1.2 awaiting_user`
26	-7. Inspect request snapshot: `cargo run -p garwarpctl -- inspect req-1`	26	+7. List known requests: `cargo run -p garwarpctl -- list`
		27	+8. Inspect request snapshot: `cargo run -p garwarpctl -- inspect req-1`
27		28
28	## Runtime Tuning	29	## Runtime Tuning
29	1. `GARWARP_REQUEST_TIMEOUT_MS`: timeout before in-flight requests are marked `expired`.	30	1. `GARWARP_REQUEST_TIMEOUT_MS`: timeout before in-flight requests are marked `expired`.

gardesk/garwarp / `265e97f`

4 changed files