Samuel OnojaandSamuel Onoja
6b0d903ad0
* Add Live Activities as configurable bar items * Fix activity owner monitoring and Morph list interactions * Keep activity rows stable during updates and tighten their layout * Use subtle theme tint for activity cards * Tighten activity title and progress spacing * Use theme accent for active progress rings * Fit compact activities to measured titles and badge * Expose Live Activities display controls in Settings * Open activity terminals and streamline the Morph header * Give Morph continuous icons and prioritize workspace navigation * Show activity progress inside its ring * Inset activity progress rings and strengthen their stroke * Fix activity lifecycle, command output handling and list navigation * Reduce activity update work and harden publisher lifetimes * Set up Live Activities for the detected user shell during installation * Document Activities setup, daily use and troubleshooting * Preserve Morph idle width across empty activity updates * Fix dimming flicker, hide inactive music tab and consolidate Activities docs * Fix panel clearance across styles and match previews to theme settings * Prevent panel blur from repainting neighboring islands --------- Co-authored-by: Samuel Onoja <[email protected]>
473 lines
17 KiB
Rust
473 lines
17 KiB
Rust
use std::os::unix::net::UnixListener;
|
|
use std::path::Path;
|
|
use std::process::{Command, Output};
|
|
use std::thread;
|
|
|
|
use ferese_ipc::{Request, Response, read_frame, write_frame};
|
|
use serde_json::json;
|
|
|
|
fn ctl(args: &[&str]) -> Command {
|
|
let mut command = Command::new(env!("CARGO_BIN_EXE_feresectl"));
|
|
command
|
|
.args(args)
|
|
.env_remove("FERESE_SOCKET")
|
|
.env_remove("XDG_RUNTIME_DIR");
|
|
command
|
|
}
|
|
|
|
fn serve(path: &Path, expected: &'static str, value: serde_json::Value) -> thread::JoinHandle<()> {
|
|
let listener = UnixListener::bind(path).unwrap();
|
|
thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(2)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, expected);
|
|
write_frame(&mut stream, &Response::success(request.id, value)).unwrap();
|
|
})
|
|
}
|
|
|
|
fn success(output: Output) -> String {
|
|
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
|
String::from_utf8(output.stdout).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn help_exits_successfully_without_a_session_and_has_hidden_legacy_aliases() {
|
|
for args in [
|
|
&["--help"][..],
|
|
&["theme", "--help"],
|
|
&["media", "--help"],
|
|
&["xwayland", "--help"],
|
|
&["screenshot", "--help"],
|
|
&["focus-floating", "--help"],
|
|
] {
|
|
let text = success(ctl(args).output().unwrap());
|
|
assert!(text.contains("Usage:"));
|
|
assert!(!text.contains("get-outputs"));
|
|
}
|
|
let output = ctl(&["widows"]).output().unwrap();
|
|
assert_eq!(output.status.code(), Some(2));
|
|
let error = String::from_utf8(output.stderr).unwrap();
|
|
assert!(error.contains("windows"), "{error}");
|
|
}
|
|
|
|
#[test]
|
|
fn focus_floating_sends_a_parameterless_action_and_rejects_cycle_arguments() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("control.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(2)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, "focus-floating");
|
|
assert_eq!(request.args, json!({}));
|
|
write_frame(&mut stream, &Response::success(request.id, json!({}))).unwrap();
|
|
});
|
|
success(
|
|
ctl(&["--socket", socket.to_str().unwrap(), "focus-floating"])
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
worker.join().unwrap();
|
|
let output = ctl(&["focus-floating", "next"]).output().unwrap();
|
|
assert_eq!(output.status.code(), Some(2));
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_socket_targets_the_nested_instance_for_queries_and_theme_commands() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let nested = directory.path().join("nested.sock");
|
|
let host = directory.path().join("host.sock");
|
|
let host_listener = UnixListener::bind(&host).unwrap();
|
|
host_listener.set_nonblocking(true).unwrap();
|
|
for args in [
|
|
vec!["--socket", nested.to_str().unwrap(), "-j", "windows"],
|
|
vec!["theme", "mode", "dark", "--socket", nested.to_str().unwrap(), "--json"],
|
|
] {
|
|
let worker = serve(
|
|
&nested,
|
|
if args[0] == "theme" {
|
|
"theme-set-mode"
|
|
} else {
|
|
"get-windows"
|
|
},
|
|
json!({"instance": "nested"}),
|
|
);
|
|
let output = success(ctl(&args).env("FERESE_SOCKET", &host).output().unwrap());
|
|
assert_eq!(
|
|
serde_json::from_str::<serde_json::Value>(&output).unwrap(),
|
|
json!({"instance": "nested"})
|
|
);
|
|
worker.join().unwrap();
|
|
std::fs::remove_file(&nested).unwrap();
|
|
assert_eq!(
|
|
host_listener.accept().unwrap_err().kind(),
|
|
std::io::ErrorKind::WouldBlock
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn socket_environment_and_runtime_fallback_use_the_same_query_path() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
std::fs::create_dir(directory.path().join("ferese")).unwrap();
|
|
let socket = directory.path().join("ferese/control.sock");
|
|
for environment in ["FERESE_SOCKET", "XDG_RUNTIME_DIR"] {
|
|
let worker = serve(&socket, "outputs", json!([{"name": "nested", "enabled": true}]));
|
|
let target = if environment == "FERESE_SOCKET" {
|
|
socket.as_path()
|
|
} else {
|
|
directory.path()
|
|
};
|
|
let output = success(ctl(&["outputs"]).env(environment, target).output().unwrap());
|
|
assert!(output.contains("name: nested"));
|
|
assert!(!output.contains('"'));
|
|
worker.join().unwrap();
|
|
std::fs::remove_file(&socket).unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn legacy_queries_are_hidden_aliases_with_an_explicit_json_flag() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("control.sock");
|
|
let worker = serve(&socket, "get-workspaces", json!([]));
|
|
let output = ctl(&["--socket", socket.to_str().unwrap(), "get-workspaces", "-j"])
|
|
.output()
|
|
.unwrap();
|
|
assert!(String::from_utf8_lossy(&output.stderr).contains("deprecated; use workspaces"));
|
|
assert_eq!(success(output).trim(), "[]");
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn event_stream_uses_the_selected_socket_and_prints_complete_json_lines() {
|
|
use ferese_ipc::events::{Change, Event, VERSION};
|
|
use std::io::{BufRead, BufReader};
|
|
use std::process::Stdio;
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("events.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let event = Event {
|
|
version: VERSION,
|
|
generation: 7,
|
|
last: true,
|
|
change: Change::LockChanged {
|
|
lock: ferese_ipc::events::LockState {
|
|
phase: "locked".into(),
|
|
sleeping: false,
|
|
},
|
|
},
|
|
};
|
|
let expected = event.clone();
|
|
let (stop, stopped) = std::sync::mpsc::channel();
|
|
let worker = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.command, "event-stream");
|
|
assert_eq!(request.args["version"], VERSION);
|
|
write_frame(&mut stream, &Response::success(request.id, json!({"version": VERSION}))).unwrap();
|
|
write_frame(&mut stream, &event).unwrap();
|
|
stopped.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
|
|
});
|
|
let mut child = ctl(&["event-stream", "--socket", socket.to_str().unwrap()])
|
|
.stdout(Stdio::piped())
|
|
.spawn()
|
|
.unwrap();
|
|
let mut line = String::new();
|
|
BufReader::new(child.stdout.take().unwrap())
|
|
.read_line(&mut line)
|
|
.unwrap();
|
|
assert_eq!(serde_json::from_str::<Event>(&line).unwrap(), expected);
|
|
child.kill().unwrap();
|
|
child.wait().unwrap();
|
|
stop.send(()).unwrap();
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn activity_start_uses_versioned_framing_and_parent_scope() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let socket = dir.path().join("activity.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let server = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
assert_eq!(request.version, ferese_ipc::VERSION);
|
|
assert_eq!(request.command, "activity-publish");
|
|
let wire: ferese_ipc::activities::Request = serde_json::from_value(request.args).unwrap();
|
|
assert!(matches!(wire.owner, ferese_ipc::activities::OwnerScope::Parent));
|
|
match wire.publish {
|
|
ferese_ipc::activities::Publish::Start { local, data, .. } => {
|
|
assert_eq!(local, "build");
|
|
assert_eq!(data.value, ferese_activities::Value::Indeterminate);
|
|
}
|
|
_ => panic!("wrong activity action"),
|
|
}
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(request.id, json!({"handle":{"generation":1}})),
|
|
)
|
|
.unwrap();
|
|
});
|
|
success(
|
|
ctl(&[
|
|
"--socket",
|
|
socket.to_str().unwrap(),
|
|
"activity",
|
|
"start",
|
|
"build",
|
|
"--title",
|
|
"Build",
|
|
])
|
|
.output()
|
|
.unwrap(),
|
|
);
|
|
server.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn run_preserves_arguments_cwd_environment_output_and_exit_when_publishing_fails() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let output = ctl(&[
|
|
"--socket",
|
|
"/missing/ferese.sock",
|
|
"run",
|
|
"--title",
|
|
"Test",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf '%s|%s|%s' \"$1\" \"$ACTIVITY_TEST_VALUE\" \"$PWD\"; printf stderr >&2; exit 17",
|
|
"sh",
|
|
"argument with spaces;$literal",
|
|
])
|
|
.env("ACTIVITY_TEST_VALUE", "preserved")
|
|
.current_dir(dir.path())
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(17));
|
|
assert_eq!(
|
|
String::from_utf8(output.stdout).unwrap(),
|
|
format!("argument with spaces;$literal|preserved|{}", dir.path().display())
|
|
);
|
|
assert_eq!(output.stderr, b"stderr");
|
|
}
|
|
|
|
#[test]
|
|
fn run_preserves_child_exit_and_signal_status() {
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let output = ctl(&[
|
|
"run",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf '{\"reason\":\"build-finished\",\"success\":true}\\n'; exit 19",
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(19));
|
|
let output = ctl(&["run", "--", "sh", "-c", "kill -TERM $$"]).output().unwrap();
|
|
assert_eq!(output.status.signal(), Some(libc::SIGTERM));
|
|
}
|
|
|
|
#[test]
|
|
fn wrapper_forwards_termination_and_preserves_job_control_group() {
|
|
use std::os::unix::process::{CommandExt, ExitStatusExt};
|
|
let mut command = ctl(&["run", "--", "sh", "-c", "kill -STOP $$; sleep 30"]);
|
|
unsafe {
|
|
command.pre_exec(|| {
|
|
libc::setpgid(0, 0);
|
|
Ok(())
|
|
});
|
|
}
|
|
let mut child = command.spawn().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_millis(150));
|
|
let pid = child.id() as i32;
|
|
assert_eq!(unsafe { libc::kill(-pid, libc::SIGCONT) }, 0);
|
|
assert_eq!(unsafe { libc::kill(pid, libc::SIGTERM) }, 0);
|
|
assert_eq!(child.wait().unwrap().signal(), Some(libc::SIGTERM));
|
|
}
|
|
|
|
#[test]
|
|
fn terminal_ctrl_c_reaches_child_and_wrapper_returns_sigint() {
|
|
use std::os::unix::process::{CommandExt, ExitStatusExt};
|
|
let mut command = ctl(&["run", "--", "sleep", "30"]);
|
|
unsafe {
|
|
command.pre_exec(|| {
|
|
libc::setpgid(0, 0);
|
|
Ok(())
|
|
});
|
|
}
|
|
let mut child = command.spawn().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_millis(150));
|
|
assert_eq!(unsafe { libc::kill(-(child.id() as i32), libc::SIGINT) }, 0);
|
|
assert_eq!(child.wait().unwrap().signal(), Some(libc::SIGINT));
|
|
}
|
|
|
|
#[test]
|
|
fn a_silent_broker_cannot_prevent_or_change_command_execution() {
|
|
let directory = tempfile::tempdir().unwrap();
|
|
let socket = directory.path().join("blocked.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (_stream, _) = listener.accept().unwrap();
|
|
std::thread::sleep(std::time::Duration::from_secs(3));
|
|
});
|
|
let began = std::time::Instant::now();
|
|
let result = ctl(&[
|
|
"--socket",
|
|
socket.to_str().unwrap(),
|
|
"run",
|
|
"--",
|
|
"sh",
|
|
"-c",
|
|
"printf executed; exit 23",
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(result.stdout, b"executed");
|
|
assert_eq!(result.status.code(), Some(23));
|
|
assert!(began.elapsed() < std::time::Duration::from_secs(3));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
fn fake_cargo(dir: &Path, script: &str) -> String {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let path = dir.join("cargo");
|
|
std::fs::write(&path, script).unwrap();
|
|
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
|
format!("{}:{}", dir.display(), std::env::var("PATH").unwrap_or_default())
|
|
}
|
|
|
|
#[test]
|
|
fn cargo_adapter_completion_does_not_wait_for_descendant_stdout() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = fake_cargo(
|
|
dir.path(),
|
|
"#!/bin/sh\nsleep 5 &\necho $! > descendant\nprintf captured\nexit 23\n",
|
|
);
|
|
let output = dir.path().join("output");
|
|
let mut child = ctl(&[
|
|
"--socket",
|
|
"/missing/activity.sock",
|
|
"run",
|
|
"--cargo-json",
|
|
"--",
|
|
"cargo",
|
|
"build",
|
|
])
|
|
.env("PATH", path)
|
|
.current_dir(dir.path())
|
|
.stdout(std::fs::File::create(&output).unwrap())
|
|
.stderr(std::process::Stdio::null())
|
|
.spawn()
|
|
.unwrap();
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
|
|
let status = loop {
|
|
if let Some(status) = child.try_wait().unwrap() {
|
|
break Some(status);
|
|
}
|
|
if std::time::Instant::now() >= deadline {
|
|
child.kill().unwrap();
|
|
child.wait().unwrap();
|
|
break None;
|
|
}
|
|
thread::sleep(std::time::Duration::from_millis(10));
|
|
};
|
|
let descendant: i32 = std::fs::read_to_string(dir.path().join("descendant"))
|
|
.unwrap()
|
|
.trim()
|
|
.parse()
|
|
.unwrap();
|
|
unsafe {
|
|
libc::kill(descendant, libc::SIGTERM);
|
|
}
|
|
assert_eq!(
|
|
status.and_then(|status| status.code()),
|
|
Some(23),
|
|
"waited for descendant EOF"
|
|
);
|
|
assert_eq!(std::fs::read(&output).unwrap(), b"captured");
|
|
}
|
|
|
|
#[test]
|
|
fn stalled_progress_acknowledgements_do_not_block_cargo_stdout() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = fake_cargo(
|
|
dir.path(),
|
|
r##"#!/usr/bin/env python3
|
|
import json, time, sys
|
|
start = time.monotonic()
|
|
time.sleep(.3)
|
|
for _ in range(20000):
|
|
print('{"reason":"compiler-artifact"}')
|
|
sys.stdout.flush()
|
|
with open('elapsed', 'w') as f:
|
|
f.write(str(time.monotonic() - start))
|
|
print('{"reason":"build-finished","success":true}')
|
|
print('child output')
|
|
print(json.dumps({'reason': 'compiler-message', 'message': {'rendered': 'diagnostic\n'}}))
|
|
sys.exit(19)
|
|
"##,
|
|
);
|
|
let socket = dir.path().join("broker.sock");
|
|
let listener = UnixListener::bind(&socket).unwrap();
|
|
listener.set_nonblocking(true).unwrap();
|
|
let server = thread::spawn(move || {
|
|
let mut stalled = Vec::new();
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
|
|
while std::time::Instant::now() < deadline {
|
|
let Ok((mut stream, _)) = listener.accept() else {
|
|
thread::sleep(std::time::Duration::from_millis(5));
|
|
continue;
|
|
};
|
|
stream
|
|
.set_read_timeout(Some(std::time::Duration::from_secs(1)))
|
|
.unwrap();
|
|
let request: Request = read_frame(&mut stream).unwrap();
|
|
match request.args["publish"]["action"].as_str().unwrap() {
|
|
"run" => {
|
|
let handle = ferese_activities::Id {
|
|
owner: ferese_activities::Owner { pid: 1, birth: 1 },
|
|
local: request.args["publish"]["local"].as_str().unwrap().into(),
|
|
session: 1,
|
|
generation: 1,
|
|
};
|
|
write_frame(
|
|
&mut stream,
|
|
&Response::success(request.id, json!({"handle":handle,"progress":"cargo-json"})),
|
|
)
|
|
.unwrap();
|
|
}
|
|
"update" => stalled.push(stream), // Accept the update but never acknowledge it.
|
|
"end" => {
|
|
assert_eq!(request.args["publish"]["result"], "failed");
|
|
write_frame(&mut stream, &Response::success(request.id, json!({}))).unwrap();
|
|
return stalled.len();
|
|
}
|
|
_ => panic!("unexpected publication"),
|
|
}
|
|
}
|
|
panic!("completion was not published");
|
|
});
|
|
let output = ctl(&["--socket", socket.to_str().unwrap(), "run", "--", "cargo", "build"])
|
|
.env("PATH", path)
|
|
.current_dir(dir.path())
|
|
.output()
|
|
.unwrap();
|
|
assert_eq!(output.status.code(), Some(19));
|
|
assert_eq!(output.stdout, b"child output\ndiagnostic\n");
|
|
assert!(server.join().unwrap() > 0, "probe must exercise progress publishing");
|
|
let elapsed: f64 = std::fs::read_to_string(dir.path().join("elapsed"))
|
|
.unwrap()
|
|
.parse()
|
|
.unwrap();
|
|
assert!(elapsed < 1.5, "stdout reader stalled the child for {elapsed}s");
|
|
}
|